public void PowerNetworkUpdate(float Voltage) //Could be optimised to not update when voltage is same as previous voltage
{
if (Powered != null)
{
if (AdvancedControlToScript)
{
Powered.PowerNetworkUpdate(Voltage);
}
else
{
if (Voltage <= 1)
{
State = PowerStates.Off;
}
else if (Voltage > MaximumWorkingVoltage)
{
State = PowerStates.OverVoltage;
}
else if (Voltage < MinimumWorkingVoltage)
{
State = PowerStates.LowVoltage;
}
else
{
State = PowerStates.On;
}
Powered.StateUpdate(State);
}
}
}
public override void PowerStateUpdate(PowerStates state)
{
if (state == PowerStates.On || state == PowerStates.OverVoltage)
{
processor.SetState(new ProcessorIdle(processor));
}
}
public override void PowerStateUpdate(PowerStates state)
{
if (state == PowerStates.On || state == PowerStates.OverVoltage)
{
microwave.SetState(new MicrowaveOpen(microwave));
}
}
public void StateUpdate(PowerStates State)
{
if (!isServer)
{
return;
}
switch (State)
{
case PowerStates.On:
ServerChangeState(true, invokeEvent: false);
powerState = State;
break;
case PowerStates.LowVoltage:
ServerChangeState(false, invokeEvent: false);
powerState = State;
break;
case PowerStates.OverVoltage:
ServerChangeState(true, invokeEvent: false);
powerState = State;
break;
default:
ServerChangeState(false, invokeEvent: false);
powerState = State;
break;
}
}
public override void PowerStateUpdate(PowerStates state)
{
if (state == PowerStates.Off || state == PowerStates.LowVoltage)
{
microwave.SetState(new MicrowaveUnpowered(microwave));
}
}
public void StateUpdate(PowerStates newPowerState)
{
if (!isServer)
{
return;
}
powerState = newPowerState;
if (mState == LightMountState.Broken ||
mState == LightMountState.MissingBulb)
{
return;
}
switch (newPowerState)
{
case PowerStates.On:
ServerChangeLightState(LightMountState.On);
return;
case PowerStates.LowVoltage:
ServerChangeLightState(LightMountState.Emergency);
return;
case PowerStates.OverVoltage:
ServerChangeLightState(LightMountState.BurnedOut);
return;
case PowerStates.Off:
ServerChangeLightState(LightMountState.Emergency);
return;
}
}
public void StateUpdate(PowerStates State)
{
CurrentState = State;
if (spriteHandler == null)
{
spriteHandler = GetComponentInChildren <SpriteHandler>();
}
if (APCConnectionHandler == null)
{
APCConnectionHandler = GetComponentInChildren <APCPoweredDevice>();
}
// For a future iteration, allow the jukebox to be connected to the power grid.
/*
* if (State <= PowerStates.On)
* {
* Stop();
* TabUpdateMessage.SendToPeepers(gameObject, NetTabType.Jukebox, TabAction.Close);
* }
*/
// StateUpdate might happen before start
if (IsPlaying)
{
APCConnectionHandler.Wattusage = InUseWattUsage;
}
else
{
APCConnectionHandler.Wattusage = StandByWattUsage;
}
}
public override void PowerStateUpdate(PowerStates state)
{
if (state == PowerStates.Off || state == PowerStates.LowVoltage)
{
processor.SetState(new ProcessorUnpowered(processor));
processor.EjectContents();
}
}
public void SetPowerState(PowerStates state)
{
PowerState exitingState = powerState;
powerState = powerStates[state];
exitingState?.OnStateExit(powerState);
powerState?.OnStateEnter(exitingState);
}
public void UpdateSynchronisedState(PowerStates _State)
{
State = _State;
if (Powered != null)
{
Powered.StateUpdate(State);
}
}
public void StateUpdate(PowerStates State)
{
if (State == PowerStates.Off || State == PowerStates.LowVoltage)
{
SetPowered(false);
}
else
{
SetPowered(true);
}
}
public void StateUpdate(PowerStates State)
{
if (State == PowerStates.Off || State == PowerStates.LowVoltage)
{
isOn = false;
}
else
{
isOn = true;
}
}
public void StateUpdate(PowerStates State)
{
if (State == PowerStates.Off || State == PowerStates.LowVoltage)
{
ToggleOn(false);
}
else
{
ToggleOn(true);
}
}
/// <summary>
/// Part of interface IAPCPowered. Sets the processor's state according to the given power state.
/// </summary>
/// <param name="state">The power state to set the processor's state with.</param>
public void StateUpdate(PowerStates state)
{
EnsureInit(); // This method could be called before the component's Awake().
if (isServer) // Since state changes affect animations (and call an Rpc animation function), only server can do this.
{
if (currentState == null)
{
SetState(new ProcessorUnpowered(this));
}
currentState.PowerStateUpdate(state);
}
}
private void UpdateSynchronisedState(PowerStates _State)
{
if (_State != State)
{
Logger.LogTraceFormat("{0}({1}) state changing {2} to {3}", Category.Electrical, name, transform.position.To2Int(), State, _State);
}
State = _State;
if (Powered != null)
{
Powered.StateUpdate(State);
}
}
public void StateUpdate(PowerStates State)
{
if (State == PowerStates.Off || State == PowerStates.LowVoltage)
{
SyncPowered(powered, false);
}
else
{
SyncPowered(powered, true);
}
if (!powerInit)
{
powerInit = true;
}
}
public void StateUpdate(PowerStates State)
{
if (CurrentState != State)
{
CurrentState = State;
if (State == PowerStates.Off)
{
PoweredDevice.Wattusage = OffWatts;
SetPowerOff();
}
else
{
PoweredDevice.Wattusage = OnWatts;
SetOnline();
}
}
}
public void StateUpdate(PowerStates State)
{
RelatedAPC = GetComponent <APCPoweredDevice>().RelatedAPC;
if (State == PowerStates.Off || State == PowerStates.LowVoltage)
{
SyncPowered(powered, false);
}
else
{
SyncPowered(powered, true);
}
if (!powerInit)
{
powerInit = true;
}
}
public void ApplyPowerUp(PowerStates powerState, float modifier, float duration)
{
PlayerMovement control = GetComponent<PlayerMovement>();
m_PowerStateTimers[powerState] = duration;
switch (powerState)
{
case PowerStates.SuperSpeed:
control._fMoveSpeed = Mathf.Max(control._fMoveSpeed, m_MovementSpeed * modifier);
break;
case PowerStates.Invulnerability:
m_IsInvulnerable = true;
GetComponentInChildren<Shield>().GetComponent<SpriteRenderer>().enabled = true;
break;
default:
break;
}
}
private void PowerDown()
{
if (_powerState != PowerStates.powerOffline)
{
if (powerDownFraction <= 0)
{
_powerState = PowerStates.powerOffline;
}
else
{
powerDownFraction -= 0.01;
}
PartResource megajouleResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_MEGAJOULES);
if (megajouleResource != null)
{
megajouleResource.maxAmount = Math.Max(0.001, megajouleResource.maxAmount * powerDownFraction);
megajouleResource.amount = Math.Min(megajouleResource.maxAmount, megajouleResource.amount);
}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = Math.Max(0.001, electricChargeResource.maxAmount * powerDownFraction);
electricChargeResource.amount = Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
else
{
PartResource megajouleResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_MEGAJOULES);
if (megajouleResource != null)
{
megajouleResource.maxAmount = 0.001;
megajouleResource.amount = 0;
}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = 0.001;
electricChargeResource.amount = 0;
}
}
}
private bool newState; // Used to skip setup after first time set in states. ONLY USED IN ExecuteGameState!
void Awake()
{
Debug.Log("GameController Awake()");
Debug.logger.logEnabled = true;
mS = MainStates.Election;
eS = ElectionStates.PassPresident;
lS = LegislationStates.None;
pS = PowerStates.None;
statePanelScript = statePanel.GetComponent <StatePanelScript> ();
confirmButtonScript = confirmButton.GetComponent <ButtonScript> ();
jaButtonScript = jaButton.GetComponent <ButtonScript> ();
neinButtonScript = neinButton.GetComponent <ButtonScript> ();
failCountScript = FailCounter.GetComponent <FailCountScript> ();
tileController = new TileController(6, 11);
drawCount.text = tileController.GetDrawCount().ToString();
discardCount.text = tileController.GetDiscardCount().ToString();
gameStateObjectScript = gameStateObject.GetComponent <GameStateObjectScript> ();
newState = true;
}
private void UpdateSynchronisedState(PowerStates _OldState, PowerStates _State)
{
EnsureInit();
if (_State != State)
{
Logger.LogTraceFormat("{0}({1}) state changing {2} to {3}", Category.Electrical, name, transform.position.To2Int(), State, _State);
}
State = _State;
if (Powered != null && StateUpdateOnClient)
{
if (SelfPowered)
{
Powered.StateUpdate(PowerStates.On);
}
else
{
Powered.StateUpdate(State);
}
}
}
private void PowerDown()
{
if (_powerState != PowerStates.powerOffline)
{
if (powerDownFraction <= 0)
{
_powerState = PowerStates.powerOffline;
}
else
{
powerDownFraction -= 0.01;
}
if (megajouleResource != null)
{
megajouleResource.maxAmount = Math.Max(0.0001, megajouleResource.maxAmount * powerDownFraction);
megajouleResource.amount = Math.Min(megajouleResource.maxAmount, megajouleResource.amount);
}
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = Math.Max(0.0001, electricChargeResource.maxAmount * powerDownFraction);
electricChargeResource.amount = Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
else
{
if (megajouleResource != null)
{
megajouleResource.maxAmount = 0.0001;
megajouleResource.amount = 0;
}
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = 0.0001;
electricChargeResource.amount = 0;
}
}
}
private void UpdateMegaWattPowerBuffer()
{
if (maxStableMegaWattPower != _previousMaxStableMegaWattPower)
{
_powerState = PowerStates.powerChange;
}
_previousMaxStableMegaWattPower = maxStableMegaWattPower;
if (maxStableMegaWattPower > 0 && (TimeWarp.fixedDeltaTime != previousDeltaTime || _powerState != PowerStates.powerOnline))
{
_powerState = PowerStates.powerOnline;
var megaWattBufferingBonus = attachedPowerSource.PowerBufferBonus * maxStableMegaWattPower;
requiredMegawattCapacity = Math.Max(0.0001, TimeWarp.fixedDeltaTime * maxStableMegaWattPower + megaWattBufferingBonus);
var previousMegawattCapacity = Math.Max(0.0001, previousDeltaTime * maxStableMegaWattPower + megaWattBufferingBonus);
if (megajouleResource != null)
{
var mageJouleRatio = megajouleResource.amount / megajouleResource.maxAmount;
megajouleResource.maxAmount = requiredMegawattCapacity;
megajouleResource.amount = requiredMegawattCapacity > previousMegawattCapacity
? Math.Max(0, Math.Min(requiredMegawattCapacity, megajouleResource.amount + requiredMegawattCapacity - previousMegawattCapacity))
: Math.Max(0, Math.Min(requiredMegawattCapacity, mageJouleRatio * requiredMegawattCapacity));
}
if (part.Resources.Contains(FNResourceManager.STOCK_RESOURCE_ELECTRICCHARGE))
{
PartResource electricChargeResource = part.Resources[FNResourceManager.STOCK_RESOURCE_ELECTRICCHARGE];
var electricChargeRatio = electricChargeResource.amount / electricChargeResource.maxAmount;
electricChargeResource.maxAmount = requiredMegawattCapacity;
electricChargeResource.amount = requiredMegawattCapacity > previousMegawattCapacity
? Math.Max(0, Math.Min(requiredMegawattCapacity, electricChargeResource.amount + requiredMegawattCapacity - previousMegawattCapacity))
: Math.Max(0, Math.Min(requiredMegawattCapacity, electricChargeRatio * requiredMegawattCapacity));
}
}
previousDeltaTime = TimeWarp.fixedDeltaTime;
}
public void StateUpdate(PowerStates State)
{
CurrentState = State;
if (spriteRenderer == null)
{
spriteRenderer = GetComponentInChildren <SpriteRenderer>();
}
if (APCConnectionHandler == null)
{
APCConnectionHandler = GetComponentInChildren <APCPoweredDevice>();
}
if (spriteRenderer.sprite == SPRITE_ON)
{
APCConnectionHandler.Wattusage = InUseWattUsage;
}
else
{
APCConnectionHandler.Wattusage = StandByWattUsage;
}
}
private void UpdateMegaWattPowerBuffer(double maxStableMegaWattPower)
{
if (maxStableMegaWattPower != _previousMaxStableMegaWattPower)
{
_powerState = PowerStates.powerChange;
}
_previousMaxStableMegaWattPower = maxStableMegaWattPower;
if (maxStableMegaWattPower > 0 && (TimeWarp.fixedDeltaTime != previousTimeWarp || _powerState != PowerStates.powerOnline))
{
_powerState = PowerStates.powerOnline;
var powerBufferingBonus = attachedThermalSource.PowerBufferBonus * maxStableMegaWattPower;
requiredMegawattCapacity = (float)Math.Max(0.0001, TimeWarp.fixedDeltaTime * maxStableMegaWattPower + powerBufferingBonus);
var previousMegawattCapacity = Math.Max(0.0001f, previousTimeWarp * maxStableMegaWattPower + powerBufferingBonus);
if (megajouleResource != null)
{
megajouleResource.maxAmount = requiredMegawattCapacity;
if (maxStableMegaWattPower > 0.1)
{
megajouleResource.amount = requiredMegawattCapacity > previousMegawattCapacity
? Math.Max(0, Math.Min(requiredMegawattCapacity, megajouleResource.amount + requiredMegawattCapacity - previousMegawattCapacity))
: Math.Max(0, Math.Min(requiredMegawattCapacity, (megajouleResource.amount / megajouleResource.maxAmount) * requiredMegawattCapacity));
}
}
if (part.Resources.Contains(FNResourceManager.STOCK_RESOURCE_ELECTRICCHARGE))
{
PartResource electricChargeResource = part.Resources[FNResourceManager.STOCK_RESOURCE_ELECTRICCHARGE];
electricChargeResource.maxAmount = requiredMegawattCapacity;
electricChargeResource.amount = maxStableMegaWattPower <= 0 ? 0 : Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
previousTimeWarp = TimeWarp.fixedDeltaTime;
}
private void UpdateMegaWattPowerBuffer(double maxStableMegaWattPower)
{
if (maxStableMegaWattPower != _previousMaxStableMegaWattPower)
{
_powerState = PowerStates.powerChange;
}
_previousMaxStableMegaWattPower = maxStableMegaWattPower;
if (maxStableMegaWattPower > 0 && (TimeWarp.fixedDeltaTime != previousTimeWarp || _powerState != PowerStates.powerOnline))
{
_powerState = PowerStates.powerOnline;
var powerBufferingBonus = attachedThermalSource.PowerBufferBonus * maxStableMegaWattPower;
requiredMegawattCapacity = (float)Math.Max(0.0001, TimeWarp.fixedDeltaTime * maxStableMegaWattPower + powerBufferingBonus);
var previousMegawattCapacity = Math.Max(0.0001f, previousTimeWarp * maxStableMegaWattPower + powerBufferingBonus);
if (megajouleResource != null)
{
megajouleResource.maxAmount = requiredMegawattCapacity;
if (maxStableMegaWattPower > 0.1)
{
megajouleResource.amount = requiredMegawattCapacity > previousMegawattCapacity
? Math.Max(0, Math.Min(requiredMegawattCapacity, megajouleResource.amount + requiredMegawattCapacity - previousMegawattCapacity))
: Math.Max(0, Math.Min(requiredMegawattCapacity, (megajouleResource.amount / megajouleResource.maxAmount) * requiredMegawattCapacity));
}
}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = requiredMegawattCapacity;
electricChargeResource.amount = maxStableMegaWattPower <= 0 ? 0 : Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
previousTimeWarp = TimeWarp.fixedDeltaTime;
}
public void StateUpdate(PowerStates State)
{
switch (State)
{
case PowerStates.On:
Trigger(true);
return;
case PowerStates.LowVoltage:
ServerChangeLightState(LightState.Emergency);
wallMount.SwitchChangeState(false);
return;
case PowerStates.OverVoltage:
Trigger(true);
return;
case PowerStates.Off:
ServerChangeLightState(LightState.Emergency);
wallMount.SwitchChangeState(false);
return;
}
}
/// <summary>
/// Triggers on device power state change
/// </summary>
/// <param name="newState">New state</param>
void IAPCPowered.StateUpdate(PowerStates newState)
{
//Ignore if state hasn't changed
if (newState == currentState)
{
return;
}
//Show processing state change
if (foodToBeProcessed?.Count > 0)
{
//Any state other than off
if (currentState == PowerStates.Off)
{
Chat.AddLocalMsgToChat("The seed extractor begins processing", (Vector2Int)registerObject.WorldPosition, this.gameObject);
}
//Off state
else if (newState == PowerStates.Off)
{
Chat.AddLocalMsgToChat("The seed extractor shuts down!", (Vector2Int)registerObject.WorldPosition, this.gameObject);
}
}
currentState = newState;
}
public void GetStatus()
{
if (root_device != null)
{
//searching sub devices for a power switching service
SubDevice.Service power_switch = root_device.GetServiceByType("urn:schemas-upnp-org:service:SwitchPower:1");
if (power_switch != null)
{
Console.WriteLine("Found the power switch service.");
Console.WriteLine("service control url: " + url_base + power_switch.ControlUrl);
Console.WriteLine("service type: [" + power_switch.ServiceType + "]");
string soap_method = "GetStatus";
string soap_body = "<?xml version=\"1.0\"?>\r\n";
soap_body += "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n";
soap_body += "<s:Body>\r\n";
soap_body += "<m:" + soap_method + " xmlns:m=\"" + power_switch.ServiceType + "\">\r\n";
soap_body += "</m:" + soap_method + ">\r\n";
soap_body += "</s:Body>\r\n";
soap_body += "</s:Envelope>\r\n";
string soap_action = power_switch.ServiceType + "#" + soap_method;
SOAP soap = new SOAP(url_base + power_switch.ControlUrl, soap_body, soap_action);
soap.RequestFinished += delegate(SOAP request_finished_soap, bool request_successful)
{
bool successful = false;
if (request_successful)
{
//TODO ===||
// \/
//XmlNamespaceManager nsMgr = new XmlNamespaceManager(myXmlDoc.NameTable);
//nsMgr.AddNamespace("s", "http://schemas.xmlsoap.org/soap/envelope/");
//nsMgr.AddNamespace("m", power_switch.ServiceType);
//XmlNode urlNodes = doc.SelectNodes("/s:Body/s:m");
//Console.WriteLine("Soap Response: \n" + request_finished_soap.Response);
string[] seps = { "\r\n" };
string[] lines = request_finished_soap.Response.Split(seps, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length > 0)
{
if (lines[0] == "HTTP/1.1 200 OK")
{
if (request_finished_soap.Response.IndexOf(soap_method + "Response") != -1)
{
int stats_start = request_finished_soap.Response.IndexOf("<ResultStatus>");
if (stats_start != -1)
{
string status_string = request_finished_soap.Response.Substring(stats_start + "<ResultStatus>".Length);
int status_end = status_string.IndexOf("</ResultStatus>");
if (status_end != -1)
{
status_string = status_string.Substring(0, status_end);
if (status_string == "1")
status = PowerStates.On;
else status = PowerStates.Off;
successful = true;
}
}
}
}
}
}
else Console.WriteLine("Soap Request failed.");
if (GettingStatusCompleted != null)
GettingStatusCompleted(this, successful);
};
soap.StartRequest();
}
}
}
public void SwitchPower(PowerStates state)
{
if (root_device != null)
{
//searching sub devices for power switching service
SubDevice.Service power_switch = root_device.GetServiceByType("urn:schemas-upnp-org:service:SwitchPower:1");
if (power_switch != null)
{
Console.WriteLine("Found the power switch service.");
Console.WriteLine("service control url: " + url_base + power_switch.ControlUrl);
Console.WriteLine("service type: [" + power_switch.ServiceType + "]");
string soap_method = "SetTarget";
string soap_body = "<?xml version=\"1.0\"?>\r\n";
soap_body += "<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n";
soap_body += "<s:Body>\r\n";
soap_body += "<m:" + soap_method + " xmlns:m=\"" + power_switch.ServiceType + "\">\r\n";
if (state == PowerStates.On)
soap_body += "<newTargetValue>1</newTargetValue>";
else soap_body += "<newTargetValue>0</newTargetValue>";
soap_body += "</m:" + soap_method + ">\r\n";
soap_body += "</s:Body>\r\n";
soap_body += "</s:Envelope>\r\n";
string soap_action = power_switch.ServiceType + "#" + soap_method;
SOAP soap = new SOAP(url_base + power_switch.ControlUrl, soap_body, soap_action);
soap.RequestFinished += delegate(SOAP request_finished_soap, bool request_successful)
{
bool successful = false;
if (request_successful)
{
//Console.WriteLine("Soap Response: \n" + request_finished_soap.Response);
string[] seps = { "\r\n" };
string[] lines = request_finished_soap.Response.Split(seps, StringSplitOptions.RemoveEmptyEntries);
if (lines.Length > 0)
{
if (lines[0] == "HTTP/1.1 200 OK")
{
if (request_finished_soap.Response.IndexOf(soap_method + "Response") != -1)
{
successful = true;
status = state;
}
}
}
}
else Console.WriteLine("Soap Request failed.");
if (SwitchingPowerCompleted != null)
SwitchingPowerCompleted(this, successful);
};
soap.StartRequest();
}
}
}
public void StateUpdate(PowerStates State)
{
}
private void PowerDown()
{
if (_powerState != PowerStates.powerOffline)
{
if (powerDownFraction <= 0)
_powerState = PowerStates.powerOffline;
else
powerDownFraction -= 0.01;
PartResource megajouleResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_MEGAJOULES);
if (megajouleResource != null)
{
megajouleResource.maxAmount = Math.Max(0.001, megajouleResource.maxAmount * powerDownFraction);
megajouleResource.amount = Math.Min(megajouleResource.maxAmount, megajouleResource.amount);
}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = Math.Max(0.001, electricChargeResource.maxAmount * powerDownFraction);
electricChargeResource.amount = Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
else
{
PartResource megajouleResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_MEGAJOULES);
if (megajouleResource != null)
{
megajouleResource.maxAmount = 0.001;
megajouleResource.amount = 0;
}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
electricChargeResource.maxAmount = 0.001;
electricChargeResource.amount = 0;
}
}
}
public override void OnFixedUpdate()
{
base.OnFixedUpdate();
if (IsEnabled && myAttachedReactor != null && FNRadiator.hasRadiatorsForVessel(vessel))
{
updateGeneratorPower();
// check if MaxStableMegaWattPower is changed
var maxStableMegaWattPower = MaxStableMegaWattPower;
if (maxStableMegaWattPower != _previousMaxStableMegaWattPower)
_powerState = PowerStates.powerChange;
_previousMaxStableMegaWattPower = maxStableMegaWattPower;
if (maxStableMegaWattPower > 0 && (TimeWarp.fixedDeltaTime != previousTimeWarp || _powerState != PowerStates.powerOnline))
{
_powerState = PowerStates.powerOnline;
var powerBufferingBonus = myAttachedReactor.PowerBufferBonus * maxStableMegaWattPower;
var requiredMegawattCapacity = Math.Max(0.0001, TimeWarp.fixedDeltaTime * maxStableMegaWattPower + powerBufferingBonus);
var previousMegawattCapacity = Math.Max(0.0001, previousTimeWarp * maxStableMegaWattPower + powerBufferingBonus);
if (megajouleResource != null)
{
megajouleResource.maxAmount = requiredMegawattCapacity;
if (maxStableMegaWattPower > 0.1)
{
megajouleResource.amount = requiredMegawattCapacity > previousMegawattCapacity
? Math.Max(0, Math.Min(requiredMegawattCapacity, megajouleResource.amount + requiredMegawattCapacity - previousMegawattCapacity))
: Math.Max(0, Math.Min(requiredMegawattCapacity, (megajouleResource.amount / megajouleResource.maxAmount) * requiredMegawattCapacity));
}
}
//PartResource wasteheatResource = part.Resources.list.FirstOrDefault(r => r.resourceName == FNResourceManager.FNRESOURCE_WASTEHEAT);
//if (wasteheatResource != null)
//{
// var previousMaxAmount = wasteheatResource.maxAmount;
// wasteheatResource.maxAmount = TimeWarp.fixedDeltaTime * part.mass * 1000;
// this.part.RequestResource(FNResourceManager.FNRESOURCE_WASTEHEAT, previousTimeWarp > TimeWarp.fixedDeltaTime ? previousMaxAmount - wasteheatResource.maxAmount : 0);
//}
PartResource electricChargeResource = part.Resources.list.FirstOrDefault(r => r.resourceName == "ElectricCharge");
if (electricChargeResource != null)
{
//if (maxStableMegaWattPower <= 0)
electricChargeResource.maxAmount = requiredMegawattCapacity;
electricChargeResource.amount = maxStableMegaWattPower <= 0 ? 0 : Math.Min(electricChargeResource.maxAmount, electricChargeResource.amount);
}
}
previousTimeWarp = TimeWarp.fixedDeltaTime;
// don't produce any power when our reactor has stopped
if (maxStableMegaWattPower <= 0)
{
PowerDown();
return;
}
else
powerDownFraction = 1;
double electrical_power_currently_needed;
if (myAttachedReactor.ShouldApplyBalance(chargedParticleMode ? ElectricGeneratorType.charged_particle : ElectricGeneratorType.thermal))
{
var chargedPowerPerformance = myAttachedReactor.EfficencyConnectedChargedEnergyGenrator * myAttachedReactor.ChargedPowerRatio;
var thermalPowerPerformance = myAttachedReactor.EfficencyConnectedThermalEnergyGenrator * (1 - myAttachedReactor.ChargedPowerRatio);
var totalPerformance = chargedPowerPerformance + thermalPowerPerformance;
var balancePerformanceRatio = (chargedParticleMode ? chargedPowerPerformance / totalPerformance : thermalPowerPerformance / totalPerformance);
electrical_power_currently_needed = (getCurrentUnfilledResourceDemand(FNResourceManager.FNRESOURCE_MEGAJOULES) + getSpareResourceCapacity(FNResourceManager.FNRESOURCE_MEGAJOULES)) * balancePerformanceRatio;
}
else
electrical_power_currently_needed = getCurrentUnfilledResourceDemand(FNResourceManager.FNRESOURCE_MEGAJOULES) + getSpareResourceCapacity(FNResourceManager.FNRESOURCE_MEGAJOULES);
double electricdt = 0;
double electricdtps = 0;
double max_electricdtps = 0;
if (!chargedParticleMode) // thermal mode
{
double carnotEff = 1.0 - coldBathTemp / hotBathTemp;
_totalEff = carnotEff * pCarnotEff * myAttachedReactor.ThermalEnergyEfficiency;
myAttachedReactor.NotifyActiveThermalEnergyGenrator(_totalEff, ElectricGeneratorType.thermal);
if (_totalEff <= 0 || coldBathTemp <= 0 || hotBathTemp <= 0 || maxThermalPower <= 0) return;
double thermal_power_currently_needed = electrical_power_currently_needed / _totalEff; // _totalEff;
double thermal_power_requested = Math.Max(Math.Min(maxThermalPower, thermal_power_currently_needed) * TimeWarp.fixedDeltaTime, 0.0);
requestedPower_f = (float)thermal_power_requested / TimeWarp.fixedDeltaTime;
double input_power = consumeFNResource(thermal_power_requested, FNResourceManager.FNRESOURCE_THERMALPOWER);
if (!(myAttachedReactor.EfficencyConnectedChargedEnergyGenrator > 0) && input_power < thermal_power_requested)
input_power += consumeFNResource(thermal_power_requested - input_power, FNResourceManager.FNRESOURCE_CHARGED_PARTICLES);
double wastedt = input_power * _totalEff;
consumeFNResource(wastedt, FNResourceManager.FNRESOURCE_WASTEHEAT);
electricdt = input_power * _totalEff;
electricdtps = Math.Max(electricdt / TimeWarp.fixedDeltaTime, 0.0);
max_electricdtps = maxThermalPower * _totalEff;
}
else // charged particle mode
{
_totalEff = isupgraded ? upgradedDirectConversionEff : directConversionEff;
myAttachedReactor.NotifyActiveChargedEnergyGenrator(_totalEff, ElectricGeneratorType.charged_particle);
if (_totalEff <= 0) return;
double charged_power_currently_needed = electrical_power_currently_needed; // _totalEff / ;
var charged_power_requested = Math.Max(Math.Min(maxChargedPower, charged_power_currently_needed) * TimeWarp.fixedDeltaTime, 0.0);
requestedPower_f = (float)charged_power_requested / TimeWarp.fixedDeltaTime;
double input_power = consumeFNResource(charged_power_requested, FNResourceManager.FNRESOURCE_CHARGED_PARTICLES);
electricdt = input_power * _totalEff;
electricdtps = Math.Max(electricdt / TimeWarp.fixedDeltaTime, 0.0);
double wastedt = input_power * _totalEff;
max_electricdtps = maxChargedPower * _totalEff;
consumeFNResource(wastedt, FNResourceManager.FNRESOURCE_WASTEHEAT);
}
outputPower = -(float)supplyFNResourceFixedMax(electricdtps * TimeWarp.fixedDeltaTime, max_electricdtps * TimeWarp.fixedDeltaTime, FNResourceManager.FNRESOURCE_MEGAJOULES) / TimeWarp.fixedDeltaTime;
}
else
{
previousTimeWarp = TimeWarp.fixedDeltaTime;
if (IsEnabled && !vessel.packed)
{
if (!FNRadiator.hasRadiatorsForVessel(vessel))
{
IsEnabled = false;
Debug.Log("[WarpPlugin] Generator Shutdown: No radiators available!");
ScreenMessages.PostScreenMessage("Generator Shutdown: No radiators available!", 5.0f, ScreenMessageStyle.UPPER_CENTER);
PowerDown();
}
if (myAttachedReactor == null)
{
IsEnabled = false;
Debug.Log("[WarpPlugin] Generator Shutdown: No reactor available!");
ScreenMessages.PostScreenMessage("Generator Shutdown: No reactor available!", 5.0f, ScreenMessageStyle.UPPER_CENTER);
PowerDown();
}
}
else
{
PowerDown();
}
}
}
public override void PowerStateUpdate(PowerStates state)
{
}
