/// <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)
{
}
