/// <summary>
/// Gives the 'available' amount inventory + queued
/// queueSize total amount of queued items indicator for workload
/// </summary>
private static int AvailableAmount(IMyProductionBlock productionBlock, VRage.Game.MyDefinitionId materialId, VRage.Game.MyDefinitionBase blueprintDefinition, out int queueSize)
{
var queue = productionBlock.GetQueue();
var inventory = productionBlock.OutputInventory;
var inventoryItems = inventory != null?inventory.GetItems() : null;
var amount = 0;
queueSize = 0;
if (inventoryItems != null)
{
foreach (var item in inventoryItems)
{
if (item.Content.TypeId == materialId.TypeId && item.Content.SubtypeId == materialId.SubtypeId)
{
amount += (int)item.Amount;
}
}
}
if (queue != null)
{
foreach (var item in queue)
{
queueSize += (int)item.Amount;
if (item.Blueprint.Id.Equals(blueprintDefinition.Id))
{
amount += (int)item.Amount;
}
}
}
return(amount);
}
public Program()
{
//set update frequency
Runtime.UpdateFrequency = UpdateFrequency.Update100;
//create block objects and verify existency
prgblk = GridTerminalSystem.GetBlockWithName(prgblk_name) as IMyProgrammableBlock;
Verify_availability(prgblk);
assembler = GridTerminalSystem.GetBlockWithName(assembler_name) as IMyProductionBlock;
Verify_availability(assembler);
//debug to status panel
if (dbg_to_panel)
{
status_panel = GridTerminalSystem.GetBlockWithName(status_panel_name) as IMyTextSurface;
Verify_availability(status_panel);
}
//read stored config
if (Storage.Length != 0)
{
string[] stored_config = Storage.Split('\n');
Write_settings_header();
Read_stored_settings(stored_config);
}
}
/// <summary>
/// Gives the 'available' amount inventory + queued
/// queueSize total amount of queued items indicator for workload
/// </summary>
private static int AvailableAmount(IMyProductionBlock productionBlock, VRage.Game.MyDefinitionId materialId, VRage.Game.MyDefinitionBase blueprintDefinition, out int queueSize)
{
var queue = productionBlock.GetQueue();
var inventory = productionBlock.OutputInventory;
var tempInventoryItems = new List <VRage.Game.ModAPI.Ingame.MyInventoryItem>();
if (inventory != null)
{
inventory.GetItems(tempInventoryItems);
}
var amount = 0;
queueSize = 0;
foreach (var item in tempInventoryItems)
{
if ((VRage.Game.MyDefinitionId)item.Type == materialId)
{
amount += (int)item.Amount;
}
}
if (queue != null)
{
foreach (var item in queue)
{
queueSize += (int)item.Amount;
if (item.Blueprint.Id.Equals(blueprintDefinition.Id))
{
amount += (int)item.Amount;
}
}
}
return(amount);
}
public ProductionUnit(Program parent, IMyProductionBlock production)
{
parent_ = parent;
production_ = production;
production_.UseConveyorSystem = true;
}
private void DisableGrid(IMyCubeGrid grid)
{
HashSet <long> disabledBlocks = new HashSet <long>();
List <IMySlimBlock> blocks = new List <IMySlimBlock>();
grid.GetBlocks(blocks);
foreach (IMySlimBlock block in blocks)
{
if (block.FatBlock == null)
{
continue;
}
IMyCubeBlock cubeBlock = block.FatBlock;
if (!(cubeBlock is IMyFunctionalBlock))
{
continue;
}
if (cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_Reactor) ||
cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_Thrust) ||
cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_Battery) ||
cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_SolarPanel) ||
cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_Gyro) ||
cubeBlock.BlockDefinition.TypeId == typeof(MyObjectBuilder_MedicalRoom))
{
continue;
}
if (cubeBlock is IMyProductionBlock)
{
IMyProductionBlock productionBlock = (IMyProductionBlock)cubeBlock;
if (productionBlock.IsProducing)
{
continue;
}
}
if (FunctionalBlockEntity.GetState(cubeBlock))
{
FunctionalBlockEntity.SetState(cubeBlock, false);
disabledBlocks.Add(cubeBlock.EntityId);
m_enableCount++;
}
}
lock (GridDisabled)
{
GridDisabled.Add(grid.EntityId);
//if (disabledBlocks.Count > 0)
//{
Console.WriteLine("Adding");
GridBlocksDisabled.Add(grid.EntityId, disabledBlocks);
//}
}
}
public Production(IMyProductionBlock block, Logistics logistics)
{
this.block = block;
this.name = block.CustomName;
this.logistics = logistics;
input = new Container(block.InputInventory, block.CustomName, logistics);
output = new Container(block.OutputInventory, block.CustomName, logistics);
input.canFilter = false;
}
bool tryAddAssemblerTask(IMyProductionBlock assembler, string definition, VRage.MyFixedPoint count)
{
try {
MyDefinitionId objectIdToAdd = new MyDefinitionId();
MyDefinitionId.TryParse(definition, out objectIdToAdd);
assembler.AddQueueItem(objectIdToAdd, count);
return(true);
} catch (Exception e) {
return(false);
}
}
List <IMyFunctionalBlock> Everything; // Now this.... This is an Absolute Madness
void GetNeededBlocks()
{
List <IMyFunctionalBlock> temp = new List <IMyFunctionalBlock>();
GridTerminalSystem.GetBlocksOfType(temp);
Power = new List <IMyPowerProducer>();
Batteries = new List <IMyBatteryBlock>();
Reactors = new List <IMyReactor>();
Producers = new List <IMyProductionBlock>();
Tanks = new List <IMyGasTank>();
Everything = new List <IMyFunctionalBlock>();
foreach (IMyFunctionalBlock block in temp)
{
if (isOnThisGrid(block))
{
Everything.Add(block);
if (block is IMyPowerProducer)
{
IMyPowerProducer power = (IMyPowerProducer)block;
Power.Add(power);
if (block is IMyBatteryBlock)
{
IMyBatteryBlock battery = (IMyBatteryBlock)block;
Batteries.Add(battery);
}
else
if (block is IMyReactor)
{
IMyReactor reactor = (IMyReactor)block;
Reactors.Add(reactor);
}
}
else
if (block is IMyProductionBlock)
{
IMyProductionBlock producer = (IMyProductionBlock)block;
Producers.Add(producer);
}
else
if (block is IMyGasTank)
{
IMyGasTank tank = (IMyGasTank)block;
if (tank.BlockDefinition.SubtypeName.Contains("HydrogenTank"))
{
Tanks.Add(tank);
}
}
}
}
}
public static bool IsValidInventoryConnection(object FactoryBlockInv, object TargetBlockInv, out IMyInventory inv)
{
inv = null;
try
{
MyInventory FactoryInv = (MyInventory)FactoryBlockInv;
MyEntity TargetInv = null;
if (TargetBlockInv is IMySlimBlock && ((IMySlimBlock)TargetBlockInv).FatBlock != null)
{
TargetInv = (MyEntity)((IMyEntity)(((IMySlimBlock)TargetBlockInv).FatBlock));
}
else if (TargetBlockInv is MyInventory || TargetBlockInv is IMyInventory)
{
TargetInv = ((MyInventory)TargetBlockInv).Owner;
}
MyCubeBlock FactoryInvBlock = (MyCubeBlock)FactoryInv.Owner;
if (TargetInv == null || FactoryInv == null || FactoryInvBlock == null || !TargetInv.HasInventory)
{
return(false);
}
MyCubeBlock InvBlock = TargetInv as MyCubeBlock;
if (InvBlock == null)
{
return(false);
}
IMyProductionBlock prodblock = TargetInv as IMyProductionBlock; //assembler
inv = (prodblock != null && prodblock.OutputInventory != null) ? prodblock.OutputInventory : ((IMyEntity)TargetInv).GetInventory();
if (inv == null || !InvBlock.IsFunctional || NaniteConstructionManager.NaniteBlocks.ContainsKey(TargetInv.EntityId) ||
TargetInv is Sandbox.ModAPI.Ingame.IMyReactor || !inv.IsConnectedTo((IMyInventory)FactoryInv) ||
!MyRelationsBetweenPlayerAndBlockExtensions.IsFriendly(FactoryInvBlock.GetUserRelationToOwner(InvBlock.OwnerId)))
{
return(false);
}
return(true);
}
catch (Exception e)
{
Logging.Instance.WriteLine($"IsValidInventoryConnection exception:\n{e}.");
return(false);
}
}
// adds assembling or disassembling task for specified itemId and count
public bool AddAssemblerTask(IMyProductionBlock assembler, string itemId, VRage.MyFixedPoint count)
{
var fixedItemId = "MyObjectBuilder_BlueprintDefinition/" + itemId.Split('/')[1];
if (fixedItemId.EndsWith("Item"))
{
fixedItemId = fixedItemId.Substring(0, fixedItemId.Count() - 4);
}
if (!tryAddAssemblerTask(assembler, fixedItemId, count))
{
var fixedItemId2 = fixedItemId + "Component";
if (!tryAddAssemblerTask(assembler, fixedItemId2, count))
{
Print(string.Format("AddQueueItem failed for {0}", itemId));
Print(string.Format("tried: {0}, {1}", fixedItemId, fixedItemId2));
return(false);
}
}
//Print(string.Format("queued: {0} x {1}", itemId, count));
return(true);
}
protected override void update()
{
for (;
blockIndex_ < Blocks.Count &&
App.Runtime.CurrentInstructionCount < Default.MaxInstructionCount;
blockIndex_++)
{
IMyProductionBlock block = Blocks[blockIndex_] as IMyProductionBlock;
blocksOn_ += isOn(block) ? 1 : 0;
blocksFunctional_ += block.IsFunctional ? 1 : 0;
// get list of all items in the queue
List <MyProductionItem> queue = new List <MyProductionItem>();
block.GetQueue(queue);
long currentAmount = 0;
// rebuild current amount with current production state
foreach (var item in queue)
{
currentAmount += (long)item.Amount;
currentQueuedItems_ += (long)item.Amount;
int index = items_.FindIndex((entry) => entry.BlueprintId == item.BlueprintId.ToString());
if (index >= 0)
{
items_[index].CurrentAmount += (long)item.Amount;
}
else
{
items_.Add(new ProductionItem(item));
}
}
currentPerBlock_[block.EntityId] = currentAmount;
maxPerBlock_[block.EntityId] = currentAmount == 0 ? 0 : Math.Max(maxPerBlock_[block.EntityId], currentAmount);
}
UpdateFinished = blockIndex_ >= Blocks.Count;
}
public void DrawMachine(Drawing drawing, Vector2 position, IMyProductionBlock block, List <Item> items, Style style)
{
float size_icon = style.Height - 10;
Color color_title = new Color(100, 100, 100, 128);
Color color_text = new Color(100, 100, 100, 255);
float RotationOrScale = 0.5f;
float cell_spacing = 10f;
float form_width = style.Width - 5;
float form_height = style.Height - 5;
string colorDefault = DisplayLcd.program.MyProperty.Get("color", "default");
float x = 0f;
drawing.AddForm(position + new Vector2(0, 0), SpriteForm.SquareSimple, form_width, form_height, new Color(5, 5, 5, 125));
foreach (Item item in items)
{
// icon
drawing.AddSprite(new MySprite()
{
Type = SpriteType.TEXTURE,
Data = item.Icon,
Size = new Vector2(size_icon, size_icon),
Color = DisplayLcd.program.MyProperty.GetColor("color", item.Name, colorDefault),
Position = position + new Vector2(x, size_icon / 2 + cell_spacing)
});
if (drawing.Symbol.Keys.Contains(item.Name))
{
// symbol
Vector2 positionSymbol = position + new Vector2(x, 20);
drawing.AddForm(positionSymbol, SpriteForm.SquareSimple, size_icon, 15f, new Color(10, 10, 10, 200));
drawing.AddSprite(new MySprite()
{
Type = SpriteType.TEXT,
Data = drawing.Symbol[item.Name],
Color = color_text,
Position = positionSymbol,
RotationOrScale = RotationOrScale,
FontId = drawing.Font,
Alignment = TextAlignment.LEFT
});
}
// Quantity
Vector2 positionQuantity = position + new Vector2(x, size_icon - 12);
Color mask_color = new Color(0, 0, 20, 200);
if (item.Variance == 2)
{
mask_color = new Color(20, 0, 0, 200);
}
if (item.Variance == 3)
{
mask_color = new Color(0, 20, 0, 200);
}
drawing.AddForm(positionQuantity, SpriteForm.SquareSimple, size_icon, 15f, mask_color);
drawing.AddSprite(new MySprite()
{
Type = SpriteType.TEXT,
Data = Util.GetKiloFormat(item.Amount),
Color = color_text,
Position = positionQuantity,
RotationOrScale = RotationOrScale,
FontId = drawing.Font,
Alignment = TextAlignment.LEFT
});
x += style.Height;
}
// Element Name
MySprite icon = new MySprite()
{
Type = SpriteType.TEXT,
Data = Util.CutString(block.CustomName, string_len),
Color = color_title,
Position = position + new Vector2(style.Margin.X, 0),
RotationOrScale = 0.6f,
FontId = drawing.Font,
Alignment = TextAlignment.LEFT
};
drawing.AddSprite(icon);
}
public List <Item> TraversalMachine(IMyProductionBlock block)
{
int loop = 0;
List <Item> items = new List <Item>();
Dictionary <string, double> last_amount;
if (last_machine_amount.ContainsKey(block.EntityId))
{
last_amount = last_machine_amount[block.EntityId];
}
else
{
last_amount = new Dictionary <string, double>();
last_machine_amount.Add(block.EntityId, last_amount);
}
if (block is IMyAssembler)
{
List <MyProductionItem> productionItems = new List <MyProductionItem>();
block.GetQueue(productionItems);
if (productionItems.Count > 0)
{
loop = 0;
foreach (MyProductionItem productionItem in productionItems)
{
if (loop >= max_loop)
{
break;
}
string iName = Util.GetName(productionItem);
string iType = Util.GetType(productionItem);
string key = String.Format("{0}_{1}", iType, iName);
MyDefinitionId itemDefinitionId = productionItem.BlueprintId;
double amount = 0;
Double.TryParse(productionItem.Amount.ToString(), out amount);
int variance = 2;
if (last_amount.ContainsKey(key))
{
if (last_amount[key] < amount)
{
variance = 1;
}
if (last_amount[key] > amount)
{
variance = 3;
}
last_amount[key] = amount;
}
else
{
variance = 1;
last_amount.Add(key, amount);
}
items.Add(new Item()
{
Name = iName,
Type = iType,
Amount = amount,
Variance = variance
});
loop++;
}
}
}
else
{
List <MyInventoryItem> inventoryItems = new List <MyInventoryItem>();
block.InputInventory.GetItems(inventoryItems);
if (inventoryItems.Count > 0)
{
loop = 0;
foreach (MyInventoryItem inventoryItem in inventoryItems)
{
if (loop >= max_loop)
{
break;
}
string iName = Util.GetName(inventoryItem);
string iType = Util.GetType(inventoryItem);
string key = String.Format("{0}_{1}", iType, iName);
double amount = 0;
Double.TryParse(inventoryItem.Amount.ToString(), out amount);
int variance = 2;
if (last_amount.ContainsKey(key))
{
if (last_amount[key] < amount)
{
variance = 1;
}
if (last_amount[key] > amount)
{
variance = 3;
}
last_amount[key] = amount;
}
else
{
variance = 1;
last_amount.Add(key, amount);
}
items.Add(new Item()
{
Name = iName,
Type = iType,
Amount = amount,
Variance = variance
});
loop++;
}
}
}
last_machine_amount[block.EntityId] = last_amount;
return(items);
}
public bool init()
{
IMyBlockGroup group = GridTerminalSystem.GetBlockGroupWithName(groupName_);
if (group != null)
{
pistons_.Clear();
drills_.Clear();
group.GetBlocksOfType <IMyTerminalBlock>(null, (block) =>
{
IMyPistonBase piston = block as IMyPistonBase;
if (piston != null)
{
PistonController controller = new PistonController(this, piston);
pistons_.Add(controller);
return(false);
}
IMyMotorStator stator = block as IMyMotorStator;
if (stator != null)
{
drillRotor_ = new RotorController(this, stator);
return(false);
}
IMyShipDrill drill = block as IMyShipDrill;
if (drill != null)
{
drills_.Add(drill);
return(false);
}
// production block
IMyProductionBlock pu = block as IMyProductionBlock;
if (pu != null)
{
production_ = new ProductionUnit(this, pu);
return(false);
}
IMyCargoContainer container = block as IMyCargoContainer;
if (container != null)
{
containers_.Add(container);
return(false);
}
return(false);
});
}
else
{
addMessageLine("Error: Minig Group not found!");
return(false);
}
// check drills
if (drills_.Count == 0)
{
addMessageLine("Error: No drills found!");
return(false);
}
// read config
miningDepth_ = GetConfigMiningDepth();
return(true);
}
public ProductionBlock(Program program, IMyProductionBlock block)
{
this.idleTime = -1;
this.block = block;
this.program = program;
}
public bool InitialiseAssembler()
{
_assembler = GridTerminalSystem.GetBlockWithName(_assemblerName) as IMyProductionBlock;
return(_assembler != null);
}
public Production(IMyProductionBlock block)
{
IsProducing = block.IsProducing;
IsQueueEmpty = block.IsQueueEmpty;
block.GetQueue(Queue);
}
