private object NewProxy(Type interfaceType)
{
IConduit conduit = new Conduit(interfaceType);
conduits.Add(conduit);
return conduit.Proxy;
}
protected override void OnCleanUp()
{
Conduit.GetFlowManager(conduitType).RemoveConduitUpdater(ConduitUpdate);
base.OnCleanUp();
}
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");
}
public void UpdateOverlayColours()
{
GridArea visibleArea = GridVisibleArea.GetVisibleArea();
Diseases diseases = Db.Get().Diseases;
Color32 color = new Color32(0, 0, 0, byte.MaxValue);
for (int i = 0; i < headers.Count; i++)
{
DiseaseContainer payload = payloads[i];
DiseaseHeader header = headers[i];
KBatchedAnimController controller = payload.controller;
if ((UnityEngine.Object)controller != (UnityEngine.Object)null)
{
Color32 c = color;
Vector3 position = controller.transform.GetPosition();
if (visibleArea.Min <= (Vector2)position && (Vector2)position <= visibleArea.Max)
{
int num = 0;
int disease_idx = 255;
int disease_count = 0;
GetVisualDiseaseIdxAndCount(header, ref payload, out disease_idx, out disease_count);
if (disease_idx != 255)
{
c = diseases[disease_idx].overlayColour;
num = disease_count;
}
if (payload.isContainer)
{
Storage component = header.primaryElement.GetComponent <Storage>();
List <GameObject> items = component.items;
for (int j = 0; j < items.Count; j++)
{
GameObject gameObject = items[j];
if ((UnityEngine.Object)gameObject != (UnityEngine.Object)null)
{
HandleVector <int> .Handle handle = GetHandle(gameObject);
if (handle.IsValid())
{
DiseaseHeader header2 = GetHeader(handle);
if (header2.diseaseCount > num && header2.diseaseIdx != 255)
{
num = header2.diseaseCount;
c = diseases[header2.diseaseIdx].overlayColour;
}
}
}
}
}
c.a = SimUtil.DiseaseCountToAlpha254(num);
if (payload.conduitType != 0)
{
ConduitFlow flowManager = Conduit.GetFlowManager(payload.conduitType);
int cell = Grid.PosToCell(position);
ConduitFlow.ConduitContents contents = flowManager.GetContents(cell);
if (contents.diseaseIdx != 255 && contents.diseaseCount > num)
{
num = contents.diseaseCount;
c = diseases[contents.diseaseIdx].overlayColour;
c.a = byte.MaxValue;
}
}
}
controller.OverlayColour = c;
}
}
}
public FindIntersection(
FamilyInstance jbox,
UIDocument uiDoc)
{
XYZ jboxPoint = (jbox.Location
as LocationPoint).Point;
FilteredElementCollector filteredCloserConduits
= new FilteredElementCollector(uiDoc.Document);
List <Element> listOfCloserConduit
= filteredCloserConduits
.OfClass(typeof(Conduit))
.ToList()
.Where(x
=> ((x as Conduit).Location as LocationCurve).Curve
.GetEndPoint(0).DistanceTo(jboxPoint) < 30 ||
((x as Conduit).Location as LocationCurve).Curve
.GetEndPoint(1).DistanceTo(jboxPoint) < 30)
.ToList();
// getting the location of the box and all conduit around.
Options opt = new Options();
opt.View = uiDoc.ActiveView;
GeometryElement geoEle = jbox.get_Geometry(opt);
// getting the geometry of the element to
// access the geometry of the instance.
foreach (GeometryObject geomObje1 in geoEle)
{
GeometryElement geoInstance = (geomObje1
as GeometryInstance).GetInstanceGeometry();
// the geometry of the family instance can be
// accessed by this method that returns a
// GeometryElement type. so we must get the
// GeometryObject again to access the Face of
// the family instance.
if (geoInstance != null)
{
foreach (GeometryObject geomObje2 in geoInstance)
{
Solid geoSolid = geomObje2 as Solid;
if (geoSolid != null)
{
foreach (Face face in geoSolid.Faces)
{
foreach (Element cond in listOfCloserConduit)
{
Conduit con = cond as Conduit;
Curve conCurve = (con.Location as LocationCurve).Curve;
SetComparisonResult set = face.Intersect(conCurve);
if (set.ToString() == "Overlap")
{
//getting the conduit the intersect the box.
GetListOfConduits.Add(con);
}
}
}
}
}
}
}
}
//helper method to ittereate thru connectors of a run
private List <ElementId> E_AddConduitAndNeighborFittingsToSelection(Conduit conduit, List <ElementId> elementsInConduitRun)
{
Document doc = this.Document;
ConnectorSet connectors = conduit.ConnectorManager.Connectors;
string str = "";
//Get Conduit and its neighbor connected fitting elements
foreach (Connector con in connectors)
{
if (con.IsConnected)
{
if (!elementsInConduitRun.Contains(con.Owner.Id))
{
elementsInConduitRun.Add(con.Owner.Id);
str += "Conduit: " + con.Owner.Id.ToString() + "\n";
}
ConnectorSet refs = con.AllRefs;
foreach (Connector conRef in refs)
{
if (conRef.IsConnected)
{
if (!elementsInConduitRun.Contains(conRef.Owner.Id))
{
elementsInConduitRun.Add(conRef.Owner.Id);
str += "Conduit Fitting: " + conRef.Owner.Id.ToString() + "\n";
//Get the fittings neighbor conduit and recall the main method
Categories categories = doc.Settings.Categories;
ElementId conduitFittingCategoryId = categories.get_Item(BuiltInCategory.OST_ConduitFitting).Id;
FamilyInstance fi = conRef.Owner as FamilyInstance;
if (fi != null && fi.Category.Id == conduitFittingCategoryId)
{
ConnectorSet cons = fi.MEPModel.ConnectorManager.Connectors;
foreach (Connector c2 in cons)
{
ConnectorSet c2Refs = c2.AllRefs;
foreach (Connector c2Ref in c2Refs)
{
if (!elementsInConduitRun.Contains(c2Ref.Owner.Id))
{
str += "Conduit: " + c2Ref.Owner.Id.ToString() + "\n";
Conduit c = c2Ref.Owner as Conduit;
if (c != null)
{
//TaskDialog.Show("Before Call", elementsInConduitRun.Count.ToString());
elementsInConduitRun = E_AddConduitAndNeighborFittingsToSelection(c, elementsInConduitRun);
}
}
}
}
}
}
}
}
//str += "\n";
}
}
//TaskDialog.Show("All Itereated Conduit Info last", str + "\n" + "\n" + elementsInConduitRun.Count.ToString());
return(elementsInConduitRun);
}
public float GetSliderMax(int index)
{
var flowManager = Conduit.GetFlowManager(GetComponent <TeleStorage>().Type);
return(Traverse.Create(flowManager).Field("MaxMass").GetValue <float>() * GramsPerKilogram);
}
private void ConvertMass()
{
SimUtil.DiseaseInfo diseaseInfo = SimUtil.DiseaseInfo.Invalid;
diseaseInfo.idx = byte.MaxValue;
diseaseInfo.count = 0;
float speedMultiplier = GetSpeedMultiplier();
// Accumulators
float oxygenMass = 0f;
float hydrogenMass = 0f;
float bleachStoneMass = 0f;
float totalConsumedAmount = 0f;
float waterConsumptionRate = Config.waterConsumptionRate * speedMultiplier;
Tag dirtyWaterTag = SimHashes.DirtyWater.CreateTag();
Tag saltWaterTag = SimHashes.SaltWater.CreateTag();
Tag brineTag = SimHashes.Brine.CreateTag();
bool isDirty = false;
for (int i = 0; i < storage.items.Count; i++)
{
GameObject storageItem = storage.items[i];
if (storageItem != null && storageItem.HasTag(GameTags.AnyWater))
{
PrimaryElement element = storageItem.GetComponent <PrimaryElement>();
//element.KeepZeroMassObject = true;
float consumedAmount = Mathf.Min(waterConsumptionRate, element.Mass);
float consumedPercentage = consumedAmount / element.Mass;
int diseaseCount = (int)(consumedPercentage * element.DiseaseCount);
element.Mass -= consumedAmount;
element.ModifyDiseaseCount(-diseaseCount, "IndustrialElectrolyzer.ConvertMass");
if (storageItem.HasTag(saltWaterTag))
{
// 93% H2O
oxygenMass += consumedAmount * Config.saltWater2WaterRatio * Config.water2OxygenRatio;
hydrogenMass += consumedAmount * Config.saltWater2WaterRatio * Config.water2HydrogenRatio;
// 7% NaCl
bleachStoneMass += consumedAmount * Config.saltWater2SaltRatio * Config.salt2BleachStoneRatio;
}
else if (storageItem.HasTag(brineTag))
{
// 70% H2O
oxygenMass += consumedAmount * Config.brine2WaterRatio * Config.water2OxygenRatio;
hydrogenMass += consumedAmount * Config.brine2WaterRatio * Config.water2HydrogenRatio;
// 30% NaCl
bleachStoneMass += consumedAmount * Config.brine2SaltRatio * Config.salt2BleachStoneRatio;
}
else
{
oxygenMass += consumedAmount * Config.water2OxygenRatio;
hydrogenMass += consumedAmount * Config.water2HydrogenRatio;
}
totalConsumedAmount += consumedAmount;
if (storageItem.HasTag(dirtyWaterTag) && consumedAmount > EPSILON)
{
isDirty = true;
}
diseaseInfo = SimUtil.CalculateFinalDiseaseInfo(diseaseInfo.idx, diseaseInfo.count, element.DiseaseIdx, element.DiseaseCount);
waterConsumptionRate -= consumedAmount;
if (waterConsumptionRate <= 0f)
{
Debug.Assert(waterConsumptionRate <= 0f);
break;
}
}
}
float temperature = GetComponent <PrimaryElement>().Temperature;
if (onConvertMass != null && totalConsumedAmount > EPSILON)
{
onConvertMass(totalConsumedAmount);
}
ConduitFlow gasFlowManager = Conduit.GetFlowManager(portInfo.conduitType);
SimHashes oxygenHash = isDirty ? SimHashes.ContaminatedOxygen : SimHashes.Oxygen;
float oxygenGenerated = gasFlowManager.AddElement(oxygenOutputCell, oxygenHash, oxygenMass * speedMultiplier, Mathf.Max(Config.oxygenTemperature, temperature), diseaseInfo.idx, diseaseInfo.count / 2);
ReportManager.Instance.ReportValue(ReportManager.ReportType.OxygenCreated, oxygenGenerated, gameObject.GetProperName());
Game.Instance.accumulators.Accumulate(OxygenAccumulator, oxygenGenerated);
float hydrogenGenerated = gasFlowManager.AddElement(hydrogenOutputCell, SimHashes.Hydrogen, hydrogenMass * speedMultiplier, Mathf.Max(Config.hydrogenTemperature, temperature), diseaseInfo.idx, diseaseInfo.count / 2);
Game.Instance.accumulators.Accumulate(HydrogenAccumulator, hydrogenGenerated);
if (bleachStoneMass > EPSILON)
{
Element bleachStone = ElementLoader.FindElementByHash(SimHashes.BleachStone);
Vector3 position = building.GetRotatedOffset(new CellOffset(1, 0)).ToVector3() + new Vector3(.5f, .5f, .0f) + transform.position;
UnityEngine.Debug.Log("[AE] transform is at " + transform.position);
UnityEngine.Debug.Log("[AE] exit is at " + position);
bleachStone.substance.SpawnResource(position, bleachStoneMass, temperature, diseaseInfo.idx, diseaseInfo.count);
}
storage.Trigger((int)GameHashes.OnStorageChange, gameObject);
}
protected override void OnCompleteWork(Worker worker)
{
float num = 0f;
float num2 = 0f;
bool flag = true;
foreach (GameObject item in storage.items)
{
if (!((UnityEngine.Object)item == (UnityEngine.Object)null))
{
PrimaryElement component = item.GetComponent <PrimaryElement>();
if (!((UnityEngine.Object)component == (UnityEngine.Object)null))
{
num += component.Mass;
num2 += component.Temperature * component.Mass;
flag = (flag && component.HasTag(GameTags.Liquifiable));
}
}
}
if (num <= 0f)
{
DebugUtil.LogWarningArgs(base.gameObject, "uhhh this constructable is about to generate a nan", "Item Count: ", storage.items.Count);
}
else
{
if (flag)
{
initialTemperature = Mathf.Min(num2 / num, 318.15f);
}
else
{
initialTemperature = Mathf.Clamp(num2 / num, 288.15f, 318.15f);
}
KAnimGraphTileVisualizer component2 = GetComponent <KAnimGraphTileVisualizer>();
UtilityConnections connections = (!((UnityEngine.Object)component2 == (UnityEngine.Object)null)) ? component2.Connections : ((UtilityConnections)0);
if (IsReplacementTile)
{
int cell = Grid.PosToCell(base.transform.GetLocalPosition());
GameObject replacementCandidate = building.Def.GetReplacementCandidate(cell);
if ((UnityEngine.Object)replacementCandidate != (UnityEngine.Object)null)
{
SimCellOccupier component3 = replacementCandidate.GetComponent <SimCellOccupier>();
if ((UnityEngine.Object)component3 != (UnityEngine.Object)null)
{
component3.DestroySelf(delegate
{
if ((UnityEngine.Object) this != (UnityEngine.Object)null && (UnityEngine.Object)base.gameObject != (UnityEngine.Object)null)
{
FinishConstruction(connections);
}
});
}
else
{
Conduit component4 = replacementCandidate.GetComponent <Conduit>();
if ((UnityEngine.Object)component4 != (UnityEngine.Object)null)
{
ConduitFlow flowManager = component4.GetFlowManager();
flowManager.MarkForReplacement(cell);
}
BuildingComplete component5 = replacementCandidate.GetComponent <BuildingComplete>();
if ((UnityEngine.Object)component5 != (UnityEngine.Object)null)
{
component5.Subscribe(-21016276, delegate
{
FinishConstruction(connections);
});
}
else
{
Debug.LogWarning("Why am I trying to replace a: " + replacementCandidate.name);
FinishConstruction(connections);
}
}
KAnimGraphTileVisualizer component6 = replacementCandidate.GetComponent <KAnimGraphTileVisualizer>();
if ((UnityEngine.Object)component6 != (UnityEngine.Object)null)
{
component6.skipCleanup = true;
}
PrimaryElement component7 = replacementCandidate.GetComponent <PrimaryElement>();
float mass = component7.Mass;
float temperature = component7.Temperature;
byte diseaseIdx = component7.DiseaseIdx;
int diseaseCount = component7.DiseaseCount;
Debug.Assert(component7.Element != null && component7.Element.tag != (Tag)null);
Deconstructable.SpawnItem(component7.transform.GetPosition(), component7.GetComponent <Building>().Def, component7.Element.tag, mass, temperature, diseaseIdx, diseaseCount);
replacementCandidate.Trigger(1606648047, building.Def.TileLayer);
replacementCandidate.DeleteObject();
}
}
else
{
FinishConstruction(connections);
}
PopFXManager.Instance.SpawnFX(PopFXManager.Instance.sprite_Building, GetComponent <KSelectable>().GetName(), base.transform, 1.5f, false);
}
}
/// <summary>
/// Adds the new conduit.
/// </summary>
/// <param name="doc"></param>
/// <param name="typeId"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="lvlId"></param>
/// <returns></returns>
public static Conduit AddConduit(this Document doc, ElementId typeId, XYZ start, XYZ end, ElementId lvlId)
{
return(Conduit.Create(doc, typeId, start, end, lvlId));
}
public Result Execute(ExternalCommandData revit, ref string message, ElementSet elements)
{
try
{
var document = revit.Application.ActiveUIDocument.Document;
GetSomeShit(document, out string error);
if (error != null)
{
TaskDialog.Show("Ошибка", error);
return(Result.Succeeded);
}
var systemsByEquipmentIds = new Dictionary <ElementId, List <ElementId> >();
foreach (var system in ElectricalSystems)
{
var equipment = system.BaseEquipment;
if (equipment == null)
{
continue;
}
if (!systemsByEquipmentIds.ContainsKey(equipment.Id))
{
systemsByEquipmentIds.Add(equipment.Id, new List <ElementId>());
}
systemsByEquipmentIds[equipment.Id].Add(system.Id);
}
var conduitTypes = new Dictionary <string, ElementId>();
foreach (ConduitType type in ConduitTypes)
{
conduitTypes.Add(type.FamilyName + ": " + type.Name, type.Id);
}
var gui = new UserForm(document, systemsByEquipmentIds, conduitTypes);
if (gui.ShowDialog() != DialogResult.OK)
{
return(Result.Cancelled);
}
var conduitTypeId = gui.SelectedConduitType;
var electricalCircuitsWithLevelId = new List <Tuple <ElementId, List <XYZ> > >();
foreach (var systemId in gui.SelectedCircuits)
{
var system = (ElectricalSystem)document.GetElement(systemId);
var circuit = system.GetCircuitPath().ToList();
electricalCircuitsWithLevelId.Add(new Tuple <ElementId, List <XYZ> >(system.LevelId, circuit));
}
Transaction tr = new Transaction(document, "Создание коробов по электрической цепи");
tr.Start();
foreach (var x in electricalCircuitsWithLevelId)
{
var createdConduits = new List <Conduit>();
for (var i = 0; i < x.Item2.Count() - 1; i++)
{
var startPoint = new XYZ(
Math.Min(x.Item2[i].X, x.Item2[i + 1].X) - 0.01,
Math.Min(x.Item2[i].Y, x.Item2[i + 1].Y) - 0.01,
Math.Min(x.Item2[i].Z, x.Item2[i + 1].Z) - 0.01
);
var endPoint = new XYZ(
Math.Max(x.Item2[i].X, x.Item2[i + 1].X) + 0.01,
Math.Max(x.Item2[i].Y, x.Item2[i + 1].Y) + 0.01,
Math.Max(x.Item2[i].Z, x.Item2[i + 1].Z) + 0.01
);
var myOutLn = new Outline(startPoint, endPoint);
var conduits = new List <ElementId>();
if (!myOutLn.IsEmpty)
{
var filter = new BoundingBoxIsInsideFilter(myOutLn);
var collector = new FilteredElementCollector(document);
conduits = collector
.WherePasses(filter)
.OfClass(typeof(Conduit))
.Cast <Conduit>()
.Select(a => a.Id)
.ToList();
}
document.Delete(conduits);
var conduit = Conduit.Create(document, conduitTypeId, x.Item2.ElementAt(i), x.Item2.ElementAt(i + 1), x.Item1);
createdConduits.Add(conduit);
}
//for (var i = 0; i < createdConduits.Count() - 1; i++)
//{
// var connector1 = new Connector();
// var connector2;
// foreach (Connector c in createdConduits.ElementAt(i).ConnectorManager.Connectors)
// {
// // моя тут сломался фмгня получается
// connector1 = c;
// break;
// }
// foreach (Connector c in createdConduits.ElementAt(i+1).ConnectorManager.Connectors)
// {
//
// connector2 = c;
// break;
// }
// document.Create.NewElbowFitting(
// connector1,
// connector2);
//}
}
tr.Commit();
return(Result.Succeeded);
}
catch (Exception e)
{
TaskDialog.Show("Error", e.ToString());
return(Result.Failed);
}
return(Result.Succeeded);
}
/// <summary>
/// Applied after OnSpawn runs.
/// </summary>
internal static void Postfix(Conduit __instance)
{
__instance.gameObject.AddOrGet <FindMismatchedPipe>();
}
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");
ConduitFlow flowManager = null;
//Debug.Log("ConduitUpdate " + dt);
if (__instance.conduitType == (ConduitType)100)
{
flowManager = Conduit.GetFlowManager(ConduitType.Liquid);
}
else if (__instance.conduitType == (ConduitType)101)
{
flowManager = Conduit.GetFlowManager(ConduitType.Gas);
}
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);
if (__instance.conduitType == (ConduitType)100)
{
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));
}
else if (__instance.conduitType == (ConduitType)101)
{
GasWarpData.GasPackets.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;
}
foreach (PacketData packet in GasWarpData.GasPackets)
{
//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)
{
GasWarpData.GasPackets.Remove(toRemove);
toRemove = null;
}
__instance.UpdateAnim();
return(false);
}
return(false);
}
protected override void OnCleanUp()
{
Conduit.GetFlowManager(Type).RemoveConduitUpdater(ConduitUpdate);
TeleStorageData.Instance.storageContainers.Remove(this);
base.OnCleanUp();
}
/// <summary>
/// 选择模型中的线管或者电气设备
/// </summary>
/// <returns></returns>
private bool SelectCabinet_Conduit(UIDocument uidoc, out FamilyInstance cabinet, out Conduit conduit)
{
cabinet = null;
conduit = null;
Document doc = uidoc.Document;
try
{
//
var machineRef = uidoc.Selection.PickObject(ObjectType.Element, new SelectionFilter_Cabinet_Conduit(),
"选择线管或者电气设备。");
var pickedEle = doc.GetElement(machineRef);
//选择线管。
if (IsCabinet(pickedEle))
{
cabinet = pickedEle as FamilyInstance;
//
machineRef = uidoc.Selection.PickObject(ObjectType.Element, new SelectionFilter_Conduit(), "选择线管。");
conduit = doc.GetElement(machineRef) as Conduit;
return(true);
}
else if (IsConduit(pickedEle))
{
conduit = pickedEle as Conduit;
//选择电气设备
machineRef = uidoc.Selection.PickObject(ObjectType.Element, new SelectionFilter_Cabinet(), "选择电气设备。");
cabinet = doc.GetElement(machineRef) as FamilyInstance;
return(true);
}
}
catch (OperationCanceledException ex)
{
return(false);
}
return(false);
}
protected override void OnCleanUp()
{
Conduit.GetFlowManager(type).RemoveConduitUpdater(ConduitUpdate);
Game.Instance.accumulators.Remove(accumulator);
base.OnCleanUp();
}
internal static void Postfix(Conduit __instance)
{
__instance.gameObject.AddOrGet <Pressurized>();
}
public ConduitLine(Conduit conduit)
{
Line = conduit;
ConnectorManager = conduit.ConnectorManager;
}
private void ConduitUpdate(float dt)
{
var flowManager = Conduit.GetFlowManager(Type);
if (!flowManager.HasConduit(_inputCell) || !IsOperational)
{
return;
}
var contents = flowManager.GetContents(_inputCell);
if (contents.mass <= 0.0)
{
return;
}
var contentOutput1 = flowManager.GetContents(_outputCell);
var contentOutput2 = flowManager.GetContents(_secondaryOutputCell);
var maxMass = 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);
}
