public static bool Prefix(float dt, ValveBase __instance, float ___currentFlow, int ___outputCell, int ___inputCell, HandleVector <int> .Handle ___flowAccumulator)
{
ConduitFlow flowManager = Conduit.GetFlowManager(__instance.conduitType);
if (!flowManager.HasConduit(___inputCell) || !flowManager.HasConduit(___outputCell))
{
__instance.UpdateAnim();
}
else
{
ConduitFlow.ConduitContents input_content = flowManager.GetConduit(___inputCell).GetContents(flowManager);
ConduitFlow.ConduitContents output_content = flowManager.GetConduit(___outputCell).GetContents(flowManager);
float mass_input = Mathf.Min(input_content.mass, ___currentFlow * dt);
float mass_output = output_content.mass;
float mass_limit = Mathf.Max(___currentFlow - mass_output, 0); // mass on output cannot exceed flow setting
mass_input = Mathf.Min(mass_input, mass_limit); // set new input mass
if (mass_input > 0f)
{
float disease_percent = mass_input / input_content.mass;
int disease_count = (int)(disease_percent * input_content.diseaseCount);
float mass_moved = flowManager.AddElement(___outputCell, input_content.element, mass_input, input_content.temperature, input_content.diseaseIdx, disease_count);
Game.Instance.accumulators.Accumulate(___flowAccumulator, mass_moved);
if (mass_moved > 0f)
{
flowManager.RemoveElement(___inputCell, mass_moved);
}
}
__instance.UpdateAnim();
}
return(false);
}
public bool CanConvertAtAll()
{
float filterAmt = 0;
float liquidAmt = 0;
List <GameObject> items = this.storage.items;
PrimaryElement elem = null;
foreach (GameObject item in items)
{
elem = item.GetComponent <PrimaryElement>();
if (elem.ElementID == SimHashes.BleachStone)
{
filterAmt += elem.Mass;
}
else if (elem.Element.IsLiquid /*&& elem.DiseaseIdx != Byte.MaxValue*/)
{
liquidAmt += elem.Mass;
}
}
if (filterAmt <= 0.1f || liquidAmt <= 0.1f)
{
return(false); // non-zero to prevent constant activity
}
ConduitFlow flowManager = Conduit.GetFlowManager(ConduitType.Liquid);
return(flowManager.HasConduit(outCell));
}
protected override void ConduitUpdate(float dt)
{
this.currentValue = 0;
// spawn code should never toggle as it crashes on load
if (dt < 0)
{
return;
}
int cell = Grid.PosToCell(this);
ConduitFlow flowManager = Conduit.GetFlowManager(this.conduitType);
if (flowManager.HasConduit(cell))
{
if (flowManager != null)
{
var conduit = flowManager.GetConduit(cell);
var lastFlow = conduit.GetLastFlowInfo(flowManager);
if (lastFlow.direction != ConduitFlow.FlowDirections.None)
{
this.currentValue = (lastFlow.contents.mass) * 1000;
}
}
}
if (this.activateAboveThreshold)
{
// Empty is always false
if (this.currentValue <= 0f)
{
if (base.IsSwitchedOn)
{
this.Toggle();
}
return;
}
// Full is always true
if (this.currentValue >= this.max)
{
if (!base.IsSwitchedOn)
{
this.Toggle();
}
return;
}
if ((this.currentValue > this.threshold && !base.IsSwitchedOn) || (this.currentValue <= this.threshold && base.IsSwitchedOn))
{
this.Toggle();
}
}
else if ((this.currentValue > this.threshold && base.IsSwitchedOn) || (this.currentValue <= this.threshold && !base.IsSwitchedOn))
{
this.Toggle();
}
}
private void ConduitUpdate(float dt)
{
ConduitFlow flowManager = Conduit.GetFlowManager(portInfo.conduitType);
if (flowManager.HasConduit(inputCell))
{
ConduitFlow.ConduitContents contents = flowManager.GetContents(inputCell);
if (!(contents.mass <= 0f))
{
int cell = outputCell;
ConduitFlow.ConduitContents contents2 = flowManager.GetContents(cell);
if (contents2.mass > 0f)
{
cell = secondaryOutput.Cell;
contents2 = flowManager.GetContents(cell);
}
if (contents2.mass <= 0f)
{
float num = flowManager.AddElement(cell, contents.element, contents.mass, contents.temperature, contents.diseaseIdx, contents.diseaseCount);
if (num > 0f)
{
flowManager.RemoveElement(inputCell, num);
}
}
}
}
}
private static bool Prefix(ValveBase __instance, float dt, int ___inputCell, int ___outputCell)
{
if (__instance.conduitType != LiquidWarpConfig.CONDUIT_TYPE && __instance.conduitType != GasWarpConfig.CONDUIT_TYPE)
{
return(true);
}
int channelNo = Mathf.RoundToInt(__instance.CurrentFlow * 1000.0f); // simple cast to int sometimes gives invalid result
Logger.LogFormat(" === ValveBase.ConduitUpdate({0}) Prefix conduitType={1}, inputCell={2}, outputCell={3}, channelNo={4}", dt, __instance.conduitType, ___inputCell, ___outputCell, channelNo);
if (channelNo == 10000)
{
// Channel number is set to MaxFlow (10k), which means WarpGate is disabled
return(false);
}
ConduitFlow flowManager = null;
if (__instance.conduitType == LiquidWarpConfig.CONDUIT_TYPE)
{
flowManager = Conduit.GetFlowManager(ConduitType.Liquid);
}
else if (__instance.conduitType == GasWarpConfig.CONDUIT_TYPE)
{
flowManager = Conduit.GetFlowManager(ConduitType.Gas);
}
if (!flowManager.HasConduit(___inputCell) || !flowManager.HasConduit(___outputCell))
{
__instance.UpdateAnim();
}
if (flowManager.HasConduit(___outputCell) && !flowManager.IsConduitFull(___outputCell))
{
WarpSpaceManager.RequestFluidFromChannel(__instance, channelNo);
__instance.UpdateAnim();
return(false);
}
return(false);
}
private bool SetContents(int cell, ConduitType conduitType, Element element, float mass, float temperature, byte diseaseIdx, int diseaseCount)
{
if (conduitType == ConduitType.Solid)
{
var conduitFlow = Game.Instance.solidConduitFlow;
if (!conduitFlow.HasConduit(cell))
{
return(false);
}
mass = Mathf.Clamp(mass, 0, MAX_SOLID_MASS);
var res = element.substance.SpawnResource(Vector3.zero, mass, temperature, diseaseIdx, diseaseCount);
var pc = res.GetComponent <Pickupable>();
var p = conduitFlow.RemovePickupable(cell);
if (p != null)
{
DestroyPickupable(p);
}
conduitFlow.SetContents(cell, pc);
updateSolidFlowVisualization = true;
}
else
{
ConduitFlow conduitFlow = conduitType == ConduitType.Liqud
? Game.Instance.liquidConduitFlow
: Game.Instance.gasConduitFlow;
if (!conduitFlow.HasConduit(cell))
{
return(false);
}
var maxMass = conduitType == ConduitType.Liqud ? MAX_LIQUID_MASS : MAX_GAS_MASS;
mass = Mathf.Clamp(mass, 0, maxMass);
var contents = new ConduitFlow.ConduitContents(element.id, mass, temperature, diseaseIdx, diseaseCount);
conduitFlow.SetContents(cell, contents);
if (conduitType == ConduitType.Liqud)
{
updateLiquidFlowVisualization = true;
}
else
{
updateGasFlowVisualization = true;
}
}
return(true);
}
//Since our input/output ports are inert, we must define the behavior of the ports ourself.
//float dt is the amount of time that has passed. typically not used as far as i am aware, likely always just 1 (1 second)
private void OnConduitTick(float dt)
{
//The ConduitFlow task is an overarching flow manager for a specific conduit type. If our bridge is a liquid bridge, we will get the liquid manager.
ConduitFlow flowManager = Conduit.GetFlowManager(conduitType);
//If there is a pipe connected to the location of the input port, and a pipe connected to the location of the output port
if (flowManager.HasConduit(inputPort.GetPortCell()) && flowManager.HasConduit(outputPort.GetPortCell()))
{
//Get the contents of the input pipe
ConduitFlow.ConduitContents contents = flowManager.GetContents(inputPort.GetPortCell());
if (contents.mass > 0f)
{
//The AddElement method will attempt to move as much fluid from the input to the output as it can, and will return the amount successfully moved (if any).
//This method also handles things such as merging disease amounts and temperature based on how much is moved
float amountMOved = flowManager.AddElement(outputPort.GetPortCell(), contents.element, contents.mass, contents.temperature, contents.diseaseIdx, contents.diseaseCount);
if (amountMOved > 0f)
{
//RemoveElement, similar to AddElement, automatically reduces the disease count (if any germs are present)
flowManager.RemoveElement(inputPort.GetPortCell(), amountMOved);
}
}
}
}
private void ConduitUpdate(float dt)
{
ConduitFlow flowManager = Conduit.GetFlowManager(this.conduitType);
if (!flowManager.HasConduit(this.inputCell) || !flowManager.HasConduit(this.outputCell))
{
this.UpdateAnim();
}
else
{
ConduitFlow.ConduitContents input_content = flowManager.GetConduit(this.inputCell).GetContents(flowManager);
ConduitFlow.ConduitContents output_content = flowManager.GetConduit(this.outputCell).GetContents(flowManager);
float mass_input = Mathf.Min(input_content.mass, this.CurrentFlow * dt);
float mass_output = output_content.mass;
if (limitPressure)
{
float mass_limit = Mathf.Max(this.CurrentFlow - mass_output, 0); // mass on output cannot exceed flow setting
mass_input = Mathf.Min(mass_input, mass_limit); // set new input mass
}
if (mass_input > 0f)
{
float disease_percent = mass_input / input_content.mass;
int disease_count = (int)(disease_percent * input_content.diseaseCount);
float mass_moved = flowManager.AddElement(this.outputCell, input_content.element, mass_input, input_content.temperature, input_content.diseaseIdx, disease_count);
Game.Instance.accumulators.Accumulate(this.flowAccumulator, mass_moved);
if (mass_moved > 0f)
{
flowManager.RemoveElement(this.inputCell, mass_moved);
}
}
this.UpdateAnim();
}
}
private void ConduitUpdate(float dt)
{
ConduitFlow flowManager = Conduit.GetFlowManager(type);
if (flowManager.HasConduit(inputCell))
{
ConduitFlow.ConduitContents contents = flowManager.GetContents(inputCell);
if (contents.mass > 0f)
{
float num = flowManager.AddElement(outputCell, contents.element, contents.mass, contents.temperature, contents.diseaseIdx, contents.diseaseCount);
if (num > 0f)
{
flowManager.RemoveElement(inputCell, num);
Game.Instance.accumulators.Accumulate(accumulator, contents.mass);
}
}
}
}
private void ConduitUpdate(float dt)
{
//If the building is broken, nothing normally stops it from operating!
if (gameObject.GetComponent <BuildingHP>().HitPoints == 0)
{
return;
}
ConduitFlow manager = Conduit.GetFlowManager(valveBase.conduitType);
ConduitFlow.Conduit inputConduit = manager.GetConduit(InputCell);
ConduitFlow.Conduit outputConduit = manager.GetConduit(OutputCell);
if (!manager.HasConduit(InputCell) || !manager.HasConduit(OutputCell))
{
valveBase.UpdateAnim();
}
else
{
ConduitFlow.ConduitContents inputContents = inputConduit.GetContents(manager);
if (!bufferMode)
{
float valveFlow = valveBase.CurrentFlow * dt;
float maxFlow;
float temp;
SimHashes element;
byte diseaseIdx;
float ratio;
int disease_count;
bool fromStorage = false;
Tag storedTag = Tag.Invalid;
if (!storage.IsEmpty())
{
//If there is still mass within the storage but we are not in buffer mode, take nothing in until the storage is emptied! (while still following the limit mode settings)
fromStorage = true;
GameObject item = storage.items.FirstOrDefault();
PrimaryElement storedPrimary = item.GetComponent <PrimaryElement>();
maxFlow = Mathf.Min(valveFlow, storedPrimary.Mass);
element = storedPrimary.ElementID;
temp = storedPrimary.Temperature;
diseaseIdx = storedPrimary.DiseaseIdx;
ratio = maxFlow / storedPrimary.Mass;
disease_count = (int)(ratio * (float)storedPrimary.DiseaseCount);
storedTag = storedPrimary.Element.tag;
}
else
{
maxFlow = Mathf.Min(inputContents.mass, valveBase.CurrentFlow * dt);
element = inputContents.element;
temp = inputContents.temperature;
diseaseIdx = inputContents.diseaseIdx;
ratio = maxFlow / inputContents.mass;
disease_count = (int)(ratio * (float)inputContents.diseaseCount);
}
if (maxFlow > 0f)
{
float movableMass = manager.AddElement(OutputCell, element, maxFlow, temp, diseaseIdx, disease_count);
Game.Instance.accumulators.Accumulate(flowAccumulator, movableMass);
if (movableMass > 0f)
{
//If we took the mass from storage, make sure we use the right function
if (!fromStorage)
{
manager.RemoveElement(InputCell, movableMass);
}
else
{
storage.ConsumeIgnoringDisease(storedTag, movableMass);
}
}
}
}
else
{
float availableInput = inputContents.mass;
GameObject storedItem = storage.items.FirstOrDefault();
Element storedElement = storedItem?.GetComponent <PrimaryElement>().Element;
float storedMass = storedItem != null?storedItem.GetComponent <PrimaryElement>().Mass : 0f;
float maxOutputCapacity = Integration.GetMaxCapacityAt(OutputCell, valveBase.conduitType);
//Override the set current flow if the output pipe cannot support a flow that large. This prevents the valve from storing, for example, 3KG, when it can only output 1KG at a time.
float minimumOutput = Mathf.Min(maxOutputCapacity, valveBase.CurrentFlow);
storage.capacityKg = maxOutputCapacity;
float movableToStorage = Mathf.Min(availableInput, storage.RemainingCapacity());
if (movableToStorage > 0f)
{
Element inputElement = ElementLoader.FindElementByHash(inputContents.element);
float ratio = movableToStorage / inputContents.mass;
int transferredDisease = (int)((float)inputContents.diseaseCount * ratio);
if (inputElement == storedElement || storedItem == null)
{
if (valveBase.conduitType == ConduitType.Gas)
{
storage.AddGasChunk(inputContents.element, movableToStorage, inputContents.temperature, inputContents.diseaseIdx, transferredDisease, false);
}
else
{
storage.AddLiquid(inputContents.element, movableToStorage, inputContents.temperature, inputContents.diseaseIdx, transferredDisease, false);
}
storedMass += movableToStorage;
if (storedItem == null)
{
storedElement = inputElement;
}
}
else
{
//The input has a different element than what is in storage! Deal damage and remove however much mass attempted to flow into the valve.
Trigger(-794517298, new BuildingHP.DamageSourceInfo
{
damage = 1,
source = STRINGS.BUILDINGS.DAMAGESOURCES.BAD_INPUT_ELEMENT,
popString = STRINGS.UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.WRONG_ELEMENT
});
SimMessages.AddRemoveSubstance(Grid.PosToCell(base.transform.GetPosition()), inputContents.element, CellEventLogger.Instance.ConduitConsumerWrongElement, movableToStorage, inputContents.temperature, inputContents.diseaseIdx, transferredDisease);
}
manager.RemoveElement(InputCell, movableToStorage);
}
ConduitFlow.ConduitContents outputContents = outputConduit.GetContents(manager);
float initialOutputMass = outputContents.mass;
Element outputElement = ElementLoader.FindElementByHash(outputContents.element);
//If we can create a packet of at least size CurrentFlow, including if we combined the valve's output into what is already in the output conduit
//Debug.Log($"[TogglableValve] InitialOut: {initialOutputMass}, StoredMass: {storedMass}, MinimumOutput: {minimumOutput}, MaxOutputCapacity: {maxOutputCapacity}, AvailableInput: {availableInput}, MovableToStorage: {movableToStorage}");
if (initialOutputMass + storedMass >= minimumOutput && (storedElement == outputElement || outputElement == null || outputElement.id == SimHashes.Vacuum))
{
float movableToOut = Mathf.Min(storedMass, maxOutputCapacity - initialOutputMass);
if (movableToOut > 0f)
{
PrimaryElement storedPrimary = storage.items.FirstOrDefault()?.GetComponent <PrimaryElement>();
float ratio = movableToOut / storedMass;
int transferredDisease = (int)((float)storedPrimary.DiseaseCount * ratio);
float totalMovedOut = manager.AddElement(OutputCell, storedPrimary.ElementID, storedMass, storedPrimary.Temperature, storedPrimary.DiseaseIdx, transferredDisease);
Game.Instance.accumulators.Accumulate(flowAccumulator, totalMovedOut);
if (totalMovedOut > 0f)
{
storage.ConsumeIgnoringDisease(storedPrimary.Element.tag, totalMovedOut);
}
}
}
}
valveBase.UpdateAnim();
}
}
private void ConvertMass()
{
float filterAmt = 0;
List <GameObject> items = this.storage.items;
PrimaryElement elem = null;
foreach (GameObject item in items)
{
elem = item.GetComponent <PrimaryElement>();
if (elem.ElementID == SimHashes.BleachStone)
{
filterAmt += elem.Mass;
}
}
if (filterAmt <= 0)
{
return;
}
float maxGerms = Mathf.Min(GERMS_PER_KG * MAX_KG_PER_SEC, (int)(filterAmt * GERMS_PER_KG));
float removedAmount = 0;
ConduitFlow flowManager = Conduit.GetFlowManager(ConduitType.Liquid);
if (!flowManager.HasConduit(inCell) || !flowManager.HasConduit(outCell))
{
return;
}
foreach (GameObject item in items)
{
elem = item.GetComponent <PrimaryElement>();
if (elem.Element.IsLiquid)
{
float mass = Mathf.Min(10f, elem.Mass);
float disease = elem.DiseaseCount / elem.Mass * mass;
if (elem.DiseaseIdx == Byte.MaxValue)
{
disease = 0;
}
if (disease > maxGerms)
{
mass = mass * maxGerms / disease;
disease = maxGerms;
}
float trueMass = flowManager.AddElement(outCell, elem.ElementID, mass, elem.Temperature, Byte.MaxValue, 0);
if (trueMass < mass)
{
disease = disease * trueMass / mass;
mass = trueMass;
}
elem.Mass -= mass;
elem.ModifyDiseaseCount(-(int)disease, "");
removedAmount = disease;
Game.Instance.accumulators.Accumulate(fluidProcessedLastTick, mass);
if (mass > 0)
{
break;
}
}
}
if (removedAmount > 0)
{
float removal = (float)removedAmount / GERMS_PER_KG;
storage.ConsumeIgnoringDisease(ElementLoader.FindElementByHash(filterIn).tag, removal);
Game.Instance.accumulators.Accumulate(filterConsumedLastTick, removal);
if (EMIT_CHLORINE)
{
float addition = (float)removedAmount / GERMS_PER_KG;
Element elementByHash = ElementLoader.FindElementByHash(filterOut);
Vector3 outVector3 = new Vector3(this.transform.GetPosition().x, this.transform.GetPosition().y, 0.0f);
int outCell = Grid.PosToCell(outVector3);
SimMessages.AddRemoveSubstance(outCell, filterOut, CellEventLogger.Instance.OxygenModifierSimUpdate, addition, 273.15f + 45f, Byte.MaxValue, 0);
}
}
//TODO: find out what the nice name is
this.storage.Trigger(-1697596308, (object)this.gameObject);
}
private static bool Prefix(ValveBase __instance, float dt)
{
Debug.Log(" === ValveBase.ConduitUpdate(" + dt + ") Prefix " + __instance.conduitType);
if (__instance.conduitType != (ConduitType)100 && __instance.conduitType != (ConduitType)101)
{
return(true);
}
FieldInfo fi1 = AccessTools.Field(typeof(ValveBase), "inputCell");
FieldInfo fi2 = AccessTools.Field(typeof(ValveBase), "outputCell");
FieldInfo fi3 = AccessTools.Field(typeof(ValveBase), "flowAccumulator");
//Debug.Log("ConduitUpdate " + dt);
ConduitFlow flowManager = Conduit.GetFlowManager(__instance.conduitType);
ConduitFlow.Conduit conduit = flowManager.GetConduit((int)fi1.GetValue(__instance));
if (!flowManager.HasConduit((int)fi1.GetValue(__instance)) || !flowManager.HasConduit((int)fi2.GetValue(__instance)))
{
__instance.UpdateAnim();
}
if ((int)fi1.GetValue(__instance) > 0 && flowManager.HasConduit((int)fi1.GetValue(__instance)) &&
((int)fi2.GetValue(__instance) > 0 && !flowManager.HasConduit((int)fi2.GetValue(__instance))))
{
ConduitFlow.ConduitContents contents = conduit.GetContents(flowManager);
//float num = Mathf.Min(contents.mass, this.currentFlow * dt);
FieldInfo fi = AccessTools.Field(typeof(ValveBase), "currentFlow");
//float num = Mathf.Min(contents.mass, (float)fi.GetValue(this) * dt);
float num = Mathf.Min(contents.mass, 10f * dt);
Debug.Log("ConduitUpdate " + num);
if (num > 0f)
{
float num2 = num / contents.mass;
int disease_count = (int)(num2 * (float)contents.diseaseCount);
Debug.Log("List " + num);
LiquidWarpData.LiquidPackets.Add(new PacketData((int)__instance.conduitType, (float)fi.GetValue(__instance), (int)fi2.GetValue(__instance), contents.element, num, contents.temperature, contents.diseaseIdx, disease_count));
//float num3 = flowManager.AddElement(this.outputCell, contents.element, num, contents.temperature, contents.diseaseIdx, disease_count);
//Game.Instance.accumulators.Accumulate(this.flowAccumulator, num3);
//float num3 = Mathf.Min(num, 10f - contents.mass);
float num3 = num;
if (num3 > 0f)
{
flowManager.RemoveElement((int)fi1.GetValue(__instance), num3);
}
}
__instance.UpdateAnim();
return(false);
}
if ((int)fi2.GetValue(__instance) > 0 && flowManager.HasConduit((int)fi2.GetValue(__instance)))
{
ConduitFlow.Conduit conduitO = flowManager.GetConduit((int)fi2.GetValue(__instance));
FieldInfo fi = AccessTools.Field(typeof(ValveBase), "currentFlow");
PacketData toRemove = null;
foreach (PacketData packet in LiquidWarpData.LiquidPackets)
{
Debug.Log("currentFlow = " + (float)fi.GetValue(__instance) + ", packet.currentFlow = " + packet.current_flow);
if ((float)fi.GetValue(__instance) == packet.current_flow &&
(int)__instance.conduitType == packet.content_type)
{
float num3 = flowManager.AddElement((int)fi2.GetValue(__instance), packet.element, packet.mass, packet.temperature, packet.disease_idx, packet.disease_count);
Debug.Log("Adding Element to pipe: " + packet.mass + "," + num3);
Game.Instance.accumulators.Accumulate((HandleVector <int> .Handle)fi3.GetValue(__instance), num3);
toRemove = packet;
break;
}
}
if (toRemove != null)
{
LiquidWarpData.LiquidPackets.Remove(toRemove);
toRemove = null;
}
__instance.UpdateAnim();
return(false);
}
return(false);
}
private void ConduitUpdate(float dt)
{
ConduitFlow flowManager = Conduit.GetFlowManager(type);
if (!flowManager.HasConduit(inputCell))
{
return;
}
if (IsOperational)
{
ConduitFlow.ConduitContents contents = flowManager.GetContents(inputCell);
if (contents.mass <= 0.0)
{
return;
}
ConduitFlow.ConduitContents contentOutput1 = flowManager.GetContents(outputCell);
ConduitFlow.ConduitContents contentOutput2 = flowManager.GetContents(secondaryOutputCell);
var maxMass = Traverse.Create(flowManager).Field("MaxMass").GetValue <float>(); //type == ConduitType.Liquid ? 10f : 1f;
var halfMass = contents.mass / 2f;
var willFitInOutput1 = maxMass - contentOutput1.mass;
var willFitInOutput2 = maxMass - contentOutput2.mass;
float delta1 = 0;
float delta2 = 0;
if (Math.Abs(willFitInOutput1) < 0.001f && Math.Abs(willFitInOutput2) < 0.001f)
{
//do nothing
}
else if (!flowManager.HasConduit(secondaryOutputCell))
{
delta1 = flowManager.AddElement(outputCell, contents.element, contents.mass, contents.temperature,
contents.diseaseIdx, contents.diseaseCount);
}
else if (!flowManager.HasConduit(outputCell))
{
delta2 = flowManager.AddElement(secondaryOutputCell, contents.element, contents.mass, contents.temperature,
contents.diseaseIdx, contents.diseaseCount);
}
else if (willFitInOutput1 >= halfMass && willFitInOutput2 >= halfMass)
{
delta1 = flowManager.AddElement(outputCell, contents.element, halfMass, contents.temperature,
contents.diseaseIdx, contents.diseaseCount / 2);
delta2 = flowManager.AddElement(secondaryOutputCell, contents.element, halfMass, contents.temperature,
contents.diseaseIdx, contents.diseaseCount / 2);
}
else if (willFitInOutput1 < halfMass)
{
var overflowOutput1 = halfMass - willFitInOutput1;
var ratio = (halfMass - overflowOutput1) / halfMass;
delta1 = flowManager.AddElement(outputCell, contents.element, halfMass - overflowOutput1,
contents.temperature, contents.diseaseIdx, (int)((contents.diseaseCount / 2f) * ratio));
delta2 = flowManager.AddElement(secondaryOutputCell, contents.element, halfMass + overflowOutput1,
contents.temperature, contents.diseaseIdx, (int)((contents.diseaseCount / 2f) * (1f / ratio)));
}
else
{
var overflowOutput2 = halfMass - willFitInOutput2;
var ratio = (halfMass - overflowOutput2) / halfMass;
delta1 = flowManager.AddElement(secondaryOutputCell, contents.element, halfMass - overflowOutput2,
contents.temperature, contents.diseaseIdx, (int)((contents.diseaseCount / 2f) * ratio));
delta2 = flowManager.AddElement(outputCell, contents.element, halfMass + overflowOutput2,
contents.temperature, contents.diseaseIdx, (int)((contents.diseaseCount / 2f) * (1f / ratio)));
}
flowManager.RemoveElement(inputCell, delta1);
flowManager.RemoveElement(inputCell, delta2);
Game.Instance.accumulators.Accumulate(accumulator, contents.mass);
}
}
private bool isValidRequestor(ValveBase warpGate)
{
return(warpGate != null && flowManager.HasConduit(warpGate.GetOutputCell()));
}
public static void RequestFluidFromChannel(ValveBase requestor, int channelNo)
{
Logger.LogFormat("==Entry WarpSpaceManager.RequestFluidFromChannel(requestor={0}, channelNo={1})", requestor.GetInstanceID(), channelNo);
try
{
ConduitFlow flowManager = null;
if (requestor.conduitType == LiquidWarpConfig.CONDUIT_TYPE)
{
flowManager = Conduit.GetFlowManager(ConduitType.Liquid);
}
else if (requestor.conduitType == GasWarpConfig.CONDUIT_TYPE)
{
flowManager = Conduit.GetFlowManager(ConduitType.Gas);
}
else
{
Logger.Log("unable to determine correct ConduitType.");
return;
}
ValveChannels channels = getChannelsForConduitType(requestor.conduitType);
ValvesList providers;
if (!channels.TryGetValue(channelNo, out providers) || (providers.Count == 0))
{
Logger.LogFormat("No providers for channel {0} found.", channelNo);
return;
}
ValveBase provider = providers.getNext();
ValveBase start = provider;
if (null == provider)
{
Logger.Log("You should never see this message! provider is null");
return;
}
int toCell = (int)valveBaseOutputCellFieldInfo.GetValue(requestor);
ConduitFlow.ConduitContents requestorContents = flowManager.GetContents(toCell);
// Fill input cell from various providers, in case when provider's conduit is not full
do
{
Logger.LogFormat("Trying to request from valveBase {0}", provider.GetInstanceID());
int fromCell = (int)valveBaseInputCellFieldInfo.GetValue(provider);
if (provider != requestor && flowManager.HasConduit(fromCell))
{
ConduitFlow.ConduitContents providerContents = flowManager.GetContents(fromCell);
float addedMass = flowManager.AddElement(toCell, providerContents.element, providerContents.mass, providerContents.temperature, providerContents.diseaseIdx, providerContents.diseaseCount);
Game.Instance.accumulators.Accumulate(provider.AccumulatorHandle, addedMass);
if (addedMass > 0f)
{
Logger.LogFormat("Adding Element to cell: requestor={0} provider={1} actually added mass={2}, element type={3}", requestor.GetInstanceID(), provider.GetInstanceID(), addedMass, providerContents.element);
flowManager.RemoveElement(fromCell, addedMass);
Game.Instance.accumulators.Accumulate(requestor.AccumulatorHandle, addedMass);
}
}
if (flowManager.IsConduitFull(toCell))
{
break;
}
provider = providers.getNext();
} while (provider != start);
}
catch (Exception ex)
{
Logger.LogFormat("Exception in WarpSpaceManager.RequestFluidFromChannel: {0}\n{1}", ex.Message, ex.StackTrace);
}
Logger.Log("==Exit WarpSpaceManager.RequestFluidFromChannel");
}
