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 static bool Prefix(ConduitConsumer __instance, ConduitFlow conduit_mgr, int ___utilityCell)
{
// if we don't have the component, do nothing special
if (__instance.gameObject.GetComponent <InfiniteStorage>() == null)
{
return(true);
}
var contents = conduit_mgr.GetContents(___utilityCell);
var storage = __instance.gameObject.GetComponent <Storage>();
if (storage == null)
{
return(true);
}
var filterable = __instance.gameObject.GetComponent <TreeFilterable>();
if (filterable == null)
{
return(true);
}
// If it doesn't contain the tag, return false, don't consume
var tag = ElementLoader.FindElementByHash(contents.element).tag;
var ret = filterable.AcceptedTags.Contains(tag);
return(ret);
}
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);
}
}
}
}
}
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 float GetContainedMass()
{
int cell = Grid.PosToCell(this);
ConduitFlow flowManager = Conduit.GetFlowManager(conduitType);
return(flowManager.GetContents(cell).mass);
}
protected override void UpdateVisualState(bool force = false)
{
if (wasOn != switchedOn || force)
{
wasOn = switchedOn;
if (switchedOn)
{
animController.Play(ConduitSensor.ON_ANIMS, KAnim.PlayMode.Loop);
int cell = Grid.PosToCell(this);
ConduitFlow flowManager = Conduit.GetFlowManager(conduitType);
ConduitFlow.ConduitContents contents = flowManager.GetContents(cell);
Color32 c = Color.white;
if (contents.diseaseIdx != 255)
{
Disease disease = Db.Get().Diseases[contents.diseaseIdx];
c = disease.overlayColour;
}
animController.SetSymbolTint(TINT_SYMBOL, c);
}
else
{
animController.Play(ConduitSensor.OFF_ANIMS, KAnim.PlayMode.Once);
}
}
}
public unsafe void Sim200ms(float dt)
{
IntPtr value = ConduitTemperatureManager_Update(dt, (IntPtr)(void *)Game.Instance.simData.buildingTemperatures);
ConduitTemperatureUpdateData *ptr = (ConduitTemperatureUpdateData *)(void *)value;
int numEntries = ptr->numEntries;
if (numEntries > 0)
{
Marshal.Copy((IntPtr)(void *)ptr->temperatures, temperatures, 0, numEntries);
}
for (int i = 0; i < ptr->numFrozenHandles; i++)
{
int h = ptr->frozenHandles[i];
int handleIndex = Sim.GetHandleIndex(h);
ConduitInfo conduitInfo = this.conduitInfo[handleIndex];
ConduitFlow flowManager = Conduit.GetFlowManager(conduitInfo.type);
flowManager.FreezeConduitContents(conduitInfo.idx);
}
for (int j = 0; j < ptr->numMeltedHandles; j++)
{
int h2 = ptr->meltedHandles[j];
int handleIndex2 = Sim.GetHandleIndex(h2);
ConduitInfo conduitInfo2 = this.conduitInfo[handleIndex2];
ConduitFlow flowManager2 = Conduit.GetFlowManager(conduitInfo2.type);
flowManager2.MeltConduitContents(conduitInfo2.idx);
}
}
public static float GetMaxCapacityWithObject(int cell, ConduitType type, out GameObject obj, bool isBridge = false)
{
if (type != ConduitType.Gas && type != ConduitType.Liquid)
{
throw new System.ArgumentException($"[Pressurized] Invalid Conduit Type given to IntegrationHelper.GetMaxCapacityAt(): {type.ToString()} Type must be ConduitType.Gas or ConduitType.Liquid.", "type");
}
ConduitFlow manager = Conduit.GetFlowManager(type);
Pressurized pressurized = GetPressurizedAt(cell, type, isBridge);
if (pressurized == null)
{
obj = null;
}
else
{
obj = pressurized.gameObject;
}
if (Pressurized.IsDefault(pressurized))
{
return(manager.MaxMass());
}
else
{
return(pressurized.Info.IncreaseMultiplier * manager.MaxMass());
}
}
protected virtual void ConduitUpdate(float dt)
{
if (!SkipSetOperational)
{
this.operational.SetFlag(PortConduitDispenserBase.outputConduitFlag, this.IsConnected);
}
if (this.operational.IsOperational || this.alwaysDispense)
{
PrimaryElement primaryElement = this.FindSuitableElement();
if (primaryElement != null)
{
primaryElement.KeepZeroMassObject = true;
ConduitFlow conduitManager = this.GetConduitManager();
float num = conduitManager.AddElement(this.utilityCell, primaryElement.ElementID, primaryElement.Mass, primaryElement.Temperature, primaryElement.DiseaseIdx, primaryElement.DiseaseCount);
if (num > 0f)
{
float num2 = num / primaryElement.Mass;
int num3 = (int)(num2 * (float)primaryElement.DiseaseCount);
primaryElement.ModifyDiseaseCount(-num3, "CustomConduitDispenser.ConduitUpdate");
primaryElement.Mass -= num;
base.Trigger(-1697596308, primaryElement.gameObject);
}
}
}
}
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 OnCleanUp()
{
ConduitFlow liquidConduitFlow = Game.Instance.liquidConduitFlow;
liquidConduitFlow.onConduitsRebuilt -= OnConduitsRebuilt;
Components.Toilets.Remove(this);
base.OnCleanUp();
}
private void ConduitUpdate(float dt)
{
if (this.isConsuming)
{
ConduitFlow conduitManager = this.GetConduitManager();
this.Consume(dt, conduitManager);
}
}
public static float MaxMass(this ConduitFlow manager)
{
if (manager == null)
{
throw new System.ArgumentNullException("manager");
}
return((float)maxMass.GetValue(manager));
}
private void ConduitUpdate(float dt)
{
if (isConsuming)
{
ConduitFlow conduitManager = GetConduitManager();
Consume(dt, conduitManager);
}
}
private void OnConduitUpdate(float dt)
{
ConduitFlow liquidConduitFlow = Game.Instance.liquidConduitFlow;
bool flag = liquidConduitFlow.GetContents(outputCell).mass > 0f;
smi.sm.outputBlocked.Set(flag, smi);
operational.SetFlag(coolantOutputPipeEmpty, !flag);
}
internal static void Postfix(ConduitFlowVisualizer __instance, int cell, ConduitFlow ___flowManager, bool ___showContents, ref Color32 __result)
{
Pressurized pressure = Integration.GetPressurizedAt(cell, (ConduitType)conduitType.GetValue(___flowManager));
if (!Pressurized.IsDefault(pressure))
{
__result = ___showContents ? pressure.Info.FlowOverlayTint : pressure.Info.FlowTint;
}
}
private void OnConduitUpdate(float dt)
{
if (GetSMI() != null)
{
ConduitFlow liquidConduitFlow = Game.Instance.liquidConduitFlow;
bool value = liquidConduitFlow.GetContents(outputCell).mass > 0f && base.smi.HasContaminatedMass();
base.smi.sm.outputBlocked.Set(value, base.smi);
}
}
public static float GetMaxCapacityAt(int cell, ConduitType type, bool isBridge = false)
{
if (type != ConduitType.Gas && type != ConduitType.Liquid)
{
throw new System.ArgumentException($"[Pressurized] Invalid Conduit Type given to IntegrationHelper.GetMaxCapacityAt(): {type.ToString()} Type must be ConduitType.Gas or ConduitType.Liquid.", "type");
}
ConduitFlow manager = Conduit.GetFlowManager(type);
return(Pressurized.GetMaxCapacity(GetPressurizedAt(cell, type, isBridge)));
}
protected override void OnCleanUp()
{
IUtilityNetworkMgr networkManager = Conduit.GetNetworkManager(this.portInfo.conduitType);
networkManager.RemoveFromNetworks(this.sInputCell, this.itemSInput, true);
ConduitFlow flowManager = Conduit.GetFlowManager(this.portInfo.conduitType);
flowManager.RemoveConduitUpdater(this.OnConduitTick);
base.OnCleanUp();
}
public ConduitFlowVisualizer(ConduitFlow flow_manager, Game.ConduitVisInfo vis_info, string overlay_sound, Tuning tuning)
{
flowManager = flow_manager;
visInfo = vis_info;
overlaySound = overlay_sound;
this.tuning = tuning;
movingBallMesh = new ConduitFlowMesh();
staticBallMesh = new ConduitFlowMesh();
RenderMeshTask.Ball.InitializeResources();
}
private void UpdateState(float dt)
{
bool value = consumer.IsSatisfied;
envTemp = 0f;
cellCount = 0;
if ((UnityEngine.Object)occupyArea != (UnityEngine.Object)null && (UnityEngine.Object)base.gameObject != (UnityEngine.Object)null)
{
occupyArea.TestArea(Grid.PosToCell(base.gameObject), this, UpdateStateCb);
envTemp /= (float)cellCount;
}
lastEnvTemp = envTemp;
List <GameObject> items = storage.items;
for (int i = 0; i < items.Count; i++)
{
PrimaryElement component = items[i].GetComponent <PrimaryElement>();
if (component.Mass > 0f && (!isLiquidConditioner || !component.Element.IsGas) && (isLiquidConditioner || !component.Element.IsLiquid))
{
value = true;
lastGasTemp = component.Temperature;
float num = component.Temperature + temperatureDelta;
if (num < 1f)
{
num = 1f;
lowTempLag = Mathf.Min(lowTempLag + dt / 5f, 1f);
}
else
{
lowTempLag = Mathf.Min(lowTempLag - dt / 5f, 0f);
}
ConduitFlow conduitFlow = (!isLiquidConditioner) ? Game.Instance.gasConduitFlow : Game.Instance.liquidConduitFlow;
float num2 = conduitFlow.AddElement(cooledAirOutputCell, component.ElementID, component.Mass, num, component.DiseaseIdx, component.DiseaseCount);
component.KeepZeroMassObject = true;
float num3 = num2 / component.Mass;
int num4 = (int)((float)component.DiseaseCount * num3);
component.Mass -= num2;
component.ModifyDiseaseCount(-num4, "AirConditioner.UpdateState");
float num5 = num - component.Temperature;
float num6 = num5 * component.Element.specificHeatCapacity * num2;
float display_dt = (!(lastSampleTime > 0f)) ? 1f : (Time.time - lastSampleTime);
lastSampleTime = Time.time;
GameComps.StructureTemperatures.ProduceEnergy(structureTemperature, 0f - num6, BUILDING.STATUSITEMS.OPERATINGENERGY.PIPECONTENTS_TRANSFER, display_dt);
break;
}
}
if (Time.time - lastSampleTime > 2f)
{
GameComps.StructureTemperatures.ProduceEnergy(structureTemperature, 0f, BUILDING.STATUSITEMS.OPERATINGENERGY.PIPECONTENTS_TRANSFER, Time.time - lastSampleTime);
lastSampleTime = Time.time;
}
operational.SetActive(value, false);
UpdateStatus();
}
private void UpdateConduitBlockedStatus()
{
ConduitFlow flowManager = Conduit.GetFlowManager(portInfo.conduitType);
bool flag = flowManager.IsConduitEmpty(filteredCell);
StatusItem conduitBlockedMultiples = Db.Get().BuildingStatusItems.ConduitBlockedMultiples;
bool flag2 = conduitBlockedStatusItemGuid != Guid.Empty;
if (flag == flag2)
{
conduitBlockedStatusItemGuid = selectable.ToggleStatusItem(conduitBlockedMultiples, conduitBlockedStatusItemGuid, !flag, null);
}
}
public static float GetMaxCapacity(Pressurized pressure)
{
ConduitFlow manager = Conduit.GetFlowManager(pressure.ConduitType);
if (IsDefault(pressure))
{
return(manager.MaxMass());
}
else
{
return(pressure.Info.IncreaseMultiplier * manager.MaxMass());
}
}
private void ForceRebuild()
{
//Rebuild the conduit flow network, so that conduit contents transfer no heat.
ConduitFlow manager = conduit.GetFlowManager();
if (manager == null)
{
Debug.LogError($"[Pressurized] Could not retrieve the conduit flow manager for conduit type: {ConduitType}");
return;
}
//Without forcing the rebuild, the conduit system will not know that this conduit is now made out of insulation. Rebuilds normally occur when conduits are built/destroyed
manager.ForceRebuildNetworks();
}
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);
}
protected override void OnCleanUp()
{
IUtilityNetworkMgr networkManager = Conduit.GetNetworkManager(portInfo.conduitType);
networkManager.RemoveFromNetworks(filteredCell, itemFilter, true);
ConduitFlow flowManager = Conduit.GetFlowManager(portInfo.conduitType);
flowManager.RemoveConduitUpdater(OnConduitTick);
if (partitionerEntry.IsValid() && (UnityEngine.Object)GameScenePartitioner.Instance != (UnityEngine.Object)null)
{
GameScenePartitioner.Instance.Free(ref partitionerEntry);
}
base.OnCleanUp();
}
private void OnConduitTick(float dt)
{
bool value = false;
if (this.operational.IsOperational)
{
ConduitFlow gasFlow = Conduit.GetFlowManager(this.portInfo.conduitType);
ConduitFlow.ConduitContents contentsI1 = gasFlow.GetContents(this.inputCell1);
ConduitFlow.ConduitContents contentsI2 = gasFlow.GetContents(this.inputCell2);
//Debug.Log("contentsI1.mass: " + contentsI1.mass);
//Debug.Log("contentsI2.mass: " + contentsI2.mass);
//int num = (contents.element != this.filteredElem) ? this.outputCell : this.filteredCell;
ConduitFlow.ConduitContents contentsO = gasFlow.GetContents(this.outputCell);
if (contentsI1.element != SimHashes.Hydrogen || contentsI2.element != SimHashes.Oxygen)
{
base.Trigger((int)GameHashes.DoBuildingDamage, new BuildingHP.DamageSourceInfo
{
damage = 1,
source = STRINGS.BUILDINGS.DAMAGESOURCES.BAD_INPUT_ELEMENT,
popString = STRINGS.UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.WRONG_ELEMENT
});
gasFlow.RemoveElement(this.inputCell1, 0.111999989f);
gasFlow.RemoveElement(this.inputCell2, 0.888f);
}
else
{
if (contentsI1.mass > 0.111999989f &&
contentsI2.mass > 0.888f &&
contentsO.mass <= 0f)
{
value = true;
//float num2 = flowManager.AddElement(num, contents.element, contents.mass, contents.temperature, contents.diseaseIdx, contents.diseaseCount);
float outputTemperature = contentsI1.temperature * 0.111999989f + contentsI2.temperature * 0.888f;
//Debug.Log("outputTemperature: " + outputTemperature);
ConduitFlow liquidFlow = Conduit.GetFlowManager(ConduitType.Liquid);
float num2 = liquidFlow.AddElement(this.outputCell, SimHashes.Water, 1f, outputTemperature, contentsI1.diseaseIdx, 0);
if (num2 > 0f)
{
gasFlow.RemoveElement(this.inputCell1, 0.111999989f);
gasFlow.RemoveElement(this.inputCell2, 0.888f);
}
}
}
}
this.operational.SetActive(value, false);
}
private void UpdateConduitFlow(ConduitFlow conduitFlow)
{
var conduitType = Traverse.Create(conduitFlow).Field("conduitType").GetValue <ConduitType>();
//Log.Spam($"Begin UpdateConduitFlow {conduitType}");
var networks = Traverse.Create(conduitFlow).Field("networks").GetValue <IEnumerable>();
foreach (var network in networks)
{
var cells = Traverse.Create(network).Field("cells").GetValue <List <int> >();
UpdateConduitNetwork(conduitFlow, conduitType, cells);
}
//Log.Spam($"End UpdateConduitFlow {conduitType}");
}
protected override void OnSpawn()
{
base.OnSpawn();
inputCell = building.GetUtilityInputCell();
outputCell = building.GetUtilityOutputCell();
int cell = Grid.PosToCell(base.transform.GetPosition());
CellOffset rotatedOffset = building.GetRotatedOffset(portInfo.offset);
filteredCell = Grid.OffsetCell(cell, rotatedOffset);
IUtilityNetworkMgr networkManager = Conduit.GetNetworkManager(portInfo.conduitType);
itemFilter = new FlowUtilityNetwork.NetworkItem(portInfo.conduitType, Endpoint.Source, filteredCell, base.gameObject);
networkManager.AddToNetworks(filteredCell, itemFilter, true);
GetComponent <ConduitConsumer>().isConsuming = false;
OnFilterChanged(filterable.SelectedTag);
filterable.onFilterChanged += OnFilterChanged;
ConduitFlow flowManager = Conduit.GetFlowManager(portInfo.conduitType);
flowManager.AddConduitUpdater(OnConduitTick, ConduitFlowPriority.Default);
GetComponent <KSelectable>().SetStatusItem(Db.Get().StatusItemCategories.Main, filterStatusItem, this);
UpdateConduitExistsStatus();
UpdateConduitBlockedStatus();
ScenePartitionerLayer scenePartitionerLayer = null;
switch (portInfo.conduitType)
{
case ConduitType.Gas:
scenePartitionerLayer = GameScenePartitioner.Instance.gasConduitsLayer;
break;
case ConduitType.Liquid:
scenePartitionerLayer = GameScenePartitioner.Instance.liquidConduitsLayer;
break;
case ConduitType.Solid:
scenePartitionerLayer = GameScenePartitioner.Instance.solidConduitsLayer;
break;
}
if (scenePartitionerLayer != null)
{
partitionerEntry = GameScenePartitioner.Instance.Add("ElementFilterConduitExists", base.gameObject, filteredCell, scenePartitionerLayer, delegate
{
UpdateConduitExistsStatus();
});
}
}
protected override void ConduitUpdate(float dt)
{
int cell = Grid.PosToCell(this);
ConduitFlow flowManager = Conduit.GetFlowManager(this.conduitType);
this.currentValue = flowManager.GetContents(cell).mass * 1000;
// spawn code should never toggle as it crashes on load
if (dt < 0)
{
return;
}
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();
}
}