public BatteryCache(IMyBatteryBlock b)
{
Battery = b;
Charge = new Ratio();
Input = new Ratio();
Output = new Ratio();
}
private void BatteryBackupManagement(ref bool batteryBackupManagement, bool connectorState)
{
if (batteryBackupManagement)
{
IMyBatteryBlock maxbattery = battery[0];
if (maxbattery.CurrentStoredPower / maxbattery.MaxStoredPower < 0.9)
{
foreach (IMyBatteryBlock batt in battery)
{
if (batt.CurrentStoredPower > maxbattery.CurrentStoredPower)
{
maxbattery = batt;
}
}
}
if (connectorState)
{
foreach (IMyBatteryBlock batt in battery)
{
if (autobattery > 1 && batt.ChargeMode == ChargeMode.Auto)
{
batt.ChargeMode = ChargeMode.Recharge;
}
}
}
maxbattery.ChargeMode = ChargeMode.Auto;
}
}
private float GetBatteryPower(List <IMyTerminalBlock> batteries = null)
{
float result = 0;
int count = 0;
var source = batteries ?? new List <IMyTerminalBlock>();
if (batteries == null)
{
GridTerminalSystem.GetBlocksOfType <IMyBatteryBlock>(source);
}
for (int i = 0; i < source.Count; i++)
{
IMyBatteryBlock batteryBlock = source[i] as IMyBatteryBlock;
if (batteryBlock == null)
{
continue;
}
result += batteryBlock.CurrentStoredPower / batteryBlock.MaxStoredPower;
count++;
}
return(count != 0 ? result / count : 0f);
}
public Program()
{
m_Cockpit = GridTerminalSystem.GetBlockWithName(CockpitName) as IMyCockpit;
m_CockpitBatteryDamagePanel = m_Cockpit.GetSurface(IntegrityBatteryDisplayIndex);
m_CockpitBatteryDamagePanel.ContentType = VRage.Game.GUI.TextPanel.ContentType.TEXT_AND_IMAGE;
m_CockpitBatteryDamagePanel.Alignment = VRage.Game.GUI.TextPanel.TextAlignment.CENTER;
GridTerminalSystem.GetBlocksOfType(m_Batteries, a => a is IMyBatteryBlock && a.IsSameConstructAs(m_Cockpit) && a.CustomName != BIOSBatteryName);
m_BIOSBattery = GridTerminalSystem.GetBlockWithName(BIOSBatteryName) as IMyBatteryBlock;
GridTerminalSystem.GetBlocksOfType(m_Cargos, a => a is IMyCargoContainer && a.IsSameConstructAs(m_Cockpit));
m_CockpitCargoPanel = m_Cockpit.GetSurface(CargoCheckDisplayIndex);
m_CockpitCargoPanel.ContentType = VRage.Game.GUI.TextPanel.ContentType.TEXT_AND_IMAGE;
m_CockpitCargoPanel.Alignment = VRage.Game.GUI.TextPanel.TextAlignment.CENTER;
m_CockpitCargoPanel.FontSize = 2.5f;
m_Gyros = new List <IMyGyro>();
GridTerminalSystem.GetBlocksOfType(m_Gyros, a => a.IsSameConstructAs(m_Cockpit));
var allBlocks = new List <IMyTerminalBlock>();
GridTerminalSystem.GetBlocksOfType <IMyTerminalBlock>(allBlocks, a => a.IsSameConstructAs(m_Cockpit));
foreach (var block in allBlocks)
{
m_AllBlocks.Add(new KeyValuePair <IMyTerminalBlock, IMySlimBlock>(block, block.CubeGrid.GetCubeBlock(block.Position)));
}
m_Connector = GridTerminalSystem.GetBlockWithName(ConnectorName) as IMyShipConnector;
m_Hinge = GridTerminalSystem.GetBlockWithName(ToolieHingeName) as IMyMotorStator;
Runtime.UpdateFrequency = UpdateFrequency.Update1;
}
private void ParseOutputFromDetailedInfo(IMyBatteryBlock battery)
{
string [] lines = battery.DetailedInfo.Split(new char [] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
string [] [] dictionary = new string [lines.Length] [];
string maxoutput = "";
string currentoutput = "";
for (int i = 0; i < lines.Length; i++)
{
dictionary [i] = lines [i].Split(new string [] { ": " }, StringSplitOptions.None);
switch (dictionary [i] [0])
{
case "Max Output":
maxoutput = dictionary [i] [1];
break;
case "Current Output":
currentoutput = dictionary [i] [1];
break;
}
}
MaxWatts = GetWattValue(maxoutput);
Watts = GetWattValue(currentoutput);
}
public override void render(Display display, RenderTarget rt, AddSpriteDelegate addSprite)
{
base.render(display, rt, addSprite);
RenderDataBattery renderData = RenderData as RenderDataBattery;
float positionX = renderData.Position.X + rt.DisplayOffset.X - (renderData.InnerSize.X * 0.5f) + (renderData.Size.X * 0.5f);
float positionY = renderData.Position.Y + rt.DisplayOffset.Y - (renderData.InnerSize.Y * 0.5f) + (renderData.Size.Y * 0.5f);
float offsetX = renderData.Size.X;
float offsetY = renderData.Size.Y;
// draw batteries
for (int r = 0; r < renderData.Rows; r++)
{
for (int c = 0; c < renderData.Cols; c++)
{
int index = (renderData.Cols * r) + c;
if (index >= renderData.Batteries.Count)
{
break;
}
IMyBatteryBlock battery = renderData.Batteries[index];
Vector2 position = new Vector2(positionX + (offsetX * c), positionY + (offsetY * r));
drawSingleBattery(position, renderData.Scale,
battery.CurrentStoredPower / battery.MaxStoredPower,
(battery.CurrentInput / battery.MaxInput) - (battery.CurrentOutput / battery.MaxOutput),
DataCollectorBase <IMyBatteryBlock> .isOn(battery),
battery.ChargeMode, addSprite);
}
}
}
public Charge(IMyBatteryBlock battery, string description = "") : base(description)
{
Current = battery.CurrentStoredPower;
Max = battery.MaxStoredPower;
IsCharnging = battery.IsCharging;
ChargeMode = battery.ChargeMode;
DefaultUnit = "MWh";
}
public Battery(string oBlockName)
{
m_oBlock = gts.GetBlockWithName(oBlockName) as IMyBatteryBlock;
if (m_oBlock == null)
{
throw new Exception(oBlockName + " block not found, check name");
}
Init(m_oBlock);
}
private void Main(string argument, UpdateType updateType)
{
float current_battery_output = 0.0f;
float maximal_battery_output = 0.0f;
float current_battery_input = 0.0f;
float maximal_battery_input = 0.0f;
float current_battery_stored_power = 0.0f;
float maximal_battery_stored_power = 0.0f;
float current_non_battery_output = 0.0f;
float maximal_non_battery_output = 0.0f;
textPanels.Clear();
GridTerminalSystem.GetBlocksOfType(textPanels, (text_panel) => (text_panel.CustomData.Trim().ToLower() == "powerinfo"));
foreach (long key in storageDisplays.Keys)
{
missingStorageDisplays.Add(key);
}
foreach (IMyTextPanel text_panel in textPanels)
{
if (!(missingStorageDisplays.Remove(text_panel.EntityId)))
{
storageDisplays.Add(text_panel.EntityId, new PowerDisplay(text_panel));
}
}
foreach (long key in missingStorageDisplays)
{
storageDisplays.Remove(key);
}
missingStorageDisplays.Clear();
powerProducers.Clear();
GridTerminalSystem.GetBlocksOfType(powerProducers);
foreach (IMyPowerProducer power_producer in powerProducers)
{
if (power_producer.IsWorking)
{
if (power_producer is IMyBatteryBlock)
{
IMyBatteryBlock battery_block = (IMyBatteryBlock)power_producer;
current_battery_output += battery_block.CurrentOutput;
maximal_battery_output += battery_block.MaxOutput;
current_battery_input += battery_block.CurrentInput;
maximal_battery_input += battery_block.MaxInput;
current_battery_stored_power += battery_block.CurrentStoredPower;
maximal_battery_stored_power += battery_block.MaxStoredPower;
}
else
{
current_non_battery_output += power_producer.CurrentOutput;
maximal_non_battery_output += power_producer.MaxOutput;
}
}
}
foreach (PowerDisplay storage_display in storageDisplays.Values)
{
storage_display.UpdateValues(current_battery_output, current_non_battery_output, maximal_battery_output, maximal_non_battery_output, current_battery_input, maximal_battery_input, current_battery_stored_power, maximal_battery_stored_power);
}
}
public static MyBatteryItemRenderer Find(IMyGridTerminalSystem gts, string name)
{
IMyBatteryBlock batteryBlock = gts.GetBlockWithName(name) as IMyBatteryBlock;
if (batteryBlock == null)
{
return(null);
}
return(new MyBatteryItemRenderer(batteryBlock));
}
bool FuncTest(IMyBatteryBlock block)
{
//Battery
//Interface name: IMyBatteryBlock
//Parent: IMyFunctionalBlock
//Fields:
bool HasCapacityRemaining = block.HasCapacityRemaining;
return(true);
}
double getCurrentBatteryOutput()
{
double output = 0;
foreach (var tb in batteryList)
{
IMyBatteryBlock r = tb as IMyBatteryBlock;
output += r.CurrentOutput;
}
return(output);
}
bool isDischargeSet(IMyTerminalBlock block)
{
if (block is IMyBatteryBlock)
{
IMyBatteryBlock myb = block as IMyBatteryBlock;
return(myb.OnlyDischarge);// GetValueBool("Discharge");
}
else
{
return(false);
}
}
bool isRecharging(IMyTerminalBlock block)
{
if (block is IMyBatteryBlock)
{
IMyBatteryBlock myb = block as IMyBatteryBlock;
return(myb.IsCharging);// PowerProducer.IsRecharging(myb);
}
else
{
return(false);
}
}
bool isDischargeSet(IMyTerminalBlock block)
{
if (block is IMyBatteryBlock)
{
IMyBatteryBlock myb = block as IMyBatteryBlock;
return(myb.ChargeMode == ChargeMode.Discharge);
}
else
{
return(false);
}
}
public void Refresh(OutputPanel _lcd, AlignModule _align, IMyShipController _sc = null)
{
lcd = _lcd;
align = _align;
sc = _sc ?? Pgm.GetShipController(MultiMix_UsedBlocks);
RefreshThrustsList(_align?.RocketMode ?? false);
hydrogenTanks.Clear();
if (null != downCamera)
{
downCamera.EnableRaycast = false;
}
downCamera = null;
parachute = null;
IMyGasTank hb = null;
IMyBatteryBlock bb = null;
IMyCameraBlock cb = null;
IMyParachute pb = null;
GatherBlocks(Pgm
, a => SameGrid(Me, a) && !NameContains(a, MultiMix_IgnoreBlocks)
, b => { if (ToType(b, ref hb) && hb.IsWorking && SubtypeContains(hb, "Hydrogen"))
{
hydrogenTanks.Add(hb); return(false);
}
return(true); }
, c => { if (ToType(c, ref bb) && bb.IsWorking)
{
batteries.Add(bb); return(false);
}
return(true); }
, d => { if (ToType(d, ref cb) && cb.IsWorking && NameContains(cb, "Down"))
{
downCamera = cb; cb.EnableRaycast = true; return(false);
}
return(true); }
, e => { if (ToType(e, ref pb) && pb.IsWorking)
{
parachute = pb; return(false);
}
return(true); }
);
if (null == stateMachine)
{
SetRunState(false);
}
}
List <IMyFunctionalBlock> Everything; // Now this.... This is an Absolute Madness
void GetNeededBlocks()
{
List <IMyFunctionalBlock> temp = new List <IMyFunctionalBlock>();
GridTerminalSystem.GetBlocksOfType(temp);
Power = new List <IMyPowerProducer>();
Batteries = new List <IMyBatteryBlock>();
Reactors = new List <IMyReactor>();
Producers = new List <IMyProductionBlock>();
Tanks = new List <IMyGasTank>();
Everything = new List <IMyFunctionalBlock>();
foreach (IMyFunctionalBlock block in temp)
{
if (isOnThisGrid(block))
{
Everything.Add(block);
if (block is IMyPowerProducer)
{
IMyPowerProducer power = (IMyPowerProducer)block;
Power.Add(power);
if (block is IMyBatteryBlock)
{
IMyBatteryBlock battery = (IMyBatteryBlock)block;
Batteries.Add(battery);
}
else
if (block is IMyReactor)
{
IMyReactor reactor = (IMyReactor)block;
Reactors.Add(reactor);
}
}
else
if (block is IMyProductionBlock)
{
IMyProductionBlock producer = (IMyProductionBlock)block;
Producers.Add(producer);
}
else
if (block is IMyGasTank)
{
IMyGasTank tank = (IMyGasTank)block;
if (tank.BlockDefinition.SubtypeName.Contains("HydrogenTank"))
{
Tanks.Add(tank);
}
}
}
}
}
bool isDischargeSet(IMyTerminalBlock block)
{
if (block is IMyBatteryBlock)
{
IMyBatteryBlock myb = block as IMyBatteryBlock;
//V 1.189
return(myb.ChargeMode == ChargeMode.Discharge);
// return myb.OnlyDischarge;// GetValueBool("Discharge");
}
else
{
return(false);
}
}
public bool addBattery(IMyBatteryBlock _Battery)
{
if (!batteries.Contains(_Battery))
{
batteries.Add(_Battery);
MaxOutput += (_Battery.MaxOutput * MEGAWATT);
CurrentOutput += (_Battery.CurrentOutput * MEGAWATT);
MaxStoredPower += (_Battery.MaxStoredPower * MEGAWATT);
return(true);
}
else
{
return(false);
}
}
private void updateValues(List <IMyBatteryBlock> Batteries, bool toggle, bool defaultValue, string propertyId)
{
bool newValue = defaultValue;
for (int i = 0; i < Batteries.Count; i++)
{
IMyBatteryBlock Battery = Batteries[i];
if (toggle)
{
newValue = !Battery.GetValueBool(propertyId);
}
Battery.SetValueBool(propertyId, newValue);
debug("'" + Battery.CustomName + "'." + propertyId + " => " + (newValue?"ON":"OFF"));
}
}
public IEnumerator <bool> Run()
{
while (true)
{
// Get Position
Position = Entity.GetPosition();
yield return(true);
// Get Entities
Targets.Clear();
List <long> entities = MyVisualScriptLogicProvider.GetEntitiesInSphere(Position, Config.Instance.Radius);
foreach (long entityId in entities)
{
if (entityId == Entity.EntityId)
{
continue;
}
IMyEntity entity = MyVisualScriptLogicProvider.GetEntityById(entityId);
if (entity is IMyBatteryBlock)
{
IMyBatteryBlock bat = entity as IMyBatteryBlock;
if (bat.IsSameConstructAs(Battery))
{
continue;
}
if (!bat.Enabled)
{
continue;
}
if (bat.ChargeMode == Sandbox.ModAPI.Ingame.ChargeMode.Discharge)
{
continue;
}
Target targ = new Target()
{
IBattery = bat,
Distance = (float)Vector3D.Distance(entity.GetPosition(), Position)
};
targ.Loss = targ.Distance * Config.Instance.LossPercentPerM;
Targets.Add(targ);
}
}
yield return(true);
yield return(true);
}
}
public string getDetailedInfoValue(IMyBatteryBlock block, string name)
{
string value = "";
string[] lines = block.DetailedInfo.Split(new string[] { "\r\n", "\n", "\r" }, StringSplitOptions.None);
for (int i = 0; i < lines.Length; i++)
{
string[] line = lines[i].Split(':');
if (line[0].Equals(name))
{
value = line[1].Substring(1);
break;
}
}
return(value);
}
bool isRechargeSet(IMyTerminalBlock block)
{
if (block is IMyBatteryBlock)
{
IMyBatteryBlock myb = block as IMyBatteryBlock;
// ChargeMode.Auto; 0
// ChargeMode.Discharge; 2
// ChargeMode.Recharge; 1
// 1.189
return(myb.ChargeMode == ChargeMode.Recharge);
// return myb.OnlyRecharge;// myb.GetValueBool("Recharge");
}
else
{
return(false);
}
}
public Battery(Program parent, string batteries = "")
{
// Find batteries:
lBatteries = new List <IMyBatteryBlock>();
if (batteries != string.Empty)
{
IMyBlockGroup group = parent.GridTerminalSystem.GetBlockGroupWithName(batteries);
if (group == null)
{
IMyBatteryBlock block = parent.GridTerminalSystem.GetBlockWithName(batteries) as IMyBatteryBlock;
if (block != null && block.IsSameConstructAs(parent.Me))
{
lBatteries.Add(block);
}
}
else
{
group.GetBlocksOfType(lBatteries, x => x.IsSameConstructAs(parent.Me));
}
}
else
{
parent.GridTerminalSystem.GetBlocksOfType(lBatteries, x => x.IsSameConstructAs(parent.Me));
}
MaxPower = 0.0f;
if (lBatteries.Count == 0)
{
throw new Exception($"No blocks found with argument: '{batteries}'");
}
else
{
foreach (IMyBatteryBlock block in lBatteries)
{
MaxPower += block.MaxStoredPower;
}
}
parent.Echo($"Batteries found: {lBatteries.Count}");
Update();
}
void initBatteries()
{
batteryList.Clear();
batteryPercentage = -1;
maxBatteryPower = -1;
GridTerminalSystem.GetBlocksOfType <IMyBatteryBlock>(batteryList, localGridFilter);
if (batteryList.Count > 0)
{
maxBatteryPower = 0;
}
foreach (var tb in batteryList)
{
// float output = 0;
IMyBatteryBlock r = tb as IMyBatteryBlock;
// 1.185
maxBatteryPower += r.MaxOutput;
}
}
private double getAverageLoadingState(List <IMyBatteryBlock> Batteries)
{
double allMax = 0.0;
double allStored = 0.0;
double average = 0;
for (int i = 0; i < Batteries.Count; i++)
{
IMyBatteryBlock Battery = Batteries[i];
DetailedInfo DI = new DetailedInfo(Battery);
allMax += parsePower(DI.getValue(BATTERY_VALUE_INDEX_MAX).getValue());
allStored += parsePower(DI.getValue(BATTERY_VALUE_INDEX_STORED).getValue());
}
if (allMax > 0)
{
average = allStored / allMax;
}
return(average * 100);
}
public void Emergency()
{
LastState = "EMERGENCY";
setReactors(true);
foreach (IMyFunctionalBlock A in Everything)
{
if (A is IMyBatteryBlock)
{
IMyBatteryBlock batt = (IMyBatteryBlock)A;
batt.ChargeMode = ChargeMode.Auto;
}
else
if (!(A is IMyPowerProducer) && !(A is IMyShipConnector) && !(A is IMyShipMergeBlock) &&
!(A is IMyTextPanel) && !(A is IMyUpgradeModule) && !(A is IMyTextSurface) &&
!(A is IMyProgrammableBlock) && !(A is IMyTimerBlock) && !(A is IMyDoor) && !(A is IMyThrust) && !(A is IMyGyro))
{
A.Enabled = false;
}
}
}
public static float MaxOutput(this IMyBatteryBlock Battery)
{
return((MyDefinitionManager.Static.GetCubeBlockDefinition(Battery.BlockDefinition) as MyBatteryBlockDefinition).MaxPowerOutput);
}
String PrintEnergyInfo()
{
float ShipsStoredPower = 0;
float ShipsMaxPower = 0;
float MaxShipOutput = 0;
float CurrentBatteryOutput = 0;
float CurrentShipOutput = 0;
float CurrentSolarOutput = 0;
int Online = 0;
int Recharging = 0;
int Empty = 0;
int Offline = 0;
int RNominal = 0;
int ROff = 0;
foreach (IMyPowerProducer P in powerProducers)
{
/*/
* if (isOnThisGrid(P.CubeGrid)) {
* /**/
if (P.IsWorking)
{
MaxShipOutput += P.MaxOutput;
}
CurrentShipOutput += P.CurrentOutput;
if (P is IMySolarPanel)
{
CurrentSolarOutput += P.CurrentOutput;
}
else if (!(P is IMyBatteryBlock))
{
if (P.IsWorking)
{
RNominal++;
}
else
{
ROff++;
}
}
else
{
IMyBatteryBlock B = (IMyBatteryBlock)P;
ShipsStoredPower += B.CurrentStoredPower;
ShipsMaxPower += B.MaxStoredPower;
CurrentBatteryOutput += B.CurrentOutput;
CurrentShipOutput -= B.CurrentInput;
CurrentBatteryOutput -= B.CurrentInput;
if (B.CurrentStoredPower == 0)
{
Empty++;
}
else if (!(B.IsWorking))
{
Offline++;
}
else if (B.ChargeMode == ChargeMode.Recharge)
{
Recharging++;
}
else
{
Online++;
}
}
/*/
* }
* /**/
}
if (RecentStoredPower == -1)
{
RecentStoredPower = ShipsStoredPower;
}
float convert = 1F,
difference = RecentStoredPower - ShipsStoredPower,
timeMulti;
if ((Runtime.UpdateFrequency & UpdateFrequency.Update1) > 0)
{
timeMulti = 60;
}
else if ((Runtime.UpdateFrequency & UpdateFrequency.Update10) > 0)
{
timeMulti = 6;
}
else
{
timeMulti = 6 / 10;
}
difference *= timeMulti;
CurrentShipOutput = convert * CurrentShipOutput;
MaxShipOutput = convert * MaxShipOutput;
CurrentSolarOutput *= convert;
string output = " Current Power: " + ShipsStoredPower.ToString("0.0") + "/" + ShipsMaxPower.ToString("0.0") + " MWh ("
+ ConvertFractionToPercentage(ShipsStoredPower, ShipsMaxPower) + "%)";
output += "\n H2 Reserves: " + (GetMeanHydrogenFillage() * 100).ToString("0.00") + "%";
output += "\n Current Output: " + CurrentShipOutput.ToString("0.00") + "/" + MaxShipOutput.ToString("0.0") +
" MW (" + ConvertFractionToPercentage(CurrentShipOutput, MaxShipOutput) + "%)";
output += "\n Solar: " + CurrentSolarOutput.ToString("0.00") + " MW";
float remainingTime;
if (difference != 0)
{
remainingTime = ShipsStoredPower / difference;
Logs.Add(remainingTime);
}
else
{
Logs.Add();
}
remainingTime = Logs.GetRemainingSecondsOfEnergy();
string firstPart = remainingTime < 0? "Recharged in":"Will last for";
output += String.Format("\n {0,13} {1}", firstPart, SecondsToTimeInString(remainingTime));
if (RNominal > 0 || ROff > 0)
{
double percent = GetMeanHydrogenFillage();
output += "\n Cores Online: " + RNominal + "/" + (RNominal + ROff);
}
else
{
output += "\n No power cores present!";
}
output += "\n Batteries: " + Online + "/" + (Online + Empty + Recharging + Offline) + " Online";
if (Recharging > 0)
{
output += "\n " + Recharging + " Recharging";
}
if (Empty > 0)
{
output += "\n " + Empty + " Empty";
}
long currAmm = GetIceAmount();
if (IceAmount - currAmm > 0)
{
float remTime = currAmm * 100 / (IceAmount - currAmm);
IceAmount = currAmm;
output += "\n Ice will last for ";
output += SecondsToTimeInString(remTime);
}
else
{
output += "\n Ice stable";
}
RecentStoredPower = ShipsStoredPower;
return(output);
}
internal BatterySource(IMyBatteryBlock b) : base(b)
{
}
