/// <summary> /// Gets both the current wattage generated and the potential wattage generated. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> /// <param name="potential">The location where the potential power generation will be stored.</param> /// <returns>The power currently being generated.</returns> private static float GetWattageGenerated(CircuitManager manager, ushort circuitID, out float potential) { float generated = 0.0f, total = 0.0f; if (circuitID != ushort.MaxValue) { var generators = manager.circuitInfo[circuitID].generators; int n = generators.Count; for (int i = 0; i < n; i++) { var generator = generators[i]; if (generator != null) { float watts = generator.WattageRating; total += watts; if (generator.IsProducingPower()) { generated += watts; } } } } potential = total; return(generated); }
/// <summary> /// Updates the list of energy consumers on the circuit. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> private void RefreshConsumers(CircuitManager manager, ushort circuitID) { var info = manager.circuitInfo[circuitID]; var consumers = info.consumers; var transformers = info.inputTransformers; var target = lastSelected.lastTarget; int nc = consumers.Count, nt = transformers.Count; setInactive.UnionWith(consumerLabels); consumerLabels.Clear(); for (int i = 0; i < nc; i++) { var consumer = consumers[i]; AddConsumer(consumer, i, consumer.WattsNeededWhenActive, target); } for (int i = 0; i < nt; i++) { var transformer = transformers[i]; AddConsumer(transformer, i + nc, transformer.powerTransformer.WattageRating, target); } if (nc + nt <= 0) { var label = AddOrGetLabel(es.labelTemplate, consumerParent, "noconsumers"); label.text.SetText(ENERGYGENERATOR.NOCONSUMERS); consumerLabels.Add(label); } setInactive.ExceptWith(consumerLabels); foreach (var label in setInactive) { label.SetActive(false); } setInactive.Clear(); }
/// <summary> /// Fixes GetWattsNeededWhenActive to include transformers in the maximum wattage /// consumed rating. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> /// <returns>The maximum wattage that circuit needs when all loads are active.</returns> public static float GetWattsNeededWhenActive(CircuitManager manager, ushort circuitID) { float wattage = 0.0f; if (circuitID != ushort.MaxValue) { var circuit = manager.circuitInfo[circuitID]; var consumers = circuit.consumers; var transformers = circuit.inputTransformers; int n = consumers.Count; for (int i = 0; i < n; i++) { var consumer = consumers[i]; if (consumer != null) { wattage += consumer.WattsNeededWhenActive; } } n = transformers.Count; for (int i = 0; i < n; i++) { var transformer = transformers[i]; if (transformer != null) { wattage += transformer.powerTransformer.BaseWattageRating; } } } return(wattage); }
void Start() { circuitManager = GameObject.Find("CircuitManager").GetComponent <CircuitManager>(); gameManager = GameObject.Find("GameManager").GetComponent <GameManager>(); keySound = GetComponent <AudioSource>(); }
/// <summary> /// Adds electrical circuits if needed to match the number of wire networks. /// </summary> /// <param name="instance">The circuit manager to initialize.</param> /// <param name="electricalSystem">The current electrical network.</param> private static void InitNetworks(CircuitManager instance, UtilityNetworkManager <ElectricalUtilityNetwork, Wire> electricalSystem) { var networks = electricalSystem.GetNetworks(); var circuits = instance.circuitInfo; int nGroups = (int)Wire.WattageRating.NumRatings, nNetworks = networks.Count; while (circuits.Count < nNetworks) { var newInfo = new CircuitInfo { generators = new List <Generator>(16), consumers = new List <IEnergyConsumer>(32), batteries = new List <Battery>(16), inputTransformers = new List <Battery>(8), outputTransformers = new List <Generator>(16) }; var wireLinks = new List <WireUtilityNetworkLink> [nGroups]; for (int i = 0; i < nGroups; i++) { wireLinks[i] = new List <WireUtilityNetworkLink>(8); } newInfo.bridgeGroups = wireLinks; circuits.Add(newInfo); } }
public StageLight(CircuitManager manager) : base(manager, 3, 0, false) { color = new Color(); color.red = 255; color.green = 255; color.blue = 255; color.alpha = 255; }
void Start() { cameraManager = GameObject.Find("CameraManager").GetComponent <CameraManager>(); circuitManager = GameObject.Find("CircuitManager").GetComponent <CircuitManager>(); spikePad = GameObject.Find("spike").GetComponent <room4_spikePad>(); curTime = maxTime; circuitManager.InteractUI.SetActive(false); }
public static CircuitManager GetInstance() { if (!instance) { container = new GameObject(); container.name = "CircuitManager"; instance = container.AddComponent(typeof(CircuitManager)) as CircuitManager; } return(instance); }
/// <summary> /// Applied before Sim200msLast runs. /// </summary> internal static void Prefix(CircuitManager __instance, float dt) { float elapsedTime = __instance.elapsedTime; var inst = Instance; if (elapsedTime + dt >= UpdateManager.SecondsPerSimTick && inst != null) { inst.dirty = true; } }
void Start() { circuitManager = GameObject.Find("CircuitManager").GetComponent <CircuitManager>(); rb = GetComponent <Rigidbody>(); Player = gameObject; anim = GetComponent <Animator>(); InteractUI2.SetActive(false); UseGrassStep(); }
public Simulator() { InitializeComponent(); NodeMediator nMediator = new NodeMediator(); NodeFactory nFactory = NodeFactory.Instance; nFactory.setMediator(nMediator); CircuitBuilder nCircuitBuilder = new CircuitBuilder(nFactory); CircuitManager nManager = new CircuitManager(nCircuitBuilder); controller = new CircuitController(nMediator, nManager); }
public void EnergySim200ms(float dt) { KSelectable component = GetComponent <KSelectable>(); if (operational.IsActive) { generator.GenerateJoules(generator.WattageRating * dt, false); component.SetStatusItem(Db.Get().StatusItemCategories.Power, Db.Get().BuildingStatusItems.Wattage, generator); } else { generator.ResetJoules(); component.SetStatusItem(Db.Get().StatusItemCategories.Power, Db.Get().BuildingStatusItems.GeneratorOffline, null); if (operational.IsOperational) { CircuitManager circuitManager = Game.Instance.circuitManager; if (circuitManager != null) { ushort circuitID = circuitManager.GetCircuitID(powerCell); bool flag = circuitManager.HasBatteries(circuitID); bool flag2 = false; if (!flag && circuitManager.HasConsumers(circuitID)) { flag2 = true; } else if (flag) { if (batteryRefillPercent <= 0f && circuitManager.GetMinBatteryPercentFullOnCircuit(circuitID) <= 0f) { flag2 = true; } else if (circuitManager.GetMinBatteryPercentFullOnCircuit(circuitID) < batteryRefillPercent) { flag2 = true; } } if (flag2) { if (chore == null && smi.GetCurrentState() == smi.sm.on) { chore = new WorkChore <ManualGenerator>(Db.Get().ChoreTypes.GeneratePower, this, null, true, null, null, null, true, null, false, true, null, false, true, true, PriorityScreen.PriorityClass.basic, 5, false, true); } } else if (chore != null) { chore.Cancel("No refill needed"); chore = null; } component.ToggleStatusItem(EnergyGenerator.BatteriesSufficientlyFull, !flag2, null); } } } }
/// <summary> /// Fills the transformers with battery charge if necessary, then finishes up the /// update by reporting any wasted energy and checking for overloading. /// </summary> /// <param name="instance">The circuit manager to update.</param> /// <param name="circuitID">The circuit ID to update.</param> /// <param name="used">The wattage used so far by consumers.</param> private static void SupplyTransformers(CircuitManager instance, int circuitID, float used) { var circuits = instance.circuitInfo; var circuit = circuits[circuitID]; var batteries = circuit.batteries; var generators = circuit.generators; var inputTransformers = circuit.inputTransformers; bool hasSources = generators.Count > 0 || circuit.outputTransformers.Count > 0, isUseful = hasSources || circuit.consumers.Count > 0; int nb = batteries.Count, ng = generators.Count; if (nb > 0) { // Batteries were in space-order, need to resort to charge-order batteries.Sort(BatteryChargeComparer.Instance); used += ChargeDrainEvenly(inputTransformers, batteries) / UpdateManager. SecondsPerSimTick; hasSources |= GetMinimumBatteryCharge(ref circuit); UpdateConnectionStatus(instance, circuitID, batteries, isUseful); } else { GetMinimumBatteryCharge(ref circuit); } UpdateConnectionStatus(instance, circuitID, inputTransformers, hasSources); // Report wasted energy for (int i = 0; i < ng; i++) { var generator = generators[i]; if (generator != null && REPORT) { ReportManager.Instance.ReportValue(ReportManager.ReportType.EnergyWasted, -generator.JoulesAvailable, StringFormatter.Replace(STRINGS.BUILDINGS. PREFABS.GENERATOR.OVERPRODUCTION, "{Generator}", generator. GetProperName())); } } circuit.wattsUsed = used; circuits[circuitID] = circuit; // Check for overloading var network = Game.Instance.electricalConduitSystem.GetNetworkByID(circuitID); if (network != null && network is ElectricalUtilityNetwork enet) { enet.UpdateOverloadTime(UpdateManager.SecondsPerSimTick, used, circuit. bridgeGroups); } }
private static bool Prefix(CircuitManager __instance, float dt, int id, float watts_used) { //Debug.Log(" === NoDamageMod_CircuitManager_CheckCircuitOverloaded Prefix === "); if (!NoDamageState.StateManager.State.Enabled) { return(true); } if (NoDamageState.StateManager.State.DisableAllDamage || NoDamageState.StateManager.State.NoCircuitOverload) { return(false); } return(true); }
public void LoadCircuitsFromDatabase(List <DatabaseEntry> locationData, ClimateManager climateManager) { Debug.Assert(this.mCircuits.Count == 0, "Loading from database when content is already loaded; this will work but indicates that the game is loading in a strange unintended way."); this.mCircuits.Clear(); for (int index = 0; index < locationData.Count; ++index) { DatabaseEntry databaseEntry = locationData[index]; Circuit circuit = new Circuit(); this.mCircuits.Add(circuit); circuit.circuitID = databaseEntry.GetIntValue("Circuit ID"); circuit.locationName = databaseEntry.GetStringValue("Location"); circuit.travelCost = (long)((double)databaseEntry.GetFloatValue("Travel Cost") * (double)GameStatsConstants.millionScalar); circuit.locationNameID = databaseEntry.GetStringValue("Location ID"); circuit.nationalityKey = databaseEntry.GetStringValue("Country"); circuit.countryNameID = databaseEntry.GetStringValue("Country ID"); circuit.spriteName = databaseEntry.GetStringValue("Sprite Name"); circuit.trackRubberModifier = databaseEntry.GetFloatValue("Track Rubber Modifier"); circuit.safetyCarFlagProbability = databaseEntry.GetFloatValue("Safety Car Flag Chance"); circuit.virtualSafetyCarProbability = databaseEntry.GetFloatValue("Virtual Safety Car Chance"); circuit.minimapRotation = databaseEntry.GetIntValue("Minimap Rotation"); circuit.minimapAxisX = databaseEntry.GetStringValue("Minimap Axis") == "x"; circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.TopSpeed, databaseEntry.GetFloatValue("TS")); circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.Acceleration, databaseEntry.GetFloatValue("ACC")); circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.Braking, databaseEntry.GetFloatValue("DEC")); circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.HighSpeedCorners, databaseEntry.GetFloatValue("HSC")); circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.MediumSpeedCorners, databaseEntry.GetFloatValue("MSC")); circuit.trackStatsCharacteristics.SetStat(CarStats.StatType.LowSpeedCorners, databaseEntry.GetFloatValue("LSC")); circuit.isInNorthHemisphere = databaseEntry.GetStringValue("Hemisphere") == "North"; circuit.trackLayout = CircuitManager.GetTrackLayoutFromString(databaseEntry.GetStringValue("Track Layout")); circuit.trackLengthMiles = databaseEntry.GetFloatValue("Track Length"); circuit.firstTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("First Tyre Option")); circuit.secondTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("Second Tyre Option")); circuit.thirdTyreOption = (TyreSet.Compound)Enum.Parse(typeof(TyreSet.Compound), databaseEntry.GetStringValue("Third Tyre Option")); circuit.tyreWearRate = (Circuit.Rate)Enum.Parse(typeof(Circuit.Rate), databaseEntry.GetStringValue("Tyre Wear Rate")); circuit.fuelBurnRate = (Circuit.Rate)Enum.Parse(typeof(Circuit.Rate), databaseEntry.GetStringValue("Fuel Burn Rate")); float num1 = 120f; float num2 = 90f; float inMinutes1 = (float)((double)circuit.trackLengthMiles / (double)num1 * 60.0); float inMinutes2 = (float)((double)circuit.trackLengthMiles / (double)num2 * 60.0); circuit.bestPossibleLapTime = GameUtility.MinutesToSeconds(inMinutes1); circuit.worstPossibleLapTime = GameUtility.MinutesToSeconds(inMinutes2); circuit.scene = databaseEntry.GetStringValue("Scene"); circuit.climate = CircuitManager.GetClimateFromString(databaseEntry.GetStringValue("Climate"), climateManager); circuit.driverStats = Game.instance.driverStatsProgressionManager.GetDriverStatsProgression(circuit.locationName); } }
/// <summary> /// Updates the electrical circuits. /// </summary> /// <param name="instance">The circuits to update.</param> private static void Update(CircuitManager instance) { var circuits = instance.circuitInfo; var active = instance.activeGenerators; int n = circuits.Count; var usage = ListPool <float, CircuitManager> .Allocate(); // Running in parallel would be really nice, but unfortunately transformers are // on multiple enet grids at once and are not very threadsafe, and setting // consumer status triggers a bunch of get components and UI updates for (int i = 0; i < n; i++) { var circuit = circuits[i]; var consumers = circuit.consumers; var generators = circuit.generators; var batteries = circuit.batteries; int nb = batteries.Count; float used = 0.0f; // IFF the battery with the most charge has no power, then no batteries do bool hasEnergy = GetActiveGenerators(ref circuit, active) || (nb > 0 && batteries[nb - 1].JoulesAvailable > 0.0f); if (hasEnergy) { used = SupplyConsumers(ref circuit, active); } else if (generators.Count > 0) { SetAllConsumerStatus(consumers, ConnectionStatus.Unpowered); } else { SetAllConsumerStatus(consumers, ConnectionStatus.NotConnected); } usage.Add(used); } // Second pass to charge batteries, maybe using energy from the transformers in // the first pass for (int i = 0; i < n; i++) { var circuit = circuits[i]; usage[i] = usage[i] + SupplyStorage(ref circuit); } for (int i = 0; i < n; i++) { SupplyTransformers(instance, i, usage[i]); } usage.Recycle(); }
/// <summary> /// Updates the list of generators on the circuit. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> private void RefreshGenerators(CircuitManager manager, ushort circuitID) { var text = CACHED_BUILDER; var generators = manager.circuitInfo[circuitID].generators; var target = lastSelected.lastTarget; int n = generators.Count; bool hasGenerator = false; setInactive.UnionWith(generatorLabels); generatorLabels.Clear(); for (int i = 0; i < n; i++) { var generator = generators[i]; if (generator != null && !generator.TryGetComponent(out Battery _)) { var label = AddOrGetLabel(es.labelTemplate, generatorParent, "generator" + i.ToString()); var go = generator.gameObject; var fontStyle = (go == target) ? FontStyles.Bold : FontStyles.Normal; var title = label.text; text.Clear().Append(go.GetProperName()).Append(": "); if (!generator.IsProducingPower()) { FormatStringPatches.GetFormattedWattage(text, 0.0f); text.Append(" / "); } FormatStringPatches.GetFormattedWattage(text, generator.WattageRating); title.fontStyle = fontStyle; title.SetText(text); generatorLabels.Add(label); hasGenerator = true; } } if (!hasGenerator) { var label = AddOrGetLabel(es.labelTemplate, generatorParent, "nogenerators"); label.text.SetText(ENERGYGENERATOR.NOGENERATORS); generatorLabels.Add(label); } setInactive.ExceptWith(generatorLabels); foreach (var label in setInactive) { label.SetActive(false); } setInactive.Clear(); }
/// <summary> /// Applied before Sim200msLast runs. /// </summary> internal static bool Prefix(CircuitManager __instance, float dt) { var infoScreen = UIPatches.EnergyInfoScreenWrapper.Instance; float elapsedTime = __instance.elapsedTime + dt; if (elapsedTime >= UpdateManager.SecondsPerSimTick) { elapsedTime -= UpdateManager.SecondsPerSimTick; Update(__instance); if (infoScreen != null) { infoScreen.dirty = true; } } __instance.elapsedTime = elapsedTime; return(false); }
/// <summary> /// Applied before Refresh runs. /// </summary> internal static bool Prefix(CircuitManager __instance) { var electricalSystem = Game.Instance.electricalConduitSystem; if (electricalSystem != null) { bool rebuild = electricalSystem.IsDirty; if (rebuild) { electricalSystem.Update(); } if (rebuild || __instance.dirty) { InitNetworks(__instance, electricalSystem); Rebuild(__instance); } } return(false); }
protected override bool OnWorkTick(Worker worker, float dt) { CircuitManager circuitManager = Game.Instance.circuitManager; bool flag = false; if (circuitManager != null) { ushort circuitID = circuitManager.GetCircuitID(powerCell); bool flag2 = circuitManager.HasBatteries(circuitID); flag = ((flag2 && circuitManager.GetMinBatteryPercentFullOnCircuit(circuitID) < 1f) || (!flag2 && circuitManager.HasConsumers(circuitID))); } AttributeLevels component = worker.GetComponent <AttributeLevels>(); if ((Object)component != (Object)null) { component.AddExperience(Db.Get().Attributes.Athletics.Id, dt, DUPLICANTSTATS.ATTRIBUTE_LEVELING.ALL_DAY_EXPERIENCE); } return(!flag); }
public override void OnInspectorGUI() { //Called whenever the inspector is drawn for this object. DrawDefaultInspector(); CircuitManager circuitManager = (CircuitManager)FindObjectOfType(typeof(CircuitManager)); if (GUILayout.Button("Update Road")) { if (circuitManager.circuitMesh != null) { circuitManager.updatePath(circuitManager.circuitMesh); Debug.Log("road Update"); } else { Debug.LogError("circuitMesh required"); } } }
public static bool Prefix(Wire __instance, ref StatusItem ___WireCircuitStatus, ref StatusItem ___WireMaxWattageStatus) { if (___WireCircuitStatus == null) { ___WireCircuitStatus = new StatusItem("WireCircuitStatus", "BUILDING", string.Empty, StatusItem.IconType.Info, NotificationType.Neutral, false, OverlayModes.None.ID).SetResolveStringCallback(delegate(string str, object data) { Wire wire2 = (Wire)data; int cell2 = Grid.PosToCell(wire2.transform.GetPosition()); CircuitManager circuitManager2 = Game.Instance.circuitManager; ushort circuitID2 = circuitManager2.GetCircuitID(cell2); float wattsUsedByCircuit = circuitManager2.GetWattsUsedByCircuit(circuitID2); GameUtil.WattageFormatterUnit unit2 = wire2.MaxWattageRating.GetFormatterUnit(); float maxWattageAsFloat2 = Wire.GetMaxWattageAsFloat(wire2.MaxWattageRating); float wattsNeededWhenActive2 = circuitManager2.GetWattsNeededWhenActive(circuitID2); string wireLoadColor = GameUtil.GetWireLoadColor(wattsUsedByCircuit, maxWattageAsFloat2, wattsNeededWhenActive2); str = str.Replace("{CurrentLoadAndColor}", (wireLoadColor == Color.white.ToHexString()) ? GameUtil.GetFormattedWattage(wattsUsedByCircuit, unit2) : ("<color=#" + wireLoadColor + ">" + GameUtil.GetFormattedWattage(wattsUsedByCircuit, unit2) + "</color>")); str = str.Replace("{MaxLoad}", GameUtil.GetFormattedWattage(maxWattageAsFloat2, unit2)); str = str.Replace("{WireType}", __instance.GetProperName()); return(str); }); } if (___WireMaxWattageStatus == null) { ___WireMaxWattageStatus = new StatusItem("WireMaxWattageStatus", "BUILDING", string.Empty, StatusItem.IconType.Info, NotificationType.Neutral, false, OverlayModes.None.ID).SetResolveStringCallback(delegate(string str, object data) { Wire wire = (Wire)data; GameUtil.WattageFormatterUnit unit = wire.MaxWattageRating.GetFormatterUnit(); int cell = Grid.PosToCell(wire.transform.GetPosition()); CircuitManager circuitManager = Game.Instance.circuitManager; ushort circuitID = circuitManager.GetCircuitID(cell); float wattsNeededWhenActive = circuitManager.GetWattsNeededWhenActive(circuitID); float maxWattageAsFloat = Wire.GetMaxWattageAsFloat(wire.MaxWattageRating); str = str.Replace("{TotalPotentialLoadAndColor}", (wattsNeededWhenActive > maxWattageAsFloat) ? ("<color=#" + new Color(251f / 255f, 176f / 255f, 59f / 255f).ToHexString() + ">" + GameUtil.GetFormattedWattage(wattsNeededWhenActive, unit) + "</color>") : GameUtil.GetFormattedWattage(wattsNeededWhenActive, unit)); str = str.Replace("{MaxLoad}", GameUtil.GetFormattedWattage(maxWattageAsFloat, unit)); return(str); }); } return(true); }
public CircuitManager() { Instance = this; try { var uri = new Uri("pack://application:,,,/Assets/Locations.txt"); System.Windows.Resources.StreamResourceInfo resourceStream = Application.GetResourceStream(uri); using (var reader = new StreamReader(resourceStream.Stream)) { string traitsText = reader.ReadToEnd(); List <DatabaseEntry> result = DatabaseReader.LoadFromText(traitsText); LoadCircuitsFromDatabase(result, ClimateManager.Instance); } } catch (Exception e) { Console.WriteLine(e); //throw; } }
/// <summary> /// Updates the circuit summary information. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> private void RefreshSummary(CircuitManager manager, ushort circuitID) { var text = CACHED_BUILDER; // Available text.Clear().Append(ENERGYGENERATOR.AVAILABLE_JOULES).Replace("{0}", GameUtil. GetFormattedJoules(manager.GetJoulesAvailableOnCircuit(circuitID))); joulesAvailable.text.SetText(text); // Generated float generated = GetWattageGenerated(manager, circuitID, out float potential); text.Clear(); if (Mathf.Approximately(generated, potential)) { FormatStringPatches.GetFormattedWattage(text, generated); } else { FormatStringPatches.GetFormattedWattage(text, generated); text.Append(" / "); FormatStringPatches.GetFormattedWattage(text, potential); } string ratio = text.ToString(); text.Clear().Append(ENERGYGENERATOR.WATTAGE_GENERATED).Replace("{0}", ratio); wattageGenerated.text.SetText(text); // Consumed text.Clear().Append(ENERGYGENERATOR.WATTAGE_CONSUMED).Replace("{0}", GameUtil.GetFormattedWattage(manager.GetWattsUsedByCircuit(circuitID))); wattageConsumed.text.SetText(text); // Max consumed text.Clear().Append(ENERGYGENERATOR.POTENTIAL_WATTAGE_CONSUMED).Replace("{0}", GameUtil.GetFormattedWattage(GetWattsNeededWhenActive(manager, circuitID))); potentialWattageConsumed.text.SetText(text); // Max safe text.Clear().Append(ENERGYGENERATOR.MAX_SAFE_WATTAGE).Replace("{0}", GameUtil.GetFormattedWattage(manager.GetMaxSafeWattageForCircuit(circuitID))); maxSafeWattage.text.SetText(text); }
/// <summary> /// Updates the list of batteries on the circuit. /// </summary> /// <param name="manager">The circuit manager to query.</param> /// <param name="circuitID">The circuit to look up.</param> private void RefreshBatteries(CircuitManager manager, ushort circuitID) { var text = CACHED_BUILDER; var batteries = manager.circuitInfo[circuitID].batteries; var target = lastSelected.lastTarget; int n = batteries.Count; setInactive.UnionWith(batteryLabels); batteryLabels.Clear(); for (int i = 0; i < n; i++) { var battery = batteries[i]; if (battery != null) { var label = AddOrGetLabel(es.labelTemplate, batteryParent, "battery" + i.ToString()); var go = battery.gameObject; var fontStyle = (go == target) ? FontStyles.Bold : FontStyles.Normal; var title = label.text; text.Clear().Append(go.GetProperName()).Append(": ").Append(GameUtil. GetFormattedJoules(battery.JoulesAvailable)); title.fontStyle = fontStyle; title.SetText(text); batteryLabels.Add(label); } } if (n <= 0) { var label = AddOrGetLabel(es.labelTemplate, batteryParent, "nobatteries"); label.text.SetText(ENERGYGENERATOR.NOBATTERIES); batteryLabels.Add(label); } setInactive.ExceptWith(batteryLabels); foreach (var label in setInactive) { label.SetActive(false); } setInactive.Clear(); }
/// <summary> /// Updates the plugged in status of batteries or transformers. /// </summary> /// <param name="instance">The circuit manager to update.</param> /// <param name="batteries">The batteries or transformers to update.</param> /// <param name="hasSources">Whether the batteries have a potential energy source.</param> private static void UpdateConnectionStatus(CircuitManager instance, int circuitID, IList <Battery> batteries, bool hasSources) { int ni = batteries.Count; for (int i = 0; i < ni; i++) { var battery = batteries[i]; if (battery != null) { if (battery.powerTransformer == null) { battery.SetConnectionStatus(hasSources ? ConnectionStatus.Powered : ConnectionStatus.NotConnected); } else if (instance.GetCircuitID(battery) == circuitID) { battery.SetConnectionStatus(hasSources ? ConnectionStatus.Powered : ConnectionStatus.Unpowered); } } } }
private void OnTriggerStay(Collider other) { Line = other.gameObject.GetComponentInParent <LineManager>(); Circuit = FindObjectOfType <CircuitManager>(); //전력의 값을 바꾼다. if (other.tag == "Line" && Line.ConnectSuccese == 1) { plusElectro = 1; Electro = 3.0f; Line.Electro = Electro; Circuit.ConnectElectro = Electro; Around.SetActive(false); } if (other.tag == "Line" && Line.ConnectSuccese == 0) { plusElectro = 0; Electro = 0; Line.Electro = Electro; Circuit.ConnectElectro = Electro; Around.SetActive(true); } }
void Start() { circuitManager = GameObject.Find("CircuitManager").GetComponent <CircuitManager>(); gameManager = GameObject.Find("GameManager").GetComponent <GameManager>(); }
private void Start() { circuitManager = GameObject.Find("CircuitManager").GetComponent <CircuitManager>(); circuitManager.InteractUI.SetActive(false); }
private float currentMaxAcceleration = 0; // cm/(s^2) public Piston(CircuitManager manager) : base(manager, 3) { }