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