public static bool Prefix(Wire.WattageRating rating, ref float __result) { if (rating < Wire.WattageRating.NumRatings) { return(true); } switch (rating.ToExtendedWireWattageRating()) { case WattageRating.Max1MW: __result = 1e6f; break; case WattageRating.Max1GW: __result = 1e9f; break; case WattageRating.Max5kW: __result = 5e3f; break; default: __result = 0; break; } return(false); }
static void Postfix(ref float __result, Wire.WattageRating rating) { switch (rating) { case Wire.WattageRating.Max500: __result = 500f; break; case Wire.WattageRating.Max1000: __result = 1000f; break; case Wire.WattageRating.Max2000: __result = 20000f; break; case Wire.WattageRating.Max20000: __result = 20000f; break; case Wire.WattageRating.Max50000: __result = 100000f; break; default: __result = 100000f; break; } }
/// <summary> /// Triggered when overload occurs on a wire. Updates the result of this requirement if /// it is tracking that wire type. /// </summary> /// <param name="type">The type of wire that overloaded.</param> public void CheckOverload(Wire.WattageRating type) { if (this.type == type) { overloaded = true; } }
/// <summary> /// Triggered when a wire overloads. /// </summary> /// <param name="rating">The rating of the overloaded wire.</param> public static void OnOverload(Wire.WattageRating rating) { var asc = Instance; if (asc != null) { foreach (var requirement in asc.overloadRequirements) { requirement.CheckOverload(rating); } } }
public float GetMaxSafeWattage() { for (int i = 0; i < wireGroups.Length; i++) { List <Wire> list = wireGroups[i]; if (list != null && list.Count > 0) { Wire.WattageRating rating = (Wire.WattageRating)i; return(Wire.GetMaxWattageAsFloat(rating)); } } return(0f); }
public override void AddItem(int cell, object item) { Wire wire = (Wire)item; Wire.WattageRating maxWattageRating = wire.MaxWattageRating; List <Wire> list = wireGroups[(int)maxWattageRating]; if (list == null) { list = new List <Wire>(); wireGroups[(int)maxWattageRating] = list; } list.Add(wire); timeOverloaded = Mathf.Max(timeOverloaded, wire.circuitOverloadTime); }
static void Postfix(BaseWireConfig __instance, Wire.WattageRating rating, GameObject go) { Wire component = go.GetComponent <Wire>(); switch (rating) { case Wire.WattageRating.Max500: break; case Wire.WattageRating.Max1000: break; case Wire.WattageRating.Max2000: break; case Wire.WattageRating.Max20000: break; case Wire.WattageRating.Max50000: break; default: rating = Wire.WattageRating.Max50000; break; } component.MaxWattageRating = rating; float maxWattageAsFloat = Wire.GetMaxWattageAsFloat(rating); Descriptor item = default(Descriptor); item.SetupDescriptor( string.Format(UI.BUILDINGEFFECTS.MAX_WATTAGE, GameUtil.GetFormattedWattage(maxWattageAsFloat, GameUtil.WattageFormatterUnit.Automatic)), string.Format(UI.BUILDINGEFFECTS.TOOLTIPS.MAX_WATTAGE, new object[0]), Descriptor.DescriptorType.Effect); Building component2 = go.GetComponent <Building>(); BuildingDef def = component2.Def; if (def.EffectDescription == null) { def.EffectDescription = new List <Descriptor>(); } def.EffectDescription.Add(item); }
protected void DoPostConfigureComplete(Wire.WattageRating rating, GameObject go) { Wire component = go.GetComponent <Wire>(); component.MaxWattageRating = rating; float maxWattageAsFloat = Wire.GetMaxWattageAsFloat(rating); Descriptor item = default(Descriptor); item.SetupDescriptor(string.Format(UI.BUILDINGEFFECTS.MAX_WATTAGE, GameUtil.GetFormattedWattage(maxWattageAsFloat, GameUtil.WattageFormatterUnit.Automatic)), string.Format(UI.BUILDINGEFFECTS.TOOLTIPS.MAX_WATTAGE), Descriptor.DescriptorType.Effect); Building component2 = go.GetComponent <Building>(); BuildingDef def = component2.Def; if (def.EffectDescription == null) { def.EffectDescription = new List <Descriptor>(); } def.EffectDescription.Add(item); }
private static void Postfix(Wire.WattageRating rating, ref float __result) { if (CustomizeBuildingsState.StateManager.State.WireSmallWatts == 1000 && CustomizeBuildingsState.StateManager.State.WireRefinedWatts == 2000 && CustomizeBuildingsState.StateManager.State.WireHeavyWatts == 20000 && CustomizeBuildingsState.StateManager.State.WireRefinedHeavyWatts == 50000) { return; } switch (rating) { case Wire.WattageRating.Max500: __result = 500f; break; case Wire.WattageRating.Max1000: __result = CustomizeBuildingsState.StateManager.State.WireSmallWatts; break; case Wire.WattageRating.Max2000: __result = CustomizeBuildingsState.StateManager.State.WireRefinedWatts; break; case Wire.WattageRating.Max20000: __result = CustomizeBuildingsState.StateManager.State.WireHeavyWatts; break; case Wire.WattageRating.Max50000: __result = CustomizeBuildingsState.StateManager.State.WireRefinedHeavyWatts; break; default: __result = 0.0f; break; } }
public static GameUtil.WattageFormatterUnit GetFormatterUnit(this Wire.WattageRating rating) => rating.ToExtendedWireWattageRating().GetFormatterUnit();
public override void Deserialize(IReader reader) { type = (Wire.WattageRating)reader.ReadInt32(); overloaded = false; }
public static WattageRating ToExtendedWireWattageRating(this Wire.WattageRating rating) => (WattageRating)(int)rating;
/// <summary> /// Triggered when a wire overloads. /// </summary> /// <param name="rating">The rating of the overloaded wire.</param> public static void OnOverload(Wire.WattageRating rating) { Trigger(OverloadWire.PREFIX + rating.ToString()); }
/// <summary> /// Retrieves the wattage rating of an electrical network, with a slight margin to /// avoid overloading on rounding issues. /// </summary> /// <param name="rating">The wattage rating of the wire.</param> /// <returns>The wattage the wire can handle before overloading.</returns> private static float GetRoundedMaxWattage(Wire.WattageRating rating) { return(Wire.GetMaxWattageAsFloat(rating) + 0.4f); }
public void Deserialize(IReader reader) { // Needs special case deserialization for save file migration type = (Wire.WattageRating)reader.ReadInt32(); }
public OverloadWire(Wire.WattageRating type) { this.type = type; }
public static bool Prefix(ElectricalUtilityNetwork __instance, float dt, float watts_used, List <WireUtilityNetworkLink>[] bridgeGroups, ref float ___timeOverloaded, ref GameObject ___targetOverloadedWire, ref Notification ___overloadedNotification, ref float ___timeOverloadNotificationDisplayed, List <Wire>[] ___wireGroups) { Log.Spam($"UpdateOverloadTime: {___wireGroups.Length}, {bridgeGroups.Length}"); bool wattage_rating_exceeded = false; List <Wire> overloaded_wires = null; List <WireUtilityNetworkLink> overloaded_bridges = null; for (int rating_idx = 0; rating_idx < ___wireGroups.Length; rating_idx++) { List <Wire> wires = ___wireGroups[rating_idx]; List <WireUtilityNetworkLink> bridges = bridgeGroups[rating_idx]; Wire.WattageRating rating = (Wire.WattageRating)rating_idx; float max_wattage = Wire.GetMaxWattageAsFloat(rating); if (watts_used > max_wattage && ((bridges != null && bridges.Count > 0) || (wires != null && wires.Count > 0))) { wattage_rating_exceeded = true; overloaded_wires = wires; overloaded_bridges = bridges; break; } } overloaded_wires?.RemoveAll((Wire x) => x == null); overloaded_bridges?.RemoveAll((WireUtilityNetworkLink x) => x == null); if (wattage_rating_exceeded) { ___timeOverloaded += dt; if (!(___timeOverloaded > 6f)) { return(false); } ___timeOverloaded = 0f; if (___targetOverloadedWire == null) { if (overloaded_bridges != null && overloaded_bridges.Count > 0) { int random_bridge_idx = Random.Range(0, overloaded_bridges.Count); ___targetOverloadedWire = overloaded_bridges[random_bridge_idx].gameObject; } else if (overloaded_wires != null && overloaded_wires.Count > 0) { int random_wire_idx = Random.Range(0, overloaded_wires.Count); ___targetOverloadedWire = overloaded_wires[random_wire_idx].gameObject; } } if (___targetOverloadedWire != null) { ___targetOverloadedWire.Trigger(-794517298, new BuildingHP.DamageSourceInfo { damage = 1, source = STRINGS.BUILDINGS.DAMAGESOURCES.CIRCUIT_OVERLOADED, popString = STRINGS.UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.CIRCUIT_OVERLOADED, takeDamageEffect = SpawnFXHashes.BuildingSpark, fullDamageEffectName = "spark_damage_kanim", statusItemID = Db.Get().BuildingStatusItems.Overloaded.Id }); } if (___overloadedNotification == null) { ___timeOverloadNotificationDisplayed = 0f; ___overloadedNotification = new Notification(STRINGS.MISC.NOTIFICATIONS.CIRCUIT_OVERLOADED.NAME, NotificationType.BadMinor, HashedString.Invalid, null, null, true, 0f, null, null, ___targetOverloadedWire.transform); GameScheduler.Instance.Schedule("Power Tutorial", 2f, delegate { Tutorial.Instance.TutorialMessage(Tutorial.TutorialMessages.TM_Power); }); Notifier notifier = Game.Instance.FindOrAdd <Notifier>(); notifier.Add(___overloadedNotification); } } else { ___timeOverloaded = Mathf.Max(0f, ___timeOverloaded - dt * 0.95f); ___timeOverloadNotificationDisplayed += dt; if (___timeOverloadNotificationDisplayed > 5f) { Traverse.Create(__instance).Method("RemoveOverloadedNotification").GetValue(); } } return(false); }
public void Rebuild() { for (int i = 0; i < this.circuitInfo.Count; i++) { CircuitInfo value = this.circuitInfo[i]; value.generators.Clear(); value.consumers.Clear(); value.batteries.Clear(); value.inputTransformers.Clear(); value.outputTransformers.Clear(); value.minBatteryPercentFull = 1f; for (int j = 0; j < value.bridgeGroups.Length; j++) { value.bridgeGroups[j].Clear(); } this.circuitInfo[i] = value; } consumersShadow.AddRange(consumers); List <IEnergyConsumer> .Enumerator enumerator = consumersShadow.GetEnumerator(); while (enumerator.MoveNext()) { IEnergyConsumer current = enumerator.Current; int powerCell = current.PowerCell; ushort circuitID = GetCircuitID(powerCell); if (circuitID != 65535) { Battery battery = current as Battery; if ((Object)battery != (Object)null) { Operational component = battery.GetComponent <Operational>(); if ((Object)component == (Object)null || component.IsOperational) { CircuitInfo value2 = this.circuitInfo[circuitID]; PowerTransformer powerTransformer = battery.powerTransformer; if ((Object)powerTransformer != (Object)null) { value2.inputTransformers.Add(battery); } else { value2.batteries.Add(battery); CircuitInfo circuitInfo = this.circuitInfo[circuitID]; value2.minBatteryPercentFull = Mathf.Min(circuitInfo.minBatteryPercentFull, battery.PercentFull); } this.circuitInfo[circuitID] = value2; } } else { CircuitInfo circuitInfo2 = this.circuitInfo[circuitID]; circuitInfo2.consumers.Add(current); } } } consumersShadow.Clear(); for (int k = 0; k < this.circuitInfo.Count; k++) { CircuitInfo circuitInfo3 = this.circuitInfo[k]; circuitInfo3.consumers.Sort((IEnergyConsumer a, IEnergyConsumer b) => a.WattsNeededWhenActive.CompareTo(b.WattsNeededWhenActive)); } HashSet <Generator> .Enumerator enumerator2 = generators.GetEnumerator(); while (enumerator2.MoveNext()) { Generator current2 = enumerator2.Current; int powerCell2 = current2.PowerCell; ushort circuitID2 = GetCircuitID(powerCell2); if (circuitID2 != 65535) { if (current2.GetType() == typeof(PowerTransformer)) { CircuitInfo circuitInfo4 = this.circuitInfo[circuitID2]; circuitInfo4.outputTransformers.Add(current2); } else { CircuitInfo circuitInfo5 = this.circuitInfo[circuitID2]; circuitInfo5.generators.Add(current2); } } } HashSet <WireUtilityNetworkLink> .Enumerator enumerator3 = bridges.GetEnumerator(); while (enumerator3.MoveNext()) { WireUtilityNetworkLink current3 = enumerator3.Current; current3.GetCells(out int linked_cell, out int _); ushort circuitID3 = GetCircuitID(linked_cell); if (circuitID3 != 65535) { Wire.WattageRating maxWattageRating = current3.GetMaxWattageRating(); CircuitInfo circuitInfo6 = this.circuitInfo[circuitID3]; circuitInfo6.bridgeGroups[(int)maxWattageRating].Add(current3); } } dirty = false; }
public void UpdateOverloadTime(float dt, float watts_used, List <WireUtilityNetworkLink>[] bridgeGroups) { bool flag = false; List <Wire> list = null; List <WireUtilityNetworkLink> list2 = null; for (int i = 0; i < 5; i++) { List <Wire> list3 = wireGroups[i]; List <WireUtilityNetworkLink> list4 = bridgeGroups[i]; Wire.WattageRating rating = (Wire.WattageRating)i; float maxWattageAsFloat = Wire.GetMaxWattageAsFloat(rating); if (watts_used > maxWattageAsFloat && ((list4 != null && list4.Count > 0) || (list3 != null && list3.Count > 0))) { flag = true; list = list3; list2 = list4; break; } } list?.RemoveAll((Wire x) => (Object)x == (Object)null); list2?.RemoveAll((WireUtilityNetworkLink x) => (Object)x == (Object)null); if (flag) { timeOverloaded += dt; if (timeOverloaded > 6f) { timeOverloaded = 0f; if ((Object)targetOverloadedWire == (Object)null) { if (list2 != null && list2.Count > 0) { int index = Random.Range(0, list2.Count); targetOverloadedWire = list2[index].gameObject; } else if (list != null && list.Count > 0) { int index2 = Random.Range(0, list.Count); targetOverloadedWire = list[index2].gameObject; } } if ((Object)targetOverloadedWire != (Object)null) { targetOverloadedWire.Trigger(-794517298, new BuildingHP.DamageSourceInfo { damage = 1, source = (string)BUILDINGS.DAMAGESOURCES.CIRCUIT_OVERLOADED, popString = (string)UI.GAMEOBJECTEFFECTS.DAMAGE_POPS.CIRCUIT_OVERLOADED, takeDamageEffect = SpawnFXHashes.BuildingSpark, fullDamageEffectName = "spark_damage_kanim", statusItemID = Db.Get().BuildingStatusItems.Overloaded.Id }); } if (overloadedNotification == null) { timeOverloadNotificationDisplayed = 0f; string title = MISC.NOTIFICATIONS.CIRCUIT_OVERLOADED.NAME; NotificationType type = NotificationType.BadMinor; HashedString invalid = HashedString.Invalid; Transform transform = targetOverloadedWire.transform; overloadedNotification = new Notification(title, type, invalid, null, null, true, 0f, null, null, transform); Notifier notifier = Game.Instance.FindOrAdd <Notifier>(); notifier.Add(overloadedNotification, string.Empty); } } } else { timeOverloaded = Mathf.Max(0f, timeOverloaded - dt * 0.95f); timeOverloadNotificationDisplayed += dt; if (timeOverloadNotificationDisplayed > 5f) { RemoveOverloadedNotification(); } } }