public void AddBasicInputBlock(string blockName, string fluidName, int amount, bool useAllFluid)
{
AddBlock(blockName, BasicInput.XML_TYPE_NAME);
SetField(blockName, BasicInput.FLUID_NAME_FIELD_NAME, fluidName);
SetField(blockName, BasicInput.FLUID_AMOUNT_FIELD_NAME, amount);
SetField(blockName, BasicInput.USE_ALL_FLUID_FIELD_NAME, FluidInput.BoolToString(useAllFluid));
}
private InlineProgramInfo GetInlineProgramInfo(XmlNode node, ParserInfo parserInfo)
{
string id = node.GetAttributeValue(Block.ID_FIELD_NAME);
XmlNode mutatorNode = node.TryGetNodeWithName("mutation");
string inputCountString = mutatorNode.TryGetAttributeValue(INPUT_COUNT_ATTRIBUTE_NAME);
string outputCountString = mutatorNode.TryGetAttributeValue(OUTPUT_COUNT_ATTRIBUTE_NAME);
string variableCountString = mutatorNode.TryGetAttributeValue(VARIABLE_COUNT_ATTRIBUTE_NAME);
int inputCount = int.Parse(inputCountString ?? "0");
int outputCunt = int.Parse(outputCountString ?? "0");
int variableCount = int.Parse(variableCountString ?? "0");
if (inputCount != Inputs.Length ||
outputCunt != Outputs.Length ||
variableCount != VariableImports.Length)
{
throw new InternalParseException($"Actual argument count doesn't match expected argument count when loading the program: {ProgramName}");
}
DFG <Block> dfg = new DFG <Block>();
InlineProgramInfo info = new InlineProgramInfo();
for (int i = 0; i < Inputs.Length; i++)
{
XmlNode inputNode = node.GetInnerBlockNode(GetInputFieldName(i), parserInfo, new MissingBlockException(id, $"Input {Inputs[i]} is missing a fluid block."));
if (inputNode != null)
{
FluidInput input = XmlParser.ParseFluidInput(inputNode, dfg, parserInfo);
info.InputsFromTo.Add(Inputs[i], input);
}
}
for (int i = 0; i < Outputs.Length; i++)
{
string toName = node.GetNodeWithAttributeValue(GetOutputFieldName(i)).InnerText;
info.OutputsFromTo.Add(Outputs[i], toName);
}
for (int i = 0; i < VariableImports.Length; i++)
{
XmlNode variableNode = node.GetInnerBlockNode(GetVariableFieldName(i), parserInfo, new MissingBlockException(id, ""));
if (variableNode != null)
{
VariableBlock varBlock = (VariableBlock)XmlParser.ParseBlock(variableNode, dfg, parserInfo, false, false);
info.VariablesFromTo.Add(VariableImports[i], varBlock);
}
}
return(info);
}
public static WasteUsage Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string moduleName = ParseTools.ParseString(node, MODULE_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.WASTE, moduleName);
FluidInput fluidInput = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, INPUT_FLUID_FIELD_NAME,
new MissingBlockException(id, "Waste is missing input fluid block."));
List <FluidInput> inputs = new List <FluidInput>();
inputs.Add(fluidInput);
return(new WasteUsage(moduleName, inputs, null, id));
}
public static Block CreateUnion(string output, XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = node.GetAttributeValue(Block.ID_FIELD_NAME);
FluidInput fluidInput1 = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, FIRST_INPUT_FIELD_NAME,
new MissingBlockException(id, "Union is missing input fluid block."));
FluidInput fluidInput2 = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, SECOND_INPUT_FIELD_NAME,
new MissingBlockException(id, "Union is missing input fluid block."));
List <FluidInput> inputs = new List <FluidInput>();
inputs.Add(fluidInput1);
inputs.Add(fluidInput2);
return(new Union(inputs, output, id));
}
public static Block CreateMixer(string output, XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
FluidInput fluidInput1 = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, FirstInputFieldName,
new MissingBlockException(id, "Mixer is missing input fluid block."));
FluidInput fluidInput2 = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, SecondInputFieldName,
new MissingBlockException(id, "Mixer is missing input fluid block."));
List <FluidInput> inputs = new List <FluidInput>();
inputs.Add(fluidInput1);
inputs.Add(fluidInput2);
return(new Mixer(inputs, output, id));
}
public static Block CreateHeater(string output, XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string moduleName = ParseTools.ParseString(node, MODULE_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.HEATER, moduleName);
int temperature = (int)ParseTools.ParseFloat(node, parserInfo, id, TEMPERATURE_FIELD_NAME);
int time = (int)ParseTools.ParseFloat(node, parserInfo, id, TIME_FIELD_NAME);
FluidInput fluidInput = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, INPUT_FLUID_FIELD_NAME,
new MissingBlockException(id, "Heater is missing input fluid block."));
List <FluidInput> inputs = new List <FluidInput>();
inputs.Add(fluidInput);
return(new HeaterUsage(moduleName, inputs, output, temperature, time, id));
}
private int HandleFluidTransfers(int currentTime, FluidBlock nextOperation)
{
FluidInput input = nextOperation.InputFluids[0];
//setting a fluid variable to itself is usually used to initilize
//a variable with 0 fluid in it. So don't do anything if it already
//exists and wants to transfer all liquid.
if (nextOperation.OutputVariable == input.OriginalFluidName &&
input.UseAllFluid &&
FluidVariableLocations.ContainsKey(nextOperation.OutputVariable))
{
return(currentTime);
}
int requiredDroplets = input.GetAmountInDroplets(FluidVariableLocations);
//If there already exists droplets with the target fluid type (what the droplets should be renamed to),
//then they are overwritten. But if the overwritten droplets are the required droplets themselves
//then do nothing as they would otherwise be removed and then they can't be used.
BoardFluid targetFluidType;
if (nextOperation.OutputVariable == input.OriginalFluidName &&
FluidVariableLocations.ContainsKey(nextOperation.OutputVariable))
{
targetFluidType = FluidVariableLocations[nextOperation.OutputVariable];
}
else
{
(targetFluidType, currentTime) = RecordNewFluidType(nextOperation.OutputVariable, currentTime, nextOperation);
}
FluidVariableLocations.TryGetValue(input.OriginalFluidName, out BoardFluid inputFluid);
if (inputFluid == null)
{
throw new InternalRuntimeException($"Fluid of type \"{input.OriginalFluidName}\" was to be transfered, but fluid of this type do not exist (or have ever been created).");
}
currentTime = ExtractAndReassignDroplets(currentTime, nextOperation, requiredDroplets, targetFluidType, inputFluid);
currentTime++;
return(currentTime);
}
private int HandleUnionOperation(int currentTime, Union nextOperation)
{
FluidInput input1 = nextOperation.InputFluids[0];
FluidInput input2 = nextOperation.InputFluids[1];
int requiredDroplets1 = input1.GetAmountInDroplets(FluidVariableLocations);
int requiredDroplets2 = input2.GetAmountInDroplets(FluidVariableLocations);
//First all the droplets are assigned to an intermediate fluidtype,
//and then to the actual target fluidtype. This is necessary for the case of an union,
//where the target is also the input.
BoardFluid intermediateFluidtype;
(intermediateFluidtype, currentTime) = RecordNewFluidType(RENAME_FLUIDNAME_STRING, currentTime, nextOperation);
FluidVariableLocations.TryGetValue(input1.OriginalFluidName, out BoardFluid inputFluid1);
if (inputFluid1 == null)
{
(inputFluid1, currentTime) = RecordNewFluidType(input1.OriginalFluidName, currentTime, nextOperation);
}
FluidVariableLocations.TryGetValue(input2.OriginalFluidName, out BoardFluid inputFluid2);
if (inputFluid2 == null)
{
(inputFluid2, currentTime) = RecordNewFluidType(input2.OriginalFluidName, currentTime, nextOperation);
}
currentTime = ExtractAndReassignDroplets(currentTime, nextOperation, requiredDroplets1, intermediateFluidtype, inputFluid1);
currentTime = ExtractAndReassignDroplets(currentTime, nextOperation, requiredDroplets2, intermediateFluidtype, inputFluid2);
BoardFluid targetFluidtype;
(targetFluidtype, currentTime) = RecordNewFluidType(nextOperation.OutputVariable, currentTime, nextOperation);
int targetRequiredDroplets = requiredDroplets1 + requiredDroplets2;
currentTime = ExtractAndReassignDroplets(currentTime, nextOperation, targetRequiredDroplets, targetFluidtype, intermediateFluidtype);
FluidVariableLocations.Remove(RENAME_FLUIDNAME_STRING);
NewVariablesCreatedInThisScope.Remove(RENAME_FLUIDNAME_STRING);
return(currentTime);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.FLUID_ARRAY, arrayName);
VariableBlock indexBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INDEX_FIELD_NAME,
new MissingBlockException(id, "Missing block to define the index."));
FluidInput fluidInput = ParseTools.ParseFluidInput(node, dfg, parserInfo, id, INPUT_FLUID_FIELD_NAME,
new MissingBlockException(id, "Missing input fluid block."));
dfg.AddNode(indexBlock);
List <FluidInput> inputFluids = new List <FluidInput>();
inputFluids.Add(fluidInput);
return(new SetArrayFluid(indexBlock, arrayName, inputFluids, id));
}
