public static BlockSystem <T> SearchByFilter(Program program, BlockFilter <T> filter)
{
List <T> list = new List <T>();
try
{
if (filter.ByGroup)
{
List <IMyBlockGroup> groups = new List <IMyBlockGroup>();
program.GridTerminalSystem.GetBlockGroups(groups, filter.GroupVisitor());
List <T> group_list = new List <T>();
groups.ForEach(delegate(IMyBlockGroup group)
{
group_list.Clear();
group.GetBlocksOfType <T>(list, filter.BlockVisitor());
list.AddList(group_list);
});
}
else
{
program.GridTerminalSystem.GetBlocksOfType <T>(list, filter.BlockVisitor());
}
}
catch { }
program.Echo(String.Format("List<{0}>:{1}", filter.Value, list.Count));
return(new BlockSystem <T>()
{
program = program,
List = list
});
}
private void ReadFilters(BinaryReader reader, long baseStreamOffset = 0)
{
int nonLastSizeChangers = 0;
for (int i = 0; i < _numFilters; i++)
{
var filter = BlockFilter.Read(reader);
if ((i + 1 == _numFilters && !filter.AllowAsLast) ||
(i + 1 < _numFilters && !filter.AllowAsNonLast))
{
throw new InvalidDataException("Block Filters in bad order");
}
if (filter.ChangesDataSize && i + 1 < _numFilters)
{
nonLastSizeChangers++;
}
filter.ValidateFilter();
Filters.Push(filter);
}
if (nonLastSizeChangers > 2)
{
throw new InvalidDataException("More than two non-last block filters cannot change stream size");
}
int blockHeaderPaddingSize = BlockHeaderSize -
(4 + (int)(reader.BaseStream.Position - baseStreamOffset));
byte[] blockHeaderPadding = reader.ReadBytes(blockHeaderPaddingSize);
if (!blockHeaderPadding.All(b => b == 0))
{
throw new InvalidDataException("Block header contains unknown fields");
}
}
public static bool CanCreate(ICoreClientAPI api, Entity entity)
{
if (api.Side.IsClient())
{
if (ConfigLoader.Config.FDShow)
{
var playerEntity = api.World.Player.Entity;
var playerPos = playerEntity.Pos.XYZ.AddCopy(playerEntity.LocalEyePos);
var entityPos = entity.Pos.XYZ.AddCopy(entity.LocalEyePos);
var blockSel = new BlockSelection();
var entitySel = new EntitySelection();
if (playerPos.DistanceTo(entityPos) > ConfigLoader.Config.FDRange)
{
return(false);
}
BlockFilter bFilter = (pos, block) => block.CollisionBoxes != null;
api.World.RayTraceForSelection(playerPos, entityPos, ref blockSel, ref entitySel, bFilter);
return(entitySel?.Entity?.Equals(entity) ?? false);
}
}
return(false);
}
public int NewBlockFilter()
{
BlockFilter filter = _filterStore.CreateBlockFilter(_blockTree.Head.Number);
_filterStore.SaveFilter(filter);
return(filter.Id);
}
public bool RayIntersectsBlockSelectionBox(BlockPos pos, BlockFilter filter)
{
if (filter?.Invoke(pos, blockSelectionTester.GetBlock(pos)) == false)
{
return(false);
}
Cuboidf[] selectionBoxes = blockSelectionTester.GetBlockIntersectionBoxes(pos);
if (selectionBoxes == null)
{
return(false);
}
bool intersects = false;
for (int i = 0; i < selectionBoxes.Length; i++)
{
tmpCuboidd.Set(selectionBoxes[i]).Translate(pos.X, pos.Y, pos.Z);
if (RayIntersectsWithCuboid(tmpCuboidd, ref hitOnBlockFaceTmp, ref hitPositionTmp))
{
if (intersects && hitPosition.SquareDistanceTo(ray.origin) <= hitPositionTmp.SquareDistanceTo(ray.origin))
{
continue;
}
hitOnSelectionBox = i;
intersects = true;
hitOnBlockFace = hitOnBlockFaceTmp;
hitPosition.Set(hitPositionTmp);
}
}
return(intersects);
}
public void GetBlockByHash(NodeCoreAdminClient adminClient)
{
Console.WriteLine("GetBlockByHash");
Console.WriteLine("NC_CLI command: getblockfromhash <blockHash>");
String blockHash = "0000000000002A866690AF6E6B7B784151DDB0565BE16EE0";
BlockFilter filter = new BlockFilter();
filter.Hash = blockHash.ToByteString();
GetBlocksRequest request = new GetBlocksRequest();
request.Filters.Add(filter);
request.SearchLength = 2000;
GetBlocksReply reply = adminClient.AdminClient.GetBlocks(request);
if (reply.Success)
{
if (reply.Blocks.Count > 0)
{
//Display info
int iBlockIndex = reply.Blocks[0].Number;
Console.WriteLine("BlockIndex={0}", iBlockIndex);
}
}
Console.WriteLine("--------------------");
Console.WriteLine();
}
public void GetBlockByIndex(NodeCoreAdminClient adminClient)
{
Console.WriteLine("GetBlockByIndex");
Console.WriteLine("NC_CLI command: getblockfromindex <blockIndex>");
int iBlockIndex = 100;
BlockFilter filter = new BlockFilter();
filter.Index = iBlockIndex;
GetBlocksRequest request = new GetBlocksRequest();
request.Filters.Add(filter);
request.SearchLength = 2000;
GetBlocksReply reply = adminClient.AdminClient.GetBlocks(request);
if (reply.Success)
{
if (reply.Blocks.Count > 0)
{
//Display info
String blockHash = reply.Blocks[0].Hash.ToHexString();
Console.WriteLine("BlockHash={0}", blockHash);
}
}
Console.WriteLine("--------------------");
Console.WriteLine();
}
private void Search()
{
BlockFilter <IMyTextPanel> block_filter = BlockFilter <IMyTextPanel> .Create(Me, MyProperty.lcd_filter);
lcds = BlockSystem <IMyTextPanel> .SearchByFilter(this, block_filter);
search = false;
}
private void Search()
{
BlockFilter <IMyProductionBlock> block_filter = BlockFilter <IMyProductionBlock> .Create(DisplayLcd.lcd, filter);
producers = BlockSystem <IMyProductionBlock> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
private void Search()
{
BlockFilter <IMyShipDrill> block_filter = BlockFilter <IMyShipDrill> .Create(DisplayLcd.lcd, filter);
drill_inventories = BlockSystem <IMyShipDrill> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
private void Search()
{
BlockFilter <IMyTerminalBlock> block_filter = BlockFilter <IMyTerminalBlock> .Create(DisplayLcd.lcd, filter);
block_filter.HasInventory = true;
inventories = BlockSystem <IMyTerminalBlock> .SearchByFilter(DisplayLcd.program, block_filter);
search = false;
}
public void Can_save_and_load_block_filter()
{
FilterStore store = new();
BlockFilter filter = store.CreateBlockFilter(1);
store.SaveFilter(filter);
Assert.True(store.FilterExists(0), "exists");
Assert.AreEqual(FilterType.BlockFilter, store.GetFilterType(filter.Id), "type");
}
public void Cannot_overwrite_filters()
{
FilterStore store = new FilterStore();
BlockFilter externalFilter = new BlockFilter(100, 1);
store.SaveFilter(externalFilter);
Assert.Throws <InvalidOperationException>(() => store.SaveFilter(externalFilter));
}
public IEnumerable <BlockData> GetBlocks(BlockFilter blockFilter = null)
{
var blockData = new List <BlockData>();
var collection = Database.GetCollection <MongoBlockData>(Blocks);
var builder = Builders <MongoBlockData> .Filter;
var filterDefs = new List <FilterDefinition <MongoBlockData> >();
if (blockFilter != null)
{
if (!string.IsNullOrWhiteSpace(blockFilter.BlockId))
{
filterDefs.Add(builder.Eq(x => x.Hash, blockFilter.BlockId));
}
if (!string.IsNullOrWhiteSpace(blockFilter.TxId))
{
filterDefs.Add(builder.Where(x => x.Transactions.Select(t => t.Hash).Contains(blockFilter.TxId)));
}
if (!string.IsNullOrWhiteSpace(blockFilter.ScriptPubKey))
{
filterDefs.Add(builder.Where(x => x.Transactions.Any(t => t.Outputs.Any(o => o.ScriptPubKey == blockFilter.ScriptPubKey))));
}
if (blockFilter.UnSpents != null && blockFilter.UnSpents.Any())
{
filterDefs.Add(builder.Where(x => x.Transactions.Any(t => t.Inputs.Any(i => blockFilter.UnSpents.Contains(i.PrevOut.Hash)))));
}
var filterDef = filterDefs.Any() ? filterDefs.Aggregate((x, y) => x & y) : builder.Empty;
var blocks = collection.Find <MongoBlockData>(filterDef).ToList();
if (!string.IsNullOrWhiteSpace(blockFilter.SenderPubKey))
{
var blocksSpents =
blocks.Where(
b =>
b.Transactions.Any(
t =>
t.Inputs.Any(
i => TransactionHelper.IsFrom(blockFilter.SenderPubKey, i.ScriptSig))));
foreach (var block in blocksSpents)
{
blockData.Add(block);
}
}
else
{
foreach (var block in blocks)
{
blockData.Add(block);
}
}
}
return(blockData);
}
public BlockData GetBlock(string blockId)
{
var blockFilter = new BlockFilter {
BlockId = blockId
};
var blocks = DataService.GetBlocks(blockFilter);
return(blocks.FirstOrDefault());
}
/// <summary>
/// Get certain blocks based on a filter
/// </summary>
/// <param name="filter">Filter to get blocks</param>
/// <param name="onscreen">Should the blocks be visible on the screen</param>
/// <returns>Array of filtered blocks</returns>
public Block[] GetAllBlocks(BlockFilter filter, bool onscreen)
{
List <Block> blocks = new List <Block>();
for (int i = 0; i < chunks.Count; i++)
{
blocks.AddRange(chunks[i].GetBlocks(filter, onscreen));
}
return(blocks.ToArray());
}
private void Search()
{
BlockFilter <IMyDoor> block_filter1 = BlockFilter <IMyDoor> .Create(Me, "*");
doors = BlockSystem <IMyDoor> .SearchByFilter(this, block_filter1);
BlockFilter <IMySensorBlock> block_filter2 = BlockFilter <IMySensorBlock> .Create(Me, "*");
sensors = BlockSystem <IMySensorBlock> .SearchByFilter(this, block_filter2);
}
private void ConnectStream()
{
_decomStream = BaseStream;
while (Filters.Any())
{
BlockFilter filter = Filters.Pop();
filter.SetBaseStream(_decomStream);
_decomStream = filter;
}
_streamConnected = true;
}
public BlockSelection GetSelectedBlock(Vec3d from, Vec3d to, BlockFilter filter = null)
{
LoadRayAndPos(new Line3D()
{
Start = new double[] { from.X, from.Y, from.Z },
End = new double[] { to.X, to.Y, to.Z }
});
float maxDistance = from.DistanceTo(to);
return(GetSelectedBlock(maxDistance, filter));
}
private void Assert(IEnumerable <Action <FilterBuilder> > filterBuilders,
IEnumerable <Action <ReceiptBuilder> > receiptBuilders,
Action <IEnumerable <FilterLog> > logsAssertion)
{
var filters = new List <FilterBase>();
var receipts = new List <TxReceipt>();
foreach (var filterBuilder in filterBuilders)
{
filters.Add(BuildFilter(filterBuilder));
}
foreach (var receiptBuilder in receiptBuilders)
{
receipts.Add(BuildReceipt(receiptBuilder));
}
// adding always a simple block filter and test
Block block = Build.A.Block.TestObject;
BlockFilter blockFilter = new BlockFilter(_currentFilterId++, 0);
filters.Add(blockFilter);
_filterStore.GetFilters <LogFilter>().Returns(filters.OfType <LogFilter>().ToArray());
_filterStore.GetFilters <BlockFilter>().Returns(filters.OfType <BlockFilter>().ToArray());
_filterManager = new FilterManager(_filterStore, _blockProcessor, _txPool, _logManager);
_blockProcessor.BlockProcessed += Raise.EventWith(_blockProcessor, new BlockProcessedEventArgs(block));
var index = 1;
foreach (var receipt in receipts)
{
_blockProcessor.TransactionProcessed += Raise.EventWith(_blockProcessor,
new TxProcessedEventArgs(index, Build.A.Transaction.TestObject, receipt));
index++;
}
NUnit.Framework.Assert.Multiple(() =>
{
foreach (var filter in filters.OfType <LogFilter>())
{
var logs = _filterManager.GetLogs(filter.Id);
logsAssertion(logs);
}
var hashes = _filterManager.GetBlocksHashes(blockFilter.Id);
NUnit.Framework.Assert.AreEqual(1, hashes.Length);
});
}
public void Remove_filter_removes_and_notifies()
{
FilterStore store = new();
BlockFilter filter = store.CreateBlockFilter(1);
store.SaveFilter(filter);
bool hasNotified = false;
store.FilterRemoved += (s, e) => hasNotified = true;
store.RemoveFilter(0);
Assert.True(hasNotified, "notied");
Assert.False(store.FilterExists(0), "exists");
}
public void Ids_are_incremented_when_storing_externally_created_filter()
{
FilterStore store = new FilterStore();
BlockFilter externalFilter = new BlockFilter(100, 1);
store.SaveFilter(externalFilter);
LogFilter filter = store.CreateLogFilter(new FilterBlock(1), new FilterBlock(2));
store.SaveFilter(filter);
Assert.True(store.FilterExists(100), "exists 100");
Assert.True(store.FilterExists(101), "exists 101");
Assert.AreEqual(FilterType.LogFilter, store.GetFilterType(filter.Id), "type");
}
public static List <IMyBlockGroup> SearchGroupFilter(Program program, BlockFilter <T> filter)
{
List <IMyBlockGroup> groups = new List <IMyBlockGroup>();
try
{
if (filter.ByGroup)
{
program.GridTerminalSystem.GetBlockGroups(groups, filter.GroupVisitor());
}
}
catch { }
program.Echo(String.Format("List <{0}> count: {1}", filter.Value, groups.Count));
return(groups);
}
private void Search()
{
BlockFilter <IMyBlockGroup> group_filter = BlockFilter <IMyBlockGroup> .Create(Me, MyProperty.filter);
Groups = BlockSystem <IMyBlockGroup> .SearchGroupFilter(this, group_filter);
Airlocks = new List <Airlock>();
if (Groups != null)
{
Groups.ForEach(delegate(IMyBlockGroup group)
{
Airlocks.Add(new Airlock(this, group.Name));
});
}
}
public BlockSelection GetSelectedBlock(float maxDistance, BlockFilter filter = null)
{
float distanceSq = 0;
// Get the face where our ray will exit
BlockFacing lastExitedBlockFace = GetExitingFullBlockFace(pos, ref lastExitedBlockFacePos);
if (lastExitedBlockFace == null)
{
return(null);
}
float maxDistanceSq = (maxDistance + 1) * (maxDistance + 1);
// Wander along the block exiting faces until we collide with a block selection box
while (!RayIntersectsBlockSelectionBox(pos, filter))
{
if (distanceSq >= maxDistanceSq)
{
return(null);
}
pos.Offset(lastExitedBlockFace);
lastExitedBlockFace = GetExitingFullBlockFace(pos, ref lastExitedBlockFacePos);
if (lastExitedBlockFace == null)
{
return(null);
}
distanceSq = pos.DistanceSqTo(ray.origin.X - 0.5f, ray.origin.Y - 0.5f, ray.origin.Z - 0.5f);
}
if (hitPosition.SquareDistanceTo(ray.origin) > maxDistance * maxDistance)
{
return(null);
}
return(new BlockSelection()
{
Face = hitOnBlockFace,
Position = pos.Copy(),
HitPosition = hitPosition.SubCopy(pos.X, pos.Y, pos.Z),
SelectionBoxIndex = hitOnSelectionBox
});
}
static void BlockTest()
{
IScheduledItem item =
new BlockFilter(
new SimpleInterval(DateTime.Parse("1/01/2004"), TimeSpan.FromMinutes(15)),
"Daily",
"6:00 AM",
"5:00 PM");
TestItem(item, new DateTime(2004, 1, 1), true, new DateTime(2004, 1, 1, 6, 15, 0));
TestItem(item, new DateTime(2004, 1, 1, 6, 0, 0), true, new DateTime(2004, 1, 1, 6, 0, 0));
TestItem(item, new DateTime(2004, 1, 1, 6, 0, 0), false, new DateTime(2004, 1, 1, 6, 15, 0));
TestItem(item, new DateTime(2004, 1, 1, 6, 0, 1), true, new DateTime(2004, 1, 1, 6, 15, 0));
TestItem(item, new DateTime(2004, 1, 1, 6, 15, 0), true, new DateTime(2004, 1, 1, 6, 15, 0));
TestItem(item, new DateTime(2004, 1, 1, 16, 45, 0), false, new DateTime(2004, 1, 1, 17, 0, 0));
TestItem(item, new DateTime(2004, 1, 1, 17, 1, 0), true, new DateTime(2004, 1, 2, 6, 15, 0));
}
public bool RayIntersectsBlockSelectionBox(BlockPos pos, BlockFilter filter)
{
if (filter?.Invoke(pos, blockSelectionTester.GetBlock(pos)) == false)
{
return(false);
}
Cuboidf[] selectionBoxes = blockSelectionTester.GetBlockIntersectionBoxes(pos);
if (selectionBoxes == null)
{
return(false);
}
bool intersects = false;
bool wasDecor = false;
for (int i = 0; i < selectionBoxes.Length; i++)
{
tmpCuboidd.Set(selectionBoxes[i]).Translate(pos.X, pos.Y, pos.Z);
if (RayIntersectsWithCuboid(tmpCuboidd, ref hitOnBlockFaceTmp, ref hitPositionTmp))
{
bool isDecor = selectionBoxes[i] is DecorSelectionBox;
if (intersects && (!wasDecor || isDecor) && hitPosition.SquareDistanceTo(ray.origin) <= hitPositionTmp.SquareDistanceTo(ray.origin))
{
continue;
}
hitOnSelectionBox = i;
intersects = true;
wasDecor = isDecor;
hitOnBlockFace = hitOnBlockFaceTmp;
hitPosition.Set(hitPositionTmp);
}
}
if (intersects && selectionBoxes[hitOnSelectionBox] is DecorSelectionBox dsb)
{
Vec3i posAdjust = dsb.PosAdjust;
if (posAdjust != null)
{
pos.Add(posAdjust);
}
}
return(intersects);
}
public void Can_get_filters_by_type()
{
FilterStore store = new();
BlockFilter filter1 = store.CreateBlockFilter(1);
store.SaveFilter(filter1);
LogFilter filter2 = store.CreateLogFilter(new BlockParameter(1), new BlockParameter(2));
store.SaveFilter(filter2);
LogFilter[] logFilters = store.GetFilters <LogFilter>().ToArray();
BlockFilter[] blockFilters = store.GetFilters <BlockFilter>().ToArray();
Assert.AreEqual(1, logFilters.Length, "log filters length");
Assert.AreEqual(1, logFilters[0].Id, "log filters ids");
Assert.AreEqual(1, blockFilters.Length, "block Filters length");
Assert.AreEqual(0, blockFilters[0].Id, "block filters ids");
}
void RunContinuousLogic()
{
if (search)
{
Search();
}
WriteText($"LCD found: {(lcds != null ? lcds.List.Count : 0)}", false);
BlockFilter <IMyThrust> block_filter = BlockFilter <IMyThrust> .Create(Me, "C:Up");
BlockSystem <IMyThrust> thrust = BlockSystem <IMyThrust> .SearchByFilter(this, block_filter);
if (!thrust.IsEmpty)
{
ParserInfo parser = new ParserInfo(this);
IMyThrust block = thrust.First;
parser.ParserTitle(block);
parser.ParserTerminalBlock(block);
parser.ParserThrust(block);
parser.ParserCubeBlock(block);
}
}
private void Prepare()
{
BlockFilter <IMyRefinery> filterRefinery = new BlockFilter <IMyRefinery>()
{
CubeGrid = Me.CubeGrid
};
refinery = BlockSystem <IMyRefinery> .SearchByFilter(this, filterRefinery);
refinery.ForEach(delegate(IMyRefinery block)
{
block.UseConveyorSystem = false;
});
BlockFilter <IMyCargoContainer> filterContainer = new BlockFilter <IMyCargoContainer>()
{
Filter = "Ore",
CubeGrid = Me.CubeGrid
};
stock = BlockSystem <IMyCargoContainer> .SearchByFilter(this, filterContainer);
}
