public void appendCustomInfo(Sandbox.ModAPI.IMyTerminalBlock block, StringBuilder info)
{
info.Clear();
info.AppendLine("Type: " + m_block.DefinitionDisplayNameText);
info.AppendLine("Required input: " + _power.ToString("N") + " MW");
info.AppendLine("Current input: " + _sink.CurrentInputByType(Electricity).ToString("N") + "MW");
}
public override void UpdateBeforeSimulation()
{
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
if (!m_inventory.IsItemAt(0))
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
setPowerConsumption = 0.0001f;
}
else
{
if (setPowerConsumption != (pulseWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (pulseWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (pulseWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
charge += powerConsumption;
if (charge > (pulseWeaponInfo.energyPerProjectile / efficiencyUpgrades))
{
m_inventory.AddItems((MyFixedPoint)pulseWeaponInfo.projectilesPerCharge, chargeObjectBuilders [damageUpgrades]);
charge -= (pulseWeaponInfo.energyPerProjectile / efficiencyUpgrades);
}
}
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
}
terminalBlock.RefreshCustomInfo();
}
public override void UpdateBeforeSimulation()
{
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
if (!m_inventory.IsItemAt(0))
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
setPowerConsumption = 0.0001f;
}
else
{
reloadTimer++;
if (setPowerConsumption != pulseWeaponInfo.powerUsage)
{
resourceSink.SetRequiredInputByType(electricityDefinition, pulseWeaponInfo.powerUsage);
setPowerConsumption = pulseWeaponInfo.powerUsage;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
if (reloadTimer >= 300)
{
m_inventory.AddItems(pulseWeaponInfo.projectilesPerCharge, chargeObjectBuilders[damageUpgrades]);
reloadTimer = 0;
}
}
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
}
terminalBlock.RefreshCustomInfo();
}
void findReceivers()
{
m_receivers.Clear();
if (m_functionalBlock.IsFunctional && m_functionalBlock.Enabled)
{
m_currentOutput = m_resourceSink.CurrentInputByType(m_electricityDefinition);
float falloffMultiplier = m_falloffRange;
m_maxRangeSquared = (m_currentOutput * 1000f - 10f) / m_falloffRange;
foreach (var radialTransmitter in TransmissionManager.radialTransmitters)
{
if (radialTransmitter.Key != m_entityId)
{
if (m_sender)
{
if (m_transmittedPower != 0f)
{
if (radialTransmitter.Value.channel == m_channel)
{
if (!radialTransmitter.Value.sender)
{
if (radialTransmitter.Value.enabled)
{
float distanceSquared = (float)Vector3D.DistanceSquared(m_functionalBlock.GetPosition(), radialTransmitter.Value.functionalBlock.GetPosition());
if (distanceSquared < m_maxRangeSquared)
{
float powerToTransfer = (m_currentOutput * 1000f - distanceSquared * falloffMultiplier) / 1000f;
if ((powerToTransfer + radialTransmitter.Value.currentInput) > radialTransmitter.Value.strength)
{
powerToTransfer = radialTransmitter.Value.strength - radialTransmitter.Value.currentInput;
}
radialTransmitter.Value.currentInput += powerToTransfer;
m_receivers.Add(radialTransmitter.Value.functionalBlock, new ReceiverInfo(powerToTransfer, radialTransmitter.Value.strength));
}
}
}
}
}
}
}
}
}
}
private void OnInputChanged(MyDefinitionId resourceTypeId, float oldInput, MyResourceSinkComponent sink)
{
PerTypeData tmp;
if (!_sinks.TryGetValue(resourceTypeId, out tmp))
{
return;
}
var factor = sink.CurrentInputByType(resourceTypeId) / Math.Max(1e-6f, tmp.CalculateMaxInput());
foreach (var v in tmp.Sinks)
{
v.CurrentPower = v.MaxPower * factor;
}
}
void Recharge()
{
int chargesInInventory = (int)m_inventory.GetItemAmount(chargeDefinitionIds[damageUpgrades]);
if (chargesInInventory < attractorWeaponInfo.keepAtCharge)
{
if (resourceSink.RequiredInputByType(electricityDefinition) != (attractorWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (attractorWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (attractorWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = (attractorWeaponInfo.powerUsage / efficiencyUpgrades);
}
else
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
}
}
if (resourceSink.CurrentInputByType(electricityDefinition) == (attractorWeaponInfo.powerUsage / efficiencyUpgrades))
{
if (!overheated)
{
m_inventory.AddItems((MyFixedPoint)(attractorWeaponInfo.keepAtCharge - chargesInInventory), chargeObjectBuilders [damageUpgrades]);
}
}
}
else if (chargesInInventory > attractorWeaponInfo.keepAtCharge)
{
m_inventory.RemoveItemsOfType((MyFixedPoint)(chargesInInventory - attractorWeaponInfo.keepAtCharge), chargeObjectBuilders [damageUpgrades]);
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = 0.0001f;
}
}
// terminalBlock.RefreshCustomInfo ();
}
public float GetPowerRequired()
{
if (Settings.IsGrinding)
{
return(sink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId));
}
if (_SGrid == null)
{
return(Power);
}
float time = 0;
Utils.GetGrindTime(this, ref _SGrid, ref time, false);
var removedTime = time / (1 - (Efficiency / 100));
return(Power + (removedTime / 1000 / 60 / 2));
}
//Appending Custom Info
public static void hyperDriveBlock_AppendingCustomInfo(IMyTerminalBlock termblock, StringBuilder info)
{
float maxInput = ResourceSink.MaxRequiredInputByType(_electricity);
float currentInput = ResourceSink.CurrentInputByType(_electricity);
string suffix = " MW";
if (maxInput < 1)
{
maxInput *= 1000f;
currentInput *= 1000f;
suffix = " kW";
if (maxInput < 1)
{
maxInput *= 1000f;
currentInput *= 1000f;
suffix = " W";
}
}
info.AppendLine("Idle Input: " + maxInput.ToString("0.00") + suffix);
info.AppendLine("Current Input: " + currentInput.ToString("0.00") + suffix);
info.AppendLine("Max Input: " + "150.00mW");
}
private void CurrentInputChanged(MyDefinitionId resourceTypeId, float oldInput, MyResourceSinkComponent sink)
{
ShieldCurrentPower = sink.CurrentInputByType(GId);
}
public override void UpdateBeforeSimulation()
{
int chargesInInventory = (int)m_inventory.GetItemAmount(chargeDefinitionIds [damageUpgrades]);
IMyCubeBlock cube = Entity as IMyCubeBlock;
long currentShootTime = ((MyObjectBuilder_InteriorTurret)cube.GetObjectBuilderCubeBlock()).GunBase.LastShootTime;
if (currentHeat > 0f)
{
if ((ticks - lastShootTimeTicks) > beamWeaponInfo.heatDissipationDelay)
{
currentHeat -= beamWeaponInfo.heatDissipationPerTick;
if (currentHeat <= 0f)
{
currentHeat = 0f;
overheated = false;
}
}
}
//MyAPIGateway.Utilities.ShowNotification("TIME: " + currentShootTime + " :: " + lastShootTime, 17, MyFontEnum.Red);
if (currentShootTime != lastShootTime)
{
// test
hitBool = false;
MyEntitySubpart subpart1 = cubeBlock.GetSubpart("InteriorTurretBase1");
MyEntitySubpart subpart2 = subpart1.GetSubpart("InteriorTurretBase2");;
//MyAPIGateway.Utilities.ShowNotification("Dif: " + (currentShootTime - lastShootTime), 17, MyFontEnum.Blue);
from = subpart2.WorldMatrix.Translation + subpart2.WorldMatrix.Forward * 1.25d;
to = subpart2.WorldMatrix.Translation + subpart2.WorldMatrix.Forward * 3000d;
LineD testRay = new LineD(from, to);
List <MyLineSegmentOverlapResult <MyEntity> > result = new List <MyLineSegmentOverlapResult <MyEntity> >();
MyGamePruningStructure.GetAllEntitiesInRay(ref testRay, result);
foreach (var resultItem in result)
{
IMyCubeGrid grid = resultItem.Element as IMyCubeGrid;
IMyDestroyableObject destroyableEntity = resultItem.Element as IMyDestroyableObject;
if (grid != null)
{
IMySlimBlock slimblock;
double hitd;
Vector3D?resultVec = grid.GetLineIntersectionExactAll(ref testRay, out hitd, out slimblock);
if (resultVec != null)
{
hitBool = true;
toTarget = from + subpart2.WorldMatrix.Forward * hitd;
if (!MyAPIGateway.Session.CreativeMode)
{
slimblock.DoDamage(beamWeaponInfo.damage * (currentHeat / beamWeaponInfo.maxHeat + 0.2f), MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
else
{
slimblock.DoDamage(beamWeaponInfo.damage * 1.2f, MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
//MyAPIGateway.Utilities.ShowNotification("" + s.BlockDefinition.Id.SubtypeId + " ::: " + resultItem.Distance, 17);
}
}
if (destroyableEntity != null)
{
IMyEntity ent = (IMyEntity)destroyableEntity;
double hitd = (from - ent.WorldMatrix.Translation).Length();
toTarget = from + subpart2.WorldMatrix.Forward * hitd;
hitBool = true;
if (!MyAPIGateway.Session.CreativeMode)
{
destroyableEntity.DoDamage(beamWeaponInfo.damage * (currentHeat / beamWeaponInfo.maxHeat + 0.2f), MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
else
{
destroyableEntity.DoDamage(beamWeaponInfo.damage * 1.2f, MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
}
}
// test
lastShootTime = currentShootTime;
lastShootTimeTicks = ticks;
currentHeat += beamWeaponInfo.heatPerTick;
if (currentHeat > beamWeaponInfo.maxHeat)
{
currentHeat = beamWeaponInfo.maxHeat;
overheated = true;
}
}
if (ticks - lastShootTimeTicks < 3)
{
var beamcolor = Color.DodgerBlue;
var beamcolor_aux = Color.LightSkyBlue;
var maincolor = new Vector4(beamcolor.X / 30, beamcolor.Y / 30, beamcolor.Z / 30, 1f);
var auxcolor = new Vector4(beamcolor_aux.X / 30, beamcolor_aux.Y / 30, beamcolor_aux.Z / 30, 1f);
var material = MyStringId.GetOrCompute("WeaponLaser");
if (hitBool == false)
{
if (!MyAPIGateway.Utilities.IsDedicated)
{
if (!MyAPIGateway.Session.CreativeMode)
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref auxcolor, 0.30f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref maincolor, 1.0f);
}
else
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref auxcolor, 0.30f * 1.2f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref maincolor, 1.0f * 1.2f);
}
}
}
else
{
if (!MyAPIGateway.Utilities.IsDedicated)
{
if (!MyAPIGateway.Session.CreativeMode)
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref auxcolor, 0.30f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref maincolor, 1.0f);
}
else
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref auxcolor, 0.30f * 1.2f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref maincolor, 1.0f * 1.2f);
}
}
}
}
if (chargesInInventory < beamWeaponInfo.keepAtCharge)
{
if (resourceSink.RequiredInputByType(electricityDefinition) != (beamWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (beamWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (beamWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = (beamWeaponInfo.powerUsage / efficiencyUpgrades);
}
else
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
}
}
if (resourceSink.CurrentInputByType(electricityDefinition) == (beamWeaponInfo.powerUsage / efficiencyUpgrades))
{
if (!overheated)
{
m_inventory.AddItems((MyFixedPoint)(beamWeaponInfo.keepAtCharge - chargesInInventory), chargeObjectBuilders [damageUpgrades]);
}
}
}
else if (chargesInInventory > beamWeaponInfo.keepAtCharge)
{
m_inventory.RemoveItemsOfType((MyFixedPoint)(chargesInInventory - beamWeaponInfo.keepAtCharge), chargeObjectBuilders [damageUpgrades]);
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = 0.0001f;
}
}
terminalBlock.RefreshCustomInfo();
ticks++;
}
public override void UpdateBeforeSimulation()
{
base.UpdateBeforeSimulation();
//MyAPIGateway.Utilities.ShowNotification ("YEP: " + m_subtypeName, 17);
if (m_functionalBlock.IsFunctional)
{
if (m_functionalBlock.Enabled)
{
m_info.enabled = true;
}
else
{
m_info.enabled = false;
}
}
else
{
m_info.enabled = false;
}
if (!m_sender)
{
if (m_currentRequiredInput != 0)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
m_oldTransmittedPower = 0;
m_currentRequiredInput = 0;
}
m_target = null;
}
else if (m_functionalBlock.Enabled && m_functionalBlock.IsFunctional)
{
if (m_target != null)
{
if (m_target.functionalBlock == null)
{
m_target = null;
}
else
{
if (!m_target.functionalBlock.Enabled)
{
m_target = null;
}
}
}
if (m_ticks % 100 == 0)
{
if (m_sender)
{
maintainConnection();
}
m_targetIdOld = m_targetId;
}
if (m_target != null)
{
if (m_targetVisible)
{
m_currentOutput = m_resourceSink.CurrentInputByType(m_electricityDefinition);
m_powerToTransfer = m_currentOutput * m_powerMultiplicator;
var transmitterComponent = m_target.functionalBlock.GameLogic.GetAs <OpticalPowerTransmitter>();
if ((transmitterComponent.m_receivingPower + m_powerToTransfer) > m_target.strength)
{
m_powerToTransfer = m_target.strength - transmitterComponent.m_receivingPower;
}
transmitterComponent.m_receivingPower += m_powerToTransfer;
transmitterComponent.m_senders++;
//MyAPIGateway.Utilities.ShowNotification ("ADD: " + m_target.functionalBlock.CubeGrid.EntityId + ":" + powerToTransfer, 17, MyFontEnum.DarkBlue);
TransmissionManager.totalPowerPerGrid [m_target.functionalBlock.CubeGrid.EntityId] = TransmissionManager.totalPowerPerGrid [m_target.functionalBlock.CubeGrid.EntityId] + m_powerToTransfer;
}
}
}
else
{
m_target = null;
if (m_currentRequiredInput != 0)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
m_oldTransmittedPower = 0;
m_currentRequiredInput = 0;
}
}
if (m_ticks % 100 == 0)
{
m_terminalBlock.RefreshCustomInfo();
}
if (m_sender)
{
m_saveInfo.ChannelTarget = m_targetId;
}
else
{
m_saveInfo.ChannelTarget = m_id;
}
m_saveInfo.Sender = m_sender;
m_saveInfo.Power = m_transmittedPower;
m_receivingPower = 0f;
m_senders = 0;
m_ticks++;
}
void calculateShieldPointsRecharge()
{
if (EnergyShieldsCore.Config.AlternativeRechargeMode.Enable)
{
if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).IsFunctional)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
m_currentShieldPoints = 0f;
}
}
else if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).Enabled)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else if (m_maximumShieldPoints == m_currentShieldPoints)
{
if (m_setPowerConsumption != 0.00001f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.00001f);
m_setPowerConsumption = 0.00001f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else
{
IMyCubeBlock cubeBlock = Entity as IMyCubeBlock;
float powerConsumption = getShieldDefinition().PowerConsumption *cubeBlock.UpgradeValues ["PowerConsumption"] * EnergyShieldsCore.Config.UpgradeModuleMultiplier.PowerMultiplier;
m_resourceSink.MaxRequiredInput = powerConsumption;
if (powerConsumption != m_setPowerConsumption)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerConsumption);
m_setPowerConsumption = powerConsumption;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
m_rechargeMultiplier = m_currentPowerConsumption / powerConsumption;
m_pointsToRecharge = getShieldDefinition().RechargeAtPeak *cubeBlock.UpgradeValues ["ShieldRecharge"]
* EnergyShieldsCore.Config.UpgradeModuleMultiplier.RechargeMultiplier * EnergyShieldsCore.Config.AlternativeRechargeMode.RechargeMultiplier * m_rechargeMultiplier;
if (m_ticksUntilRecharge > 0)
{
m_ticksUntilRecharge--;
m_pointsToRecharge = 0;
}
else
{
if (m_maximumShieldPoints > m_currentShieldPoints)
{
m_currentShieldPoints += m_pointsToRecharge;
}
}
if (m_maximumShieldPoints < m_currentShieldPoints)
{
if (m_overchargedTicks >= m_overchargeTimeout)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
m_overchargedTicks++;
}
else
{
m_overchargedTicks = 0;
}
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId)) {
* m_currentShieldPoints = 0f;
* }
*/
}
}
else
{
if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).IsFunctional)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
m_currentShieldPoints = 0f;
}
}
else if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).Enabled)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else if (m_maximumShieldPoints == m_currentShieldPoints)
{
if (m_setPowerConsumption != 0.00001f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.00001f);
m_setPowerConsumption = 0.00001f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else
{
float multiplier = (m_currentShieldPoints / m_maximumShieldPoints);
if (multiplier > 0.99999f)
{
multiplier = 0.00001f;
}
else if ((multiplier > 0.9f) || (multiplier < 0.08f))
{
multiplier = 0.1f;
}
else if ((multiplier > 0.7f) || (multiplier < 0.12f))
{
multiplier = 0.2f;
}
else if ((multiplier > 0.5f) || (multiplier < 0.18f))
{
multiplier = 0.4f;
}
else if ((multiplier > 0.35f) || (multiplier < 0.22f))
{
multiplier = 0.7f;
}
else
{
multiplier = 1.0f;
}
IMyCubeBlock cubeBlock = Entity as IMyCubeBlock;
float powerConsumption = getShieldDefinition().PowerConsumption *cubeBlock.UpgradeValues ["PowerConsumption"] * EnergyShieldsCore.Config.UpgradeModuleMultiplier.PowerMultiplier * multiplier;
m_resourceSink.MaxRequiredInput = powerConsumption;
if (powerConsumption != m_setPowerConsumption)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerConsumption);
m_setPowerConsumption = powerConsumption;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
m_rechargeMultiplier = m_currentPowerConsumption / powerConsumption;
m_pointsToRecharge = getShieldDefinition().RechargeAtPeak *cubeBlock.UpgradeValues ["ShieldRecharge"]
* EnergyShieldsCore.Config.UpgradeModuleMultiplier.RechargeMultiplier * EnergyShieldsCore.Config.AlternativeRechargeMode.RechargeMultiplier * m_rechargeMultiplier * multiplier;
m_currentShieldPoints += m_pointsToRecharge;
if (m_maximumShieldPoints < m_currentShieldPoints)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
if (m_maximumShieldPoints < m_currentShieldPoints)
{
if (m_overchargedTicks >= m_overchargeTimeout)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
m_overchargedTicks++;
}
else
{
m_overchargedTicks = 0;
}
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId)) {
* m_currentShieldPoints = 0f;
* }
*/
}
}
}
private void RecalculateFuelConversion(ref MyDefinitionId fuelType)
{
int typeIndex;
if (!TryGetTypeIndex(ref fuelType, out typeIndex))
{
return;
}
m_dataByFuelType[typeIndex].CurrentPowerFromFuel = FuelAmountToPower(ref fuelType, ResourceSink.CurrentInputByType(fuelType));
m_dataByFuelType[typeIndex].FuelConversionDirty = false;
}