private void Emit(object data)
{
GameObject gameObject = (GameObject)data;
global::Components.Cmps <MinionIdentity> liveMinionIdentities = global::Components.LiveMinionIdentities;
Vector2 a = gameObject.transform.GetPosition();
for (int i = 0; i < liveMinionIdentities.Count; i++)
{
MinionIdentity minionIdentity = liveMinionIdentities[i];
if (minionIdentity.gameObject != gameObject.gameObject)
{
Vector2 b = minionIdentity.transform.GetPosition();
float num = Vector2.SqrMagnitude(a - b);
if (num <= 2.25f)
{
minionIdentity.Trigger((int)GameHashes.Cringe, Strings.Get("STRINGS.DUPLICANTS.DISEASES.PUTRIDODOUR.CRINGE_EFFECT").String);
minionIdentity.gameObject.GetSMI <ThoughtGraph.Instance>().AddThought(Db.Get().Thoughts.PutridOdour);
}
}
}
int gameCell = Grid.PosToCell(gameObject.transform.GetPosition());
float temp = Db.Get().Amounts.Temperature.Lookup(this).value;
SimMessages.AddRemoveSubstance(gameCell, SimHashes.ContaminatedOxygen, CellEventLogger.Instance.ElementConsumerSimUpdate, 0.0025f, temp, DiseaseInfo.Invalid.idx, DiseaseInfo.Invalid.count);
KFMOD.PlayOneShot(GlobalAssets.GetSound("Dupe_Flatulence"), base.transform.GetPosition());
}
public void SpawnDirtyWater(float dt)
{
if (dt <= 0.0)
{
return;
}
var timeRatio = dt / GetComponent <KBatchedAnimController>().CurrentAnim.totalTime;
var orientation = sm.vomiter.Get(smi).GetComponent <Facing>();
var posCell = Grid.PosToCell(orientation.transform.GetPosition());
int frontCell = orientation.GetFrontCell();
if (!CanEmitLiquid(frontCell))
{
frontCell = posCell;
}
var suit = GetComponent <SuitEquipper>().IsWearingAirtightSuit();
if (suit != null)
{
suit.GetComponent <Storage>().AddLiquid(SimHashes.DirtyWater, STRESS.VOMIT_AMOUNT * timeRatio,
bodyTemperature.value, diseaseInfo.idx, diseaseInfo.count);
}
else
{
SimMessages.AddRemoveSubstance(frontCell, SimHashes.DirtyWater, CellEventLogger.Instance.Vomit,
STRESS.VOMIT_AMOUNT * timeRatio, bodyTemperature.value, diseaseInfo.idx, diseaseInfo.count);
}
}
public void Sim33ms(float dt)
{
ListPool <Bubble, BubbleManager> .PooledList pooledList = ListPool <Bubble, BubbleManager> .Allocate();
ListPool <Bubble, BubbleManager> .PooledList pooledList2 = ListPool <Bubble, BubbleManager> .Allocate();
foreach (Bubble bubble in bubbles)
{
Bubble item = bubble;
item.position += item.velocity * dt;
item.elapsedTime += dt;
int num = Grid.PosToCell(item.position);
if (!Grid.IsVisiblyInLiquid(item.position) || Grid.Element[num].id == item.element)
{
pooledList2.Add(item);
}
else
{
pooledList.Add(item);
}
}
foreach (Bubble item2 in pooledList2)
{
Bubble current2 = item2;
int gameCell = Grid.PosToCell(current2.position);
SimMessages.AddRemoveSubstance(gameCell, current2.element, CellEventLogger.Instance.FallingWaterAddToSim, current2.mass, current2.temperature, byte.MaxValue, 0, true, -1);
}
bubbles.Clear();
bubbles.AddRange(pooledList);
pooledList2.Recycle();
pooledList.Recycle();
}
private void AddMassToWorlIfPossible()
{
ListPool <int, EntombedItemManager> .PooledList pooledList = ListPool <int, EntombedItemManager> .Allocate();
for (int i = 0; i < cells.Count; i++)
{
int num = cells[i];
if (Grid.Solid[num] && Grid.Element[num].id == (SimHashes)elementIds[i])
{
pooledList.Add(i);
}
}
pooledList.Sort();
pooledList.Reverse();
foreach (int item2 in pooledList)
{
Item item = GetItem(item2);
RemoveItem(item2);
if (item.mass > 1.401298E-45f)
{
SimMessages.AddRemoveSubstance(item.cell, ElementLoader.FindElementByHash((SimHashes)item.elementId).idx, CellEventLogger.Instance.ElementConsumerSimUpdate, item.mass, item.temperature, item.diseaseIdx, item.diseaseCount, true, -1);
}
}
pooledList.Recycle();
}
private void ProduceSlime(GameObject cougher)
{
AmountInstance amountInstance = Db.Get().Amounts.Temperature.Lookup(cougher);
int gameCell = Grid.PosToCell(cougher);
SimMessages.AddRemoveSubstance(gameCell, SimHashes.ContaminatedOxygen, CellEventLogger.Instance.Cough, 0.1f, amountInstance.value, Db.Get().Diseases.GetIndex("Radioactive"), 1000, true, -1);
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, string.Format(DUPLICANTS.DISEASES.ADDED_POPFX, base.master.modifier.Name, 1000), cougher.transform, 1.5f, false);
}
public void Dump(Vector3 pos)
{
PrimaryElement component = GetComponent <PrimaryElement>();
if (component.Mass > 0f)
{
SimMessages.AddRemoveSubstance(Grid.PosToCell(pos), component.ElementID, CellEventLogger.Instance.Dumpable, component.Mass, component.Temperature, component.DiseaseIdx, component.DiseaseCount, true, -1);
}
Util.KDestroyGameObject(base.gameObject);
}
public void Exhaust(float dt)
{
if (!base.smi.master.wiltCondition.IsWilting())
{
emittedMass += dt * emitRate;
if (emittedMass >= minEmitMass)
{
int gameCell = Grid.PosToCell(base.transform.GetPosition() + emitOffset);
PrimaryElement component = GetComponent <PrimaryElement>();
SimMessages.AddRemoveSubstance(gameCell, SimHashes.CarbonDioxide, CellEventLogger.Instance.ElementEmitted, emittedMass, component.Temperature, byte.MaxValue, 0, true, -1);
emittedMass = 0f;
}
}
}
private void ProduceSlime(GameObject cougher)
{
AmountInstance amountInstance = Db.Get().Amounts.Temperature.Lookup(cougher);
int gameCell = Grid.PosToCell(cougher);
string id = Db.Get().Diseases.SlimeGerms.Id;
Equippable equippable = base.master.gameObject.GetComponent <SuitEquipper>().IsWearingAirtightSuit();
if ((UnityEngine.Object)equippable != (UnityEngine.Object)null)
{
equippable.GetComponent <Storage>().AddGasChunk(SimHashes.ContaminatedOxygen, 0.1f, amountInstance.value, Db.Get().Diseases.GetIndex(id), 1000, false, true);
}
else
{
SimMessages.AddRemoveSubstance(gameCell, SimHashes.ContaminatedOxygen, CellEventLogger.Instance.Cough, 0.1f, amountInstance.value, Db.Get().Diseases.GetIndex(id), 1000, true, -1);
}
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, string.Format(DUPLICANTS.DISEASES.ADDED_POPFX, base.master.modifier.Name, 1000), cougher.transform, 1.5f, false);
}
public void ForceEmit(float mass, byte disease_idx, int disease_count, float temperature = -1f)
{
if (!(mass <= 0f))
{
float temperature2 = (!(temperature > 0f)) ? outputElement.minOutputTemperature : temperature;
Element element = ElementLoader.FindElementByHash(outputElement.elementHash);
if (element.IsGas || element.IsLiquid)
{
int gameCell = Grid.PosToCell(base.transform.GetPosition());
SimMessages.AddRemoveSubstance(gameCell, outputElement.elementHash, CellEventLogger.Instance.ElementConsumerSimUpdate, mass, temperature2, disease_idx, disease_count, true, -1);
}
else if (element.IsSolid)
{
element.substance.SpawnResource(base.transform.GetPosition() + new Vector3(0f, 0.5f, 0f), mass, temperature2, disease_idx, disease_count, false, true, false);
}
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, ElementLoader.FindElementByHash(outputElement.elementHash).name, base.gameObject.transform, 1.5f, false);
}
}
public void DropElement(float mass, SimHashes element_id, byte disease_idx, int disease_count)
{
if (!(mass <= 0f))
{
Element element = ElementLoader.FindElementByHash(element_id);
float temperature = GetComponent <PrimaryElement>().Temperature;
if (element.IsGas || element.IsLiquid)
{
int gameCell = Grid.PosToCell(base.transform.GetPosition());
SimMessages.AddRemoveSubstance(gameCell, element_id, CellEventLogger.Instance.ElementConsumerSimUpdate, mass, temperature, disease_idx, disease_count, true, -1);
}
else if (element.IsSolid)
{
element.substance.SpawnResource(base.transform.GetPosition() + new Vector3(0f, 0.5f, 0f), mass, temperature, disease_idx, disease_count, false, true, false);
}
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, element.name, base.gameObject.transform, 1.5f, false);
}
}
public static void SpawnGas(GameObject go, byte germIdx, float maxBonus, SimHashes gasHash)
{
int higherGerms = Numbers.GetGermCount(go, germIdx);
float bonus = Numbers.PercentOfMaxGerms(higherGerms);
float amount = bonus * maxBonus;
PrimaryElement goPrimary = go.GetComponent <PrimaryElement>();
if (goPrimary == null)
{
return;
}
float temperature = goPrimary.Temperature;
Element element = ElementLoader.FindElementByHash(gasHash);
if (amount > 0)
{
SimMessages.AddRemoveSubstance(Grid.PosToCell(go), (int)element.idx, CellEventLogger.Instance.ElementConsumerSimUpdate, amount, temperature, germIdx, higherGerms);
}
}
private const float MASS_MULTIPLIER = 0.024f; //kg
static void Prefix(ref Health __instance, float delta)
{
var healthSubtracted = Math.Min(-delta, __instance.maxHitPoints);
if (healthSubtracted <= 0)
{
return;
}
SimMessages.AddRemoveSubstance(
gameCell: Grid.PosToCell(__instance),
new_element: BloodElement.BloodSimHash,
ev: null,
mass: MASS_MULTIPLIER * healthSubtracted,
temperature: BODY_TEMP,
disease_idx: DiseaseInfo.Invalid.idx,
disease_count: DiseaseInfo.Invalid.count
);
}
public void ReleaseGasPressure(float dt)
{
PrimaryElement primaryElement = storage.FindPrimaryElement(gasElement);
if ((Object)primaryElement != (Object)null && primaryElement.Mass > 0f)
{
float num = releaseGasRate * dt;
if ((Object)base.worker != (Object)null)
{
num *= GetEfficiencyMultiplier(base.worker);
}
num = Mathf.Min(num, primaryElement.Mass);
SimUtil.DiseaseInfo percentOfDisease = SimUtil.GetPercentOfDisease(primaryElement, num / primaryElement.Mass);
primaryElement.Mass -= num;
Game.Instance.accumulators.Accumulate(accumulator, num);
SimMessages.AddRemoveSubstance(Grid.PosToCell(this), ElementLoader.GetElementIndex(gasElement), null, num, primaryElement.Temperature, percentOfDisease.idx, percentOfDisease.count, true, -1);
}
UpdatePressurePercent();
}
// выделение газов
public void Emit()
{
// эффект вонизмы, применяемый к рядомнаходящимся дуплам, кроме того кто несет труп, иначе работа сбивается.
GameObject gravedigger = null;
if (master.HasTag(GameTags.Sealed))
{
gravedigger = master.GetComponent <Pickupable>()?.storage?.gameObject;
}
Vector2 a = master.transform.GetPosition();
foreach (MinionIdentity minionIdentity in Components.LiveMinionIdentities)
{
if (minionIdentity.gameObject != master.gameObject)
{
Vector2 b = minionIdentity.transform.GetPosition();
if (Vector2.SqrMagnitude(a - b) <= gasMaxDistanceSq)
{
if (minionIdentity.gameObject != gravedigger)
{
minionIdentity.Trigger((int)GameHashes.Cringe, Strings.Get("STRINGS.DUPLICANTS.DISEASES.PUTRIDODOUR.CRINGE_EFFECT").String);
}
minionIdentity.GetSMI <ThoughtGraph.Instance>().AddThought(Db.Get().Thoughts.PutridOdour);
}
}
}
// выделяем газ
int cell = Grid.PosToCell(this);
if (Grid.IsValidCell(cell) && !Grid.Element[cell].IsSolid && !Grid.IsSubstantialLiquid(cell, submergedThreshold))
{
if (Grid.Element[cell].id == gasReplacedElement)
{
SimMessages.ReplaceElement(cell, gasEmitElement, CellEventLogger.Instance.DecompositionDirtyWater, Grid.Mass[cell], Grid.Temperature[cell], Grid.DiseaseIdx[cell], Grid.DiseaseCount[cell]);
}
else
{
SimMessages.AddRemoveSubstance(cell, gasEmitElement, CellEventLogger.Instance.ElementConsumerSimUpdate, gasEmitMass, temperature, byte.MaxValue, 0);
}
}
}
public void Sim33ms(float dt)
{
EntombedItemVisualizer component = Game.Instance.GetComponent <EntombedItemVisualizer>();
HashSetPool <Pickupable, EntombedItemManager> .PooledHashSet pooledHashSet = HashSetPool <Pickupable, EntombedItemManager> .Allocate();
foreach (Pickupable pickupable in pickupables)
{
if (CanEntomb(pickupable))
{
pooledHashSet.Add(pickupable);
}
}
pickupables.Clear();
foreach (Pickupable item in pooledHashSet)
{
int num = Grid.PosToCell(item);
PrimaryElement component2 = item.GetComponent <PrimaryElement>();
SimHashes elementID = component2.ElementID;
float mass = component2.Mass;
float temperature = component2.Temperature;
byte diseaseIdx = component2.DiseaseIdx;
int diseaseCount = component2.DiseaseCount;
Element element = Grid.Element[num];
if (elementID == element.id && mass > 0.0100000007f && Grid.Mass[num] + mass < element.maxMass)
{
SimMessages.AddRemoveSubstance(num, ElementLoader.FindElementByHash(elementID).idx, CellEventLogger.Instance.ElementConsumerSimUpdate, mass, temperature, diseaseIdx, diseaseCount, true, -1);
}
else
{
component.AddItem(num);
cells.Add(num);
elementIds.Add((int)elementID);
masses.Add(mass);
temperatures.Add(temperature);
diseaseIndices.Add(diseaseIdx);
diseaseCounts.Add(diseaseCount);
}
Util.KDestroyGameObject(item.gameObject);
}
pooledHashSet.Recycle();
}
public static void DoStateTransition(int sim_handle)
{
SimTemperatureTransfer value = null;
if (handleInstanceMap.TryGetValue(sim_handle, out value) && !((UnityEngine.Object)value == (UnityEngine.Object)null) && !value.HasTag(GameTags.Sealed))
{
PrimaryElement component = value.GetComponent <PrimaryElement>();
Element element = component.Element;
if (element.highTempTransitionTarget != SimHashes.Unobtanium)
{
if (component.Mass > 0f)
{
int gameCell = Grid.PosToCell(value.transform.GetPosition());
SimMessages.AddRemoveSubstance(gameCell, element.highTempTransitionTarget, CellEventLogger.Instance.OreMelted, component.Mass, component.Temperature, component.DiseaseIdx, component.DiseaseCount, true, -1);
}
value.OnCleanUp();
Util.KDestroyGameObject(value.gameObject);
}
}
}
public void SpawnDirtyWater(float dt)
{
int gameCell = Grid.PosToCell(base.sm.worker.Get <KMonoBehaviour>(base.smi));
byte index = Db.Get().Diseases.GetIndex("FoodPoisoning");
float num = dt * (0f - bladder.GetDelta()) / bladder.GetMax();
if (num > 0f)
{
float mass = 2f * num;
Equippable equippable = GetComponent <SuitEquipper>().IsWearingAirtightSuit();
if ((UnityEngine.Object)equippable != (UnityEngine.Object)null)
{
equippable.GetComponent <Storage>().AddLiquid(SimHashes.DirtyWater, mass, bodyTemperature.value, index, Mathf.CeilToInt(100000f * num), false, true);
}
else
{
SimMessages.AddRemoveSubstance(gameCell, SimHashes.DirtyWater, CellEventLogger.Instance.Vomit, mass, bodyTemperature.value, index, Mathf.CeilToInt(100000f * num), true, -1);
}
}
}
private void CheckStorage()
{
//var bleachStoneTag = SimHashes.BleachStone.CreateTag();
for (int i = 0; i < storage.items.Count; i++)
{
GameObject storageItem = storage.items[i];
if (storageItem != null)
{
if (storageItem.HasTag(GameTags.AnyWater))
{
continue;
}
i--;
storage.Remove(storageItem);
PrimaryElement element = storageItem.GetComponent <PrimaryElement>();
int disease_count = (int)(element.DiseaseCount * element.Mass);
SimMessages.AddRemoveSubstance(Grid.PosToCell(transform.GetPosition()), element.Element.id, CellEventLogger.Instance.ConduitConsumerWrongElement, element.Mass, element.Temperature, element.DiseaseIdx, disease_count);
}
}
}
private void EmitContents()
{
if (gasStorage.items.Count != 0)
{
float num = 0.1f;
float num2 = num;
PrimaryElement primaryElement = null;
for (int i = 0; i < gasStorage.items.Count; i++)
{
PrimaryElement component = gasStorage.items[i].GetComponent <PrimaryElement>();
if (component.Mass > num2 && component.Element.IsGas)
{
primaryElement = component;
num2 = primaryElement.Mass;
}
}
if ((Object)primaryElement != (Object)null)
{
SimMessages.AddRemoveSubstance(Grid.CellRight(Grid.CellAbove(Grid.PosToCell(base.gameObject))), ElementLoader.GetElementIndex(primaryElement.ElementID), CellEventLogger.Instance.ExhaustSimUpdate, primaryElement.Mass, primaryElement.Temperature, primaryElement.DiseaseIdx, primaryElement.DiseaseCount, true, -1);
gasStorage.ConsumeIgnoringDisease(primaryElement.gameObject);
}
}
}
public static void Emit(Instance smi, float dt)
{
if ((bool)smi.navigator)
{
GameObject gameObject = smi.sm.owner.Get(smi);
if ((bool)gameObject)
{
int gameCell = Grid.PosToCell(gameObject.transform.GetPosition());
float a = 0.1f * dt;
a = Mathf.Min(a, smi.jet_suit_tank.amount);
smi.jet_suit_tank.amount -= a;
float num = a * 3f;
if (num > 1.401298E-45f)
{
SimMessages.AddRemoveSubstance(gameCell, SimHashes.CarbonDioxide, CellEventLogger.Instance.ElementConsumerSimUpdate, num, 473.15f, byte.MaxValue, 0, true, -1);
}
if (smi.jet_suit_tank.amount == 0f)
{
smi.navigator.AddTag(GameTags.JetSuitOutOfFuel);
smi.navigator.SetCurrentNavType(NavType.Floor);
}
}
}
}
private void TryEmit(PrimaryElement primary_elem)
{
if (primary_elem.Mass >= emitMass)
{
plasticMeter.SetPositionPercent(0f);
GameObject gameObject = storage.Drop(primary_elem.gameObject, true);
Rotatable component = GetComponent <Rotatable>();
Vector3 vector = component.transform.GetPosition() + component.GetRotatedOffset(emitOffset);
int i = Grid.PosToCell(vector);
if (Grid.Solid[i])
{
vector += component.GetRotatedOffset(Vector3.left);
}
gameObject.transform.SetPosition(vector);
PrimaryElement primaryElement = storage.FindPrimaryElement(exhaustElement);
if ((Object)primaryElement != (Object)null)
{
int gameCell = Grid.PosToCell(vector);
SimMessages.AddRemoveSubstance(gameCell, primaryElement.ElementID, null, primaryElement.Mass, primaryElement.Temperature, primaryElement.DiseaseIdx, primaryElement.DiseaseCount, true, -1);
primaryElement.Mass = 0f;
primaryElement.ModifyDiseaseCount(-2147483648, "Polymerizer.Exhaust");
}
}
}
private void Emit(object data)
{
GameObject gameObject = (GameObject)data;
float value = Db.Get().Amounts.Temperature.Lookup(this).value;
Equippable equippable = GetComponent <SuitEquipper>().IsWearingAirtightSuit();
if ((Object)equippable != (Object)null)
{
equippable.GetComponent <Storage>().AddGasChunk(SimHashes.Methane, 0.1f, value, byte.MaxValue, 0, false, true);
}
else
{
Components.Cmps <MinionIdentity> liveMinionIdentities = Components.LiveMinionIdentities;
Vector2 a = gameObject.transform.GetPosition();
for (int i = 0; i < liveMinionIdentities.Count; i++)
{
MinionIdentity minionIdentity = liveMinionIdentities[i];
if ((Object)minionIdentity.gameObject != (Object)gameObject.gameObject)
{
Vector2 b = minionIdentity.transform.GetPosition();
float num = Vector2.SqrMagnitude(a - b);
if (num <= 2.25f)
{
minionIdentity.Trigger(508119890, Strings.Get("STRINGS.DUPLICANTS.DISEASES.PUTRIDODOUR.CRINGE_EFFECT").String);
minionIdentity.gameObject.GetSMI <ThoughtGraph.Instance>().AddThought(Db.Get().Thoughts.PutridOdour);
}
}
}
int gameCell = Grid.PosToCell(gameObject.transform.GetPosition());
SimMessages.AddRemoveSubstance(gameCell, SimHashes.Methane, CellEventLogger.Instance.ElementConsumerSimUpdate, 0.1f, value, byte.MaxValue, 0, true, -1);
KBatchedAnimController kBatchedAnimController = FXHelpers.CreateEffect("odor_fx_kanim", gameObject.transform.GetPosition(), gameObject.transform, true, Grid.SceneLayer.Front, false);
kBatchedAnimController.Play(WorkLoopAnims, KAnim.PlayMode.Once);
kBatchedAnimController.destroyOnAnimComplete = true;
}
KFMOD.PlayOneShot(GlobalAssets.GetSound("Dupe_Flatulence", false), base.transform.GetPosition());
}
protected override void ConduitTick(float delta)
{
if (!AlwaysConsume && !operational.IsOperational)
{
return;
}
IConduitFlow conduitFlow = GetConduitManager();
if (ConduitType != ConduitType.Solid)
{
ConduitFlow mngr = conduitFlow as ConduitFlow;
ConduitFlow.ConduitContents contents = mngr.GetContents(portCell);
if (contents.mass <= 0)
{
return;
}
Element element = ElementLoader.FindElementByHash(contents.element);
bool matchesTag = StoreTag == GameTags.Any || element.HasTag(StoreTag);
float rateAmount = ConsumptionRate * delta;
float maxTake = 0f;
float storageContains = storage.MassStored();
float storageLeft = storage.capacityKg - storageContains;
float portContains = StoreTag == GameTags.Any ? storageContains : storage.GetMassAvailable(StoreTag);
float portLeft = MaximumStore - portContains;
maxTake = Mathf.Min(storageLeft, portLeft);
maxTake = Mathf.Min(rateAmount, maxTake);
float removed = 0f;
if (maxTake > 0f)
{
ConduitFlow.ConduitContents removedContents = mngr.RemoveElement(portCell, maxTake);
removed = removedContents.mass;
LastConsumedElement = removedContents.element;
float ratio = removed / contents.mass;
if (!matchesTag)
{
BuildingHP.DamageSourceInfo damage = new BuildingHP.DamageSourceInfo
{
damage = 1,
source = BUILDINGS.DAMAGESOURCES.BAD_INPUT_ELEMENT,
popString = UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.WRONG_ELEMENT
};
Trigger((int)GameHashes.DoBuildingDamage, damage);
if (WrongElement == WrongElementResult.Dump)
{
int buildingCell = Grid.PosToCell(_parent.transform.GetPosition());
SimMessages.AddRemoveSubstance(buildingCell, contents.element, CellEventLogger.Instance.ConduitConsumerWrongElement, removed, contents.temperature, contents.diseaseIdx, contents.diseaseIdx);
return;
}
}
if (ConduitType == ConduitType.Gas)
{
if (!element.IsGas)
{
Debug.LogWarning($"[MultIO] Gas input port attempted to consume non gass: {element.id.ToString()}");
}
else
{
storage.AddGasChunk(element.id, removed, contents.temperature, contents.diseaseIdx, contents.diseaseCount, KeepZeroMassObject, false);
}
}
else if (ConduitType == ConduitType.Liquid)
{
if (!element.IsLiquid)
{
Debug.LogWarning($"[MultIO] Liquid input port attempted to consume non liquid: {element.id.ToString()}");
}
else
{
storage.AddLiquid(element.id, removed, contents.temperature, contents.diseaseIdx, contents.diseaseCount, KeepZeroMassObject, false);
}
}
}
}
else
{
SolidConduitFlow mngr = conduitFlow as SolidConduitFlow;
SolidConduitFlow.ConduitContents contents = mngr.GetContents(portCell);
if (contents.pickupableHandle.IsValid() && (AlwaysConsume || operational.IsOperational))
{
float stored = StoreTag == GameTags.Any ? storage.MassStored() : storage.GetMassAvailable(StoreTag);
float maxStorage = Mathf.Min(storage.capacityKg, MaximumStore);
float availableStorage = Mathf.Max(0f, maxStorage - stored);
if (availableStorage > 0f)
{
Pickupable tmp = mngr.GetPickupable(contents.pickupableHandle);
bool matchesTag = StoreTag == GameTags.Any || tmp.HasTag(StoreTag);
if (matchesTag)
{
if (tmp.PrimaryElement.Mass <= stored || tmp.PrimaryElement.Mass > maxStorage)
{
Pickupable take = mngr.RemovePickupable(portCell);
if (take != null)
{
storage.Store(take.gameObject, true);
}
}
}
else
{
Pickupable take = mngr.RemovePickupable(portCell);
take.transform.SetPosition(Grid.CellToPos(portCell));
//TODO: Add a PopFX. Likely will not do damage.
}
}
}
}
}
private void Consume(float dt, ConduitFlow conduit_mgr)
{
this.IsSatisfied = false;
if (this.building.Def.CanMove)
{
this.utilityCell = this.GetInputCell();
}
if (!this.IsConnected)
{
return;
}
ConduitFlow.ConduitContents contents = conduit_mgr.GetContents(this.utilityCell);
if ((double)contents.mass <= 0.0)
{
return;
}
this.IsSatisfied = true;
if (!this.alwaysConsume && !this.operational.IsOperational)
{
return;
}
float delta = Mathf.Min(this.ConsumptionRate * dt, this.space_remaining_kg);
float mass = 0.0f;
if ((double)delta > 0.0)
{
ConduitFlow.ConduitContents conduitContents = conduit_mgr.RemoveElement(this.utilityCell, delta);
mass = conduitContents.mass;
this.lastConsumedElement = conduitContents.element;
}
bool flag = ElementLoader.FindElementByHash(contents.element).HasTag(this.capacityTag);
if ((double)mass > 0.0 && this.capacityTag != GameTags.Any && !flag)
{
this.Trigger(-794517298, (object)new BuildingHP.DamageSourceInfo()
{
damage = 1,
source = (string)BUILDINGS.DAMAGESOURCES.BAD_INPUT_ELEMENT,
popString = (string)UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.WRONG_ELEMENT
});
}
if (flag || this.wrongElementResult == ConduitConsumer2.WrongElementResult.Store || (contents.element == SimHashes.Vacuum || this.capacityTag == GameTags.Any))
{
if ((double)mass <= 0.0)
{
return;
}
int disease_count = (int)((double)contents.diseaseCount * ((double)mass / (double)contents.mass));
Element elementByHash = ElementLoader.FindElementByHash(contents.element);
switch (this.conduitType)
{
case ConduitType.Gas:
if (elementByHash.IsGas)
{
this.storage.AddGasChunk(contents.element, mass, contents.temperature, contents.diseaseIdx, disease_count, this.keepZeroMassObject, false);
break;
}
Debug.LogWarning((object)("Gas conduit consumer consuming non gas: " + elementByHash.id.ToString()));
break;
case ConduitType.Liquid:
if (elementByHash.IsLiquid)
{
this.storage.AddLiquid(contents.element, mass, contents.temperature, contents.diseaseIdx, disease_count, this.keepZeroMassObject, false);
break;
}
Debug.LogWarning((object)("Liquid conduit consumer consuming non liquid: " + elementByHash.id.ToString()));
break;
}
}
else
{
if ((double)mass <= 0.0 || this.wrongElementResult != ConduitConsumer2.WrongElementResult.Dump)
{
return;
}
int disease_count = (int)((double)contents.diseaseCount * ((double)mass / (double)contents.mass));
SimMessages.AddRemoveSubstance(Grid.PosToCell(this.transform.GetPosition()), contents.element, CellEventLogger.Instance.ConduitConsumerWrongElement, mass, contents.temperature, contents.diseaseIdx, disease_count, true, -1);
}
}
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);
}
public void Poop()
{
float num = 0f;
Tag tag = Tag.Invalid;
byte disease_idx = byte.MaxValue;
int num2 = 0;
bool flag = false;
for (int i = 0; i < caloriesConsumed.Count; i++)
{
CaloriesConsumedEntry value = caloriesConsumed[i];
if (!(value.calories <= 0f))
{
Diet.Info dietInfo = diet.GetDietInfo(value.tag);
if (dietInfo != null && (!(tag != Tag.Invalid) || !(tag != dietInfo.producedElement)))
{
num += dietInfo.ConvertConsumptionMassToProducedMass(dietInfo.ConvertCaloriesToConsumptionMass(value.calories));
tag = dietInfo.producedElement;
disease_idx = dietInfo.diseaseIdx;
num2 = (int)(dietInfo.diseasePerKgProduced * num);
value.calories = 0f;
caloriesConsumed[i] = value;
flag = (flag || dietInfo.produceSolidTile);
}
}
}
if (!(num <= 0f) && !(tag == Tag.Invalid))
{
Element element = ElementLoader.GetElement(tag);
Debug.Assert(element != null, "TODO: implement non-element tag spawning");
int num3 = Grid.PosToCell(owner.transform.GetPosition());
float temperature = owner.GetComponent <PrimaryElement>().Temperature;
if (element.IsLiquid)
{
FallingWater.instance.AddParticle(num3, element.idx, num, temperature, disease_idx, num2, true, false, false, false);
}
else if (element.IsGas)
{
SimMessages.AddRemoveSubstance(num3, element.idx, CellEventLogger.Instance.ElementConsumerSimUpdate, num, temperature, disease_idx, num2, true, -1);
}
else if (flag)
{
Facing component = owner.GetComponent <Facing>();
int num4 = component.GetFrontCell();
if (!Grid.IsValidCell(num4))
{
Debug.LogWarningFormat("{0} attemping to Poop {1} on invalid cell {2} from cell {3}", owner, element.name, num4, num3);
num4 = num3;
}
SimMessages.AddRemoveSubstance(num4, element.idx, CellEventLogger.Instance.ElementConsumerSimUpdate, num, temperature, disease_idx, num2, true, -1);
}
else
{
element.substance.SpawnResource(Grid.CellToPosCCC(num3, Grid.SceneLayer.Ore), num, temperature, disease_idx, num2, false, false, false);
}
KPrefabID component2 = owner.GetComponent <KPrefabID>();
if (!Game.Instance.savedInfo.creaturePoopAmount.ContainsKey(component2.PrefabTag))
{
Game.Instance.savedInfo.creaturePoopAmount.Add(component2.PrefabTag, 0f);
}
Dictionary <Tag, float> creaturePoopAmount;
Tag prefabTag;
(creaturePoopAmount = Game.Instance.savedInfo.creaturePoopAmount)[prefabTag = component2.PrefabTag] = creaturePoopAmount[prefabTag] + num;
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, element.name, owner.transform, 1.5f, false);
}
}
public static bool Prefix(Stomach __instance, ref GameObject ___owner,
ref List <CreatureCalorieMonitor.Stomach.CaloriesConsumedEntry> ___caloriesConsumed)
{
if (___owner.PrefabID() == CloudyPuftConfig.ID || ___owner.PrefabID() == CloudyPuftConfig.BABY_ID || ___owner.PrefabID() == SmoggyPuftConfig.ID || ___owner.PrefabID() == SmoggyPuftConfig.BABY_ID)
{
float deltaEmitTemperature = 0;
if (___owner.PrefabID() == CloudyPuftConfig.ID || ___owner.PrefabID() == CloudyPuftConfig.BABY_ID)
{
deltaEmitTemperature = -5f * 2;
}
if (___owner.PrefabID() == SmoggyPuftConfig.ID || ___owner.PrefabID() == SmoggyPuftConfig.BABY_ID)
{
deltaEmitTemperature = 5f * 8;
}
float num1 = 0.0f;
Tag tag = Tag.Invalid;
byte disease_idx = byte.MaxValue;
int num2 = 0;
bool flag = false;
for (int index = 0; index < ___caloriesConsumed.Count; ++index)
{
CreatureCalorieMonitor.Stomach.CaloriesConsumedEntry caloriesConsumedEntry = ___caloriesConsumed[index];
if ((double)caloriesConsumedEntry.calories > 0.0)
{
Diet.Info dietInfo = __instance.diet.GetDietInfo(caloriesConsumedEntry.tag);
if (dietInfo != null && (!(tag != Tag.Invalid) || !(tag != dietInfo.producedElement)))
{
num1 += dietInfo.ConvertConsumptionMassToProducedMass(dietInfo.ConvertCaloriesToConsumptionMass(caloriesConsumedEntry.calories));
tag = dietInfo.producedElement;
disease_idx = dietInfo.diseaseIdx;
num2 = (int)((double)dietInfo.diseasePerKgProduced * (double)num1);
caloriesConsumedEntry.calories = 0.0f;
___caloriesConsumed[index] = caloriesConsumedEntry;
flag = flag || dietInfo.produceSolidTile;
}
}
}
if ((double)num1 <= 0.0 || tag == Tag.Invalid)
{
return(false);
}
Element element = ElementLoader.GetElement(tag);
Debug.Assert(element != null, (object)"TODO: implement non-element tag spawning");
int cell = Grid.PosToCell(___owner.transform.GetPosition());
float temperature = ___owner.GetComponent <PrimaryElement>().Temperature;
temperature = Mathf.Max(element.lowTemp + 5f, temperature + deltaEmitTemperature);
if (element.IsLiquid)
{
FallingWater.instance.AddParticle(cell, element.idx, num1, temperature, disease_idx, num2, true, false, false, false);
}
else if (element.IsGas)
{
SimMessages.AddRemoveSubstance(cell, (int)element.idx, CellEventLogger.Instance.ElementConsumerSimUpdate, num1, temperature, disease_idx, num2, true, -1);
}
else if (flag)
{
int num3 = ___owner.GetComponent <Facing>().GetFrontCell();
if (!Grid.IsValidCell(num3))
{
Debug.LogWarningFormat("{0} attemping to Poop {1} on invalid cell {2} from cell {3}", (object)___owner, (object)element.name, (object)num3, (object)cell);
num3 = cell;
}
SimMessages.AddRemoveSubstance(num3, (int)element.idx, CellEventLogger.Instance.ElementConsumerSimUpdate, num1, temperature, disease_idx, num2, true, -1);
}
else
{
element.substance.SpawnResource(Grid.CellToPosCCC(cell, Grid.SceneLayer.Ore), num1, temperature, disease_idx, num2, false, false, false);
}
KPrefabID component = ___owner.GetComponent <KPrefabID>();
if (!Game.Instance.savedInfo.creaturePoopAmount.ContainsKey(component.PrefabTag))
{
Game.Instance.savedInfo.creaturePoopAmount.Add(component.PrefabTag, 0.0f);
}
Dictionary <Tag, float> creaturePoopAmount;
Tag prefabTag;
(creaturePoopAmount = Game.Instance.savedInfo.creaturePoopAmount)[prefabTag = component.PrefabTag] = creaturePoopAmount[prefabTag] + num1;
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Resource, element.name, ___owner.transform, 1.5f, false);
return(false);
}
else
{
return(true);
}
}
private void AddToSim(int cell, int particleIdx, ref int num_particles)
{
bool flag = false;
do
{
Element element = Grid.Element[cell];
Element.State state = element.state & Element.State.Solid;
if (state == Element.State.Solid || (Grid.Properties[cell] & 2) != 0)
{
cell += Grid.WidthInCells;
if (!Grid.IsValidCell(cell))
{
return;
}
}
else
{
flag = true;
}
}while (!flag);
ParticleProperties particleProperties = this.particleProperties[particleIdx];
SimMessages.AddRemoveSubstance(cell, particleProperties.elementIdx, CellEventLogger.Instance.FallingWaterAddToSim, particleProperties.mass, particleProperties.temperature, particleProperties.diseaseIdx, particleProperties.diseaseCount, true, -1);
RemoveParticle(particleIdx, ref num_particles);
float time = GetTime();
float num = lastSpawnTime[cell];
if (time - num >= minSpawnDelay)
{
lastSpawnTime[cell] = time;
Vector3 vector = Grid.CellToPosCCC(cell, Grid.SceneLayer.TileMain);
if (CameraController.Instance.IsAudibleSound(vector))
{
bool flag2 = true;
if (splashSounds.TryGetValue(cell, out SoundInfo value))
{
value.splashCount++;
if (value.splashCount > splashCountLoopThreshold)
{
if (value.handle == HandleVector <int> .InvalidHandle)
{
value.handle = LoopingSoundManager.StartSound(liquid_splash_loop, vector, true, true);
}
LoopingSoundManager.Get().UpdateFirstParameter(value.handle, HASH_LIQUIDDEPTH, SoundUtil.GetLiquidDepth(cell));
LoopingSoundManager.Get().UpdateSecondParameter(value.handle, HASH_LIQUIDVOLUME, GetParticleVolume(particleProperties.mass));
flag2 = false;
}
}
else
{
value = default(SoundInfo);
value.handle = HandleVector <int> .InvalidHandle;
}
value.startTime = time;
splashSounds[cell] = value;
if (flag2)
{
EventInstance instance = SoundEvent.BeginOneShot(liquid_splash_initial, vector);
instance.setParameterValue("liquidDepth", SoundUtil.GetLiquidDepth(cell));
instance.setParameterValue("liquidVolume", GetParticleVolume(particleProperties.mass));
SoundEvent.EndOneShot(instance);
}
}
}
}
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 speedMultiplier = GetSpeedMultiplier();
float num = 1f * speedMultiplier;
float num2 = 1f;
for (int i = 0; i < consumedElements.Length; i++)
{
ConsumedElement consumedElement = consumedElements[i];
float num3 = consumedElement.massConsumptionRate * num * num2;
if (num3 <= 0f)
{
num2 = 0f;
break;
}
float num4 = 0f;
for (int j = 0; j < storage.items.Count; j++)
{
GameObject gameObject = storage.items[j];
if (!((UnityEngine.Object)gameObject == (UnityEngine.Object)null) && gameObject.HasTag(consumedElement.tag))
{
PrimaryElement component = gameObject.GetComponent <PrimaryElement>();
float num5 = Mathf.Min(num3, component.Mass);
num4 += num5 / num3;
}
}
num2 = Mathf.Min(num2, num4);
}
if (!(num2 <= 0f))
{
SimUtil.DiseaseInfo diseaseInfo = SimUtil.DiseaseInfo.Invalid;
diseaseInfo.idx = byte.MaxValue;
diseaseInfo.count = 0;
float num6 = 0f;
float num7 = 0f;
float num8 = 0f;
for (int k = 0; k < consumedElements.Length; k++)
{
ConsumedElement consumedElement2 = consumedElements[k];
float num9 = consumedElement2.massConsumptionRate * num * num2;
Game.Instance.accumulators.Accumulate(consumedElement2.accumulator, num9);
for (int l = 0; l < storage.items.Count; l++)
{
GameObject gameObject2 = storage.items[l];
if (!((UnityEngine.Object)gameObject2 == (UnityEngine.Object)null))
{
if (gameObject2.HasTag(consumedElement2.tag))
{
PrimaryElement component2 = gameObject2.GetComponent <PrimaryElement>();
component2.KeepZeroMassObject = true;
float num10 = Mathf.Min(num9, component2.Mass);
float num11 = num10 / component2.Mass;
int num12 = (int)(num11 * (float)component2.DiseaseCount);
float num13 = num10 * component2.Element.specificHeatCapacity;
num8 += num13;
num7 += num13 * component2.Temperature;
component2.Mass -= num10;
component2.ModifyDiseaseCount(-num12, "ElementConverter.ConvertMass");
num6 += num10;
diseaseInfo = SimUtil.CalculateFinalDiseaseInfo(diseaseInfo.idx, diseaseInfo.count, component2.DiseaseIdx, num12);
num9 -= num10;
if (num9 <= 0f)
{
break;
}
}
if (num9 <= 0f)
{
Debug.Assert(num9 <= 0f);
}
}
}
}
float num14 = (!(num8 > 0f)) ? 0f : (num7 / num8);
if (onConvertMass != null && num6 > 0f)
{
onConvertMass(num6);
}
if (outputElements != null && outputElements.Length > 0)
{
for (int m = 0; m < outputElements.Length; m++)
{
OutputElement outputElement = outputElements[m];
SimUtil.DiseaseInfo a = diseaseInfo;
if (totalDiseaseWeight <= 0f)
{
a.idx = byte.MaxValue;
a.count = 0;
}
else
{
float num15 = outputElement.diseaseWeight / totalDiseaseWeight;
a.count = (int)((float)a.count * num15);
}
if (outputElement.addedDiseaseIdx != 255)
{
a = SimUtil.CalculateFinalDiseaseInfo(a, new SimUtil.DiseaseInfo
{
idx = outputElement.addedDiseaseIdx,
count = outputElement.addedDiseaseCount
});
}
float num16 = outputElement.massGenerationRate * OutputMultiplier * num * num2;
Game.Instance.accumulators.Accumulate(outputElement.accumulator, num16);
float num17 = 0f;
num17 = ((!outputElement.useEntityTemperature && (num14 != 0f || outputElement.minOutputTemperature != 0f)) ? Mathf.Max(outputElement.minOutputTemperature, num14) : GetComponent <PrimaryElement>().Temperature);
Element element = ElementLoader.FindElementByHash(outputElement.elementHash);
if (outputElement.storeOutput)
{
PrimaryElement primaryElement = storage.AddToPrimaryElement(outputElement.elementHash, num16, num17);
if ((UnityEngine.Object)primaryElement == (UnityEngine.Object)null)
{
if (element.IsGas)
{
storage.AddGasChunk(outputElement.elementHash, num16, num17, a.idx, a.count, true, true);
}
else if (element.IsLiquid)
{
storage.AddLiquid(outputElement.elementHash, num16, num17, a.idx, a.count, true, true);
}
else
{
GameObject go = element.substance.SpawnResource(base.transform.GetPosition(), num16, num17, a.idx, a.count, true, false, false);
storage.Store(go, true, false, true, false);
}
}
else
{
primaryElement.AddDisease(a.idx, a.count, "ElementConverter.ConvertMass");
}
}
else
{
Vector3 position = base.transform.GetPosition();
float x = position.x + outputElement.outputElementOffset.x;
Vector3 position2 = base.transform.GetPosition();
Vector3 vector = new Vector3(x, position2.y + outputElement.outputElementOffset.y, 0f);
int num18 = Grid.PosToCell(vector);
if (element.IsLiquid)
{
int idx = element.idx;
FallingWater.instance.AddParticle(num18, (byte)idx, num16, num17, a.idx, a.count, true, false, false, false);
}
else if (element.IsSolid)
{
element.substance.SpawnResource(vector, num16, num17, a.idx, a.count, false, false, false);
}
else
{
SimMessages.AddRemoveSubstance(num18, outputElement.elementHash, CellEventLogger.Instance.OxygenModifierSimUpdate, num16, num17, a.idx, a.count, true, -1);
}
}
if (outputElement.elementHash == SimHashes.Oxygen)
{
ReportManager.Instance.ReportValue(ReportManager.ReportType.OxygenCreated, num16, base.gameObject.GetProperName(), null);
}
}
}
storage.Trigger(-1697596308, base.gameObject);
}
}
