public override void Init(MyObjectBuilder_EntityBase objectBuilder) { try { npcCrewBlock = Entity as IMyUpgradeModule; //MyAPIGateway.Utilities.ShowMessage("DEBUG", "Init Ran"); NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME; npcCrewBlock.CubeGrid.ColorBlocks(npcCrewBlock.SlimBlock.Position, npcCrewBlock.SlimBlock.Position, Color.Red.ColorToHSV()); NPCCrewConfig loadconfig = NPCCrewConfig.LoadConfigFile(); forceColor = loadconfig.forceColor; if (Sink == null) { Sink = new MyResourceSinkComponent(); } ResourceInfo = new MyResourceSinkInfo() { ResourceTypeId = GId, MaxRequiredInput = 0.02f, RequiredInputFunc = () => Power }; Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink.AddType(ref ResourceInfo); Entity.Components.Add(Sink); Sink.Update(); } catch (Exception e) { MyVisualScriptLogicProvider.ShowNotificationToAll("Init Error" + e, 10000, "Red"); } }
public override void Close() { try { if (Session.Instance.Modulators.Contains(this)) { Session.Instance.Modulators.Remove(this); } if (ShieldComp?.Modulator == this) { ShieldComp.Modulator = null; } ShieldComp = null; if (ModulatorComp?.Modulator == this) { ModulatorComp.Modulator = null; } ModulatorComp = null; if (Sink != null) { ResourceInfo = new MyResourceSinkInfo { ResourceTypeId = _gId, MaxRequiredInput = 0f, RequiredInputFunc = null }; Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink = null; } } catch (Exception ex) { Log.Line($"Exception in Close: {ex}"); } base.Close(); }
public void AddType(ref MyResourceSinkInfo sinkData) { if (m_resourceIds.Contains(sinkData.ResourceTypeId) || m_resourceTypeToIndex.ContainsKey(sinkData.ResourceTypeId)) { return; } var newDataPerType = new PerTypeData[m_resourceIds.Count + 1]; for (int dataIndex = 0; dataIndex < m_dataPerType.Length; ++dataIndex) { newDataPerType[dataIndex] = m_dataPerType[dataIndex]; } m_dataPerType = newDataPerType; m_dataPerType[m_dataPerType.Length - 1] = new PerTypeData { MaxRequiredInput = sinkData.MaxRequiredInput, RequiredInputFunc = sinkData.RequiredInputFunc }; m_resourceIds.Add(sinkData.ResourceTypeId); m_resourceTypeToIndex.Add(sinkData.ResourceTypeId, m_dataPerType.Length - 1); if (OnAddType != null) { OnAddType(this, sinkData.ResourceTypeId); } }
public override void UpdateOnceBeforeFrame() { if (!IsReal((MyCubeBlock)block) || !MyAPIGateway.Multiplayer.IsServer) // ignore projected and other non-physical grids { return; } NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME; myNotUsedRespawn = block.Components.Get <MyEntityRespawnComponentBase>(); _respawnAllowed = myNotUsedRespawn != null; // setup resources sink = Entity.Components.Get <MyResourceSinkComponent>(); var fleshSink = new MyResourceSinkInfo() { ResourceTypeId = Gasses.Flesh, // people are flesh MaxRequiredInput = MaxFillRate, RequiredInputFunc = GetFleshRequired }; sink.AddType(ref fleshSink); sink.Update(); }
public NaniteOreDetector(IMyFunctionalBlock entity) { m_block = entity as IMyOreDetector; m_lastUpdate = DateTime.MinValue; m_scanStart = DateTime.MinValue; m_scanEnd = DateTime.MinValue; m_lock = new FastResourceLock(); m_oreListCache = new StringBuilder(); m_detectorState = DetectorStates.Disabled; m_lastDetectorState = DetectorStates.Disabled; m_block.Components.TryGet(out Sink); ResourceInfo = new MyResourceSinkInfo() { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, MaxRequiredInput = 0f, RequiredInputFunc = () => (m_block.Enabled && m_block.IsFunctional) ? _power : 0f }; Sink.RemoveType(ref ResourceInfo.ResourceTypeId); Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink.AddType(ref ResourceInfo); m_effects.Add(new OreDetectorEffect((MyCubeBlock)m_block)); if (!NaniteConstructionManager.OreDetectors.ContainsKey(entity.EntityId)) { NaniteConstructionManager.OreDetectors.Add(entity.EntityId, this); } }
private void SinkChanged(MyResourceSinkComponent old, MyResourceSinkComponent @new) { if (old != null) { foreach (var key in old.AcceptedResources) { old.SetMaxRequiredInputByType(key, 0); old.SetRequiredInputFuncByType(key, () => 0); } RemoveDelegate(ref old.CurrentInputChanged, OnInputChanged); } if (@new == null) { return; } foreach (var kv in _sinks) { var info = new MyResourceSinkInfo() { MaxRequiredInput = kv.Value.CalculateMaxInput(), RequiredInputFunc = kv.Value.DelCalculateRequiredInput, ResourceTypeId = kv.Key }; @new.AddType(ref info); @new.SetMaxRequiredInputByType(kv.Key, kv.Value.CalculateMaxInput()); @new.SetRequiredInputFuncByType(kv.Key, kv.Value.DelCalculateRequiredInput); } AddDelegate(ref @new.CurrentInputChanged, OnInputChanged); }
private void PowerPreInit() { try { if (Sink == null) { Sink = new MyResourceSinkComponent(); } ResourceInfo = new MyResourceSinkInfo() { ResourceTypeId = _gId, MaxRequiredInput = 0.02f, RequiredInputFunc = () => Power }; Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink.AddType(ref ResourceInfo); Entity.Components.Add(Sink); } catch (Exception ex) { Log.Line($"Exception in PowerPreInit: {ex}"); } }
public void Init(MyStringHash group, MyResourceSinkInfo sinkData) { MyUtils.Init(ref m_singleHelperList); m_singleHelperList.Add(sinkData); Init(group, m_singleHelperList); m_singleHelperList.Clear(); }
internal void CloseComps(MyEntity ent) { try { var cube = (MyCubeBlock)ent; cube.OnClose -= CloseComps; if (cube.CubeGrid.IsPreview) { return; } CoreComponent comp; if (!cube.Components.TryGet(out comp)) { return; } for (int i = 0; i < comp.Monitors.Length; i++) { comp.Monitors[i].Clear(); comp.Monitors[i] = null; } //IdToCompMap.Remove(comp.MyCube.EntityId); if (comp.Platform.State == CorePlatform.PlatformState.Ready) { comp.GeneralWeaponCleanUp(); comp.StopAllSounds(); comp.CleanCompParticles(); comp.CleanCompSounds(); comp.Platform.RemoveParts(comp); } if (comp.Ai != null) { Log.Line("Comp still had AI on close"); comp.Ai = null; } if (comp.Registered) { Log.Line($"comp still registered"); comp.RegisterEvents(false); } PlatFormPool.Return(comp.Platform); comp.Platform = null; var sinkInfo = new MyResourceSinkInfo() { ResourceTypeId = comp.GId, MaxRequiredInput = 0f, RequiredInputFunc = null, }; comp.MyCube.ResourceSink.Init(MyStringHash.GetOrCompute("Charging"), sinkInfo); } catch (Exception ex) { Log.Line($"Exception in DelayedCompClose: {ex}"); } }
private int InitializeType(MyDefinitionId fuelType) { m_dataByFuelType.Add(new FuelTypeData { ThrustsByDirection = new Dictionary <Vector3I, HashSet <MyEntity> >(6, m_directionComparer), MaxRequirementsByDirection = new Dictionary <Vector3I, float>(6, m_directionComparer), FuelConversionDirty = true, CurrentPowerFromFuel = 0f, CurrentRequiredFuelInput = 0f, Efficiency = 0f, EnergyDensity = 0f, }); int typeIndex = m_dataByFuelType.Count - 1; m_fuelTypeToIndex.Add(fuelType, typeIndex); m_fuelTypes.Add(fuelType); foreach (var direction in Base6Directions.IntDirections) { m_dataByFuelType[typeIndex].ThrustsByDirection[direction] = new HashSet <MyEntity>(); } var sinkData = new MyResourceSinkInfo { ResourceTypeId = fuelType, MaxRequiredInput = 0, RequiredInputFunc = () => RequiredFuelInput(ref fuelType) }; if (m_fuelTypes.Count == 1) { ResourceSink.Init(MyStringHash.GetOrCompute("Thrust"), sinkData); ResourceSink.IsPoweredChanged += Sink_IsPoweredChanged; ResourceSink.CurrentInputChanged += Sink_CurrentInputChanged; var cubeGrid = Container.Entity as MyCubeGrid; if (cubeGrid != null) { var gridSystems = cubeGrid.GridSystems; if (gridSystems != null) { if (gridSystems.ResourceDistributor != null) { gridSystems.ResourceDistributor.AddSink(ResourceSink); } } } } else { ResourceSink.AddType(ref sinkData); } return(typeIndex); }
public RadarPowerModule(MyRadar Radar) : base(Radar) { if (!RadarBlock.TryGetComponent(out MyRadarPowerSink)) { MyRadarPowerSink = new MyResourceSinkComponent(); MyResourceSinkInfo info = new MyResourceSinkInfo(); info.ResourceTypeId = Electricity; MyRadarPowerSink.AddType(ref info); RadarBlock.Components.Add(MyRadarPowerSink); } }
public void AppendSinkData(List <MyResourceSinkInfo> sinkData) { for (int i = 0; i < this.m_storedGases.Length; i++) { int captureIndex = i; MyResourceSinkInfo item = new MyResourceSinkInfo { ResourceTypeId = this.m_storedGases[i].Id, MaxRequiredInput = this.m_storedGases[i].Throughput, RequiredInputFunc = () => this.Sink_ComputeRequiredGas(this.m_storedGases[captureIndex]) }; sinkData.Add(item); } }
private void InitPowerSystem() { m_powerConsumption = MaxHeat * 0.001f; var powerSystem = new MyResourceSinkComponent(); var sinkInfo = new MyResourceSinkInfo(); sinkInfo.ResourceTypeId = m_electricityDefinition; sinkInfo.MaxRequiredInput = m_powerConsumption; sinkInfo.RequiredInputFunc = new Func <float>(RequiredInputFunc); powerSystem.AddType(ref sinkInfo); Entity.Components.Add <MyResourceSinkComponent>(powerSystem); m_resourceSink = Entity.Components.Get <MyResourceSinkComponent>(); }
public override void Close() { try { base.Close(); if (!_allInited) { return; } if (Session.Enforced.Debug >= 3) { Log.Line($"Close: {ShieldMode} - ShieldId [{Shield.EntityId}]"); } if (ShieldComp?.DefenseShields == this) { OfflineShield(true, false, true); ShieldComp.DefenseShields = null; } if (Session.Instance.Controllers.Contains(this)) { Session.Instance.Controllers.Remove(this); } bool value1; if (Session.Instance.FunctionalShields.ContainsKey(this)) { Session.Instance.FunctionalShields.TryRemove(this, out value1); } Icosphere = null; InitEntities(false); MyAPIGateway.Session.OxygenProviderSystem.RemoveOxygenGenerator(_ellipsoidOxyProvider); if (_sink != null) { _resourceInfo = new MyResourceSinkInfo { ResourceTypeId = GId, MaxRequiredInput = 0f, RequiredInputFunc = null }; _sink.Init(MyStringHash.GetOrCompute("Defense"), _resourceInfo); _sink = null; } ShieldComp = null; } catch (Exception ex) { Log.Line($"Exception in Close: {ex}"); } }
void SetPowerSink() { sink = Entity.Components.Get <MyResourceSinkComponent>(); sink.SetRequiredInputFuncByType(resourceId, () => GetPowerInput()); MyResourceSinkInfo resourceInfo = new MyResourceSinkInfo() { ResourceTypeId = resourceId, MaxRequiredInput = turret == null ? _idlePowerDrawBase : _idlePowerDrawMax, RequiredInputFunc = () => GetPowerInput() }; sink.RemoveType(ref resourceInfo.ResourceTypeId); sink.Init(MyStringHash.GetOrCompute("Defense"), resourceInfo); //sink.Init(MyStringHash.GetOrCompute("Defense"), turret == null ? _idlePowerDrawBase : _idlePowerDrawMax, () => GetPowerInput()); sink.AddType(ref resourceInfo); }
public override void Close() { try { base.Close(); if (Session.Enforced.Debug == 3) { Log.Line($"Close: {EmitterMode} - EmitterId [{Entity.EntityId}]"); } if (Session.Instance.Emitters.Contains(this)) { Session.Instance.Emitters.Remove(this); } if (ShieldComp?.StationEmitter == this) { if ((int)EmitterMode == ShieldComp.EmitterMode) { ShieldComp.EmitterLos = false; ShieldComp.EmitterEvent = true; } ShieldComp.StationEmitter = null; } else if (ShieldComp?.ShipEmitter == this) { if ((int)EmitterMode == ShieldComp.EmitterMode) { ShieldComp.EmitterLos = false; ShieldComp.EmitterEvent = true; } ShieldComp.ShipEmitter = null; } ShieldComp = null; if (Sink != null) { ResourceInfo = new MyResourceSinkInfo { ResourceTypeId = _gId, MaxRequiredInput = 0f, RequiredInputFunc = null }; Sink.Init(MyStringHash.GetOrCompute("Utility"), ResourceInfo); Sink = null; } } catch (Exception ex) { Log.Line($"Exception in Close: {ex}"); } }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.BEFORE_NEXT_FRAME; _objectBuilder = objectBuilder; hyperDriveBlock = Entity as IMyUpgradeModule; if (!hyperDriveBlock.Components.TryGet <MyResourceSinkComponent>(out ResourceSink)) { ResourceSink = new MyResourceSinkComponent(); var sinkInfo = new MyResourceSinkInfo(); sinkInfo.ResourceTypeId = _electricity; ResourceSink.AddType(ref sinkInfo); hyperDriveBlock.Components.Add(ResourceSink); } }
public void AddType(ref MyResourceSinkInfo sinkData) { var newDataPerType = new PerTypeData[m_dataPerType.Length + 1]; for (int dataIndex = 0; dataIndex < m_dataPerType.Length; ++dataIndex) { newDataPerType[dataIndex] = m_dataPerType[dataIndex]; } m_dataPerType = newDataPerType; m_dataPerType[m_dataPerType.Length - 1] = new PerTypeData { MaxRequiredInput = sinkData.MaxRequiredInput, RequiredInputFunc = sinkData.RequiredInputFunc }; m_resourceIds.Add(sinkData.ResourceTypeId); m_resourceTypeToIndex.Add(sinkData.ResourceTypeId, m_dataPerType.Length - 1); OnAddType(this); }
private void SinkSetup() { hydrogenSink = Entity.Components.Get <MyResourceSinkComponent>(); var maxHydrogenRequired = hydrogenSink.MaxRequiredInputByType(hydrogenDef); var maxOxygenRequired = maxHydrogenRequired / 2; sinkInfo = new MyResourceSinkInfo() { ResourceTypeId = oxygenDef, MaxRequiredInput = maxOxygenRequired, RequiredInputFunc = GetOxygenRequired }; sink = hydrogenSink; sink.AddType(ref sinkInfo); sink.Update(); }
private void PowerPreInit() { try { if (_sink == null) { _sink = new MyResourceSinkComponent(); } _resourceInfo = new MyResourceSinkInfo() { ResourceTypeId = GId, MaxRequiredInput = 0f, RequiredInputFunc = () => _power }; _sink.Init(MyStringHash.GetOrCompute("Defense"), _resourceInfo); _sink.AddType(ref _resourceInfo); Entity.Components.Add(_sink); } catch (Exception ex) { Log.Line($"Exception in PowerPreInit: {ex}"); } }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { if (_isInit) { return; } m_block = Container.Entity as IMyTerminalBlock; m_block.AppendingCustomInfo += appendCustomInfo; _imyUM = Entity as IMyUpgradeModule; if (!_imyUM.Components.TryGet(out _sink)) { _sink = new MyResourceSinkComponent(); MyResourceSinkInfo info = new MyResourceSinkInfo(); info.ResourceTypeId = Electricity; _sink.AddType(ref info); _imyUM.Components.Add(_sink); } this.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; // deprecated Container.Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; }
private PerTypeData Type(MyDefinitionId id) { PerTypeData res; if (!_sinks.TryGetValue(id, out res)) { _sinks.Add(id, res = new PerTypeData()); var root = _resourceSink.Value; if (root != null) { var info = new MyResourceSinkInfo() { MaxRequiredInput = res.CalculateMaxInput(), RequiredInputFunc = res.DelCalculateRequiredInput, ResourceTypeId = id }; root.AddType(ref info); } } return(res); }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { if (_isInit) { return; } Container.Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; _tblock = Container.Entity as IMyTerminalBlock; _tblock.AppendingCustomInfo += appendCustomInfo; _ublock = Entity as IMyUpgradeModule; _maxrange = 1000f; if (!_ublock.Components.TryGet(out _sink)) { _sink = new MyResourceSinkComponent(); MyResourceSinkInfo info = new MyResourceSinkInfo(); info.ResourceTypeId = Electricity; _sink.AddType(ref info); _ublock.Components.Add(_sink); } Shields.Add(Entity.EntityId, this); _isInit = true; }
public SubTankImpl(TankComponent tank, ISubTankDef def) { Tank = tank; StoresId = def.StoresId; Capacity = def.Capacity; MaxRate = def.MaxRate; Provide = def.Provide; Take = def.Take; Provide = def.Provide; sinkInfo = new MyResourceSinkInfo() { ResourceTypeId = StoresId, MaxRequiredInput = MaxRate, RequiredInputFunc = GetRequired }; sourceInfo = new MyResourceSourceInfo() { ResourceTypeId = StoresId, DefinedOutput = MaxRate }; }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { m_objectBuilder = objectBuilder; Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME | MyEntityUpdateEnum.EACH_FRAME; MyResourceSinkInfo ElectricityResourceSinkInfo = new MyResourceSinkInfo { ResourceTypeId = ElectricityDefinitionsId, MaxRequiredInput = MaxElectricityConsumption, RequiredInputFunc = OnUpdateElectricityUsage }; MyResourceSinkComponent ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init(MyStringHash.GetOrCompute("Factory"), ElectricityResourceSinkInfo); Entity.Components.Add <MyResourceSinkComponent>(ResourceSink); ResourceSink.Update(); m_resourceSink = ResourceSink; /* * // Because a Cargo Container does not produce anything, we need to create a new Resource Source for it and attach it to the block * MyResourceSourceComponent ResourceSource = new MyResourceSourceComponent(); * Entity.Components.Add<MyResourceSourceComponent>(ResourceSource); * * // We let it produce OxyHydrogen gas with a defined (changed by us later) maximum of 1200MW * MyResourceSourceInfo oxyHydrogenResourceSourceInfo = new MyResourceSourceInfo() {ResourceTypeId = ElectricityDefinitionsId, DefinedOutput = 0.0001f, IsInfiniteCapacity = true, ProductionToCapacityMultiplier = 60*60}; * ResourceSource.Init(MyStringHash.GetOrCompute("Battery"), oxyHydrogenResourceSourceInfo); * ResourceSource.SetMaxOutputByType(ElectricityDefinitionsId, 0.00005f); * ResourceSource.SetProductionEnabledByType(ElectricityDefinitionsId, true); * * m_resourceSource = ResourceSource; */ }
public override unsafe void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.SyncFlag = true; List <MyResourceSourceInfo> sourceResourceData = new List <MyResourceSourceInfo>(); foreach (MyOxygenGeneratorDefinition.MyGasGeneratorResourceInfo info in this.BlockDefinition.ProducedGases) { MyResourceSourceInfo *infoPtr1; MyResourceSourceInfo item = new MyResourceSourceInfo { ResourceTypeId = info.Id }; infoPtr1->DefinedOutput = (this.BlockDefinition.IceConsumptionPerSecond * info.IceToGasRatio) * (MySession.Static.CreativeMode ? 10f : 1f); infoPtr1 = (MyResourceSourceInfo *)ref item; item.ProductionToCapacityMultiplier = 1f; sourceResourceData.Add(item); } this.SourceComp.Init(this.BlockDefinition.ResourceSourceGroup, sourceResourceData); base.Init(objectBuilder, cubeGrid); MyObjectBuilder_OxygenGenerator generator = objectBuilder as MyObjectBuilder_OxygenGenerator; this.InitializeConveyorEndpoint(); this.m_useConveyorSystem.SetLocalValue(generator.UseConveyorSystem); base.NeedsUpdate |= MyEntityUpdateEnum.EACH_100TH_FRAME | MyEntityUpdateEnum.EACH_FRAME; MyInventory component = this.GetInventory(0); if (component != null) { component.Constraint = this.BlockDefinition.InputInventoryConstraint; } else { component = new MyInventory(this.BlockDefinition.InventoryMaxVolume, this.BlockDefinition.InventorySize, MyInventoryFlags.CanReceive) { Constraint = this.BlockDefinition.InputInventoryConstraint }; base.Components.Add <MyInventoryBase>(component); } this.m_oreConstraint = new MyInventoryConstraint(component.Constraint.Description, component.Constraint.Icon, component.Constraint.IsWhitelist); foreach (MyDefinitionId id in component.Constraint.ConstrainedIds) { if (id.TypeId != typeof(MyObjectBuilder_GasContainerObject)) { this.m_oreConstraint.Add(id); } } if (MyFakes.ENABLE_INVENTORY_FIX) { base.FixSingleInventory(); } if (component != null) { component.Init(generator.Inventory); } this.AutoRefill = generator.AutoRefill; this.SourceComp.Enabled = base.Enabled; if (Sync.IsServer) { this.SourceComp.OutputChanged += new MyResourceOutputChangedDelegate(this.Source_OutputChanged); } float num = this.IceAmount(); foreach (MyDefinitionId id2 in this.SourceComp.ResourceTypes) { MyDefinitionId gasId = id2; this.m_sourceComp.SetRemainingCapacityByType(id2, (float)this.IceToGas(ref gasId, (double)num)); } MyResourceSinkInfo sinkData = new MyResourceSinkInfo { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, MaxRequiredInput = this.BlockDefinition.OperationalPowerConsumption, RequiredInputFunc = new Func <float>(this.ComputeRequiredPower) }; base.ResourceSink.Init(this.BlockDefinition.ResourceSinkGroup, sinkData); base.ResourceSink.IsPoweredChanged += new Action(this.PowerReceiver_IsPoweredChanged); base.ResourceSink.Update(); this.UpdateText(); base.AddDebugRenderComponent(new MyDebugRenderComponentDrawConveyorEndpoint(this.m_conveyorEndpoint)); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.IsWorkingChanged += new Action <MyCubeBlock>(this.MyGasGenerator_IsWorkingChanged); }
public void Init(MyObjectBuilder_Battery builder, List <MyResourceSinkInfo> additionalSinks = null, List <MyResourceSourceInfo> additionalSources = null) { var defaultSinkInfo = new MyResourceSinkInfo { MaxRequiredInput = MyEnergyConstants.BATTERY_MAX_POWER_INPUT, ResourceTypeId = MyResourceDistributorComponent.ElectricityId, RequiredInputFunc = () => (ResourceSource.RemainingCapacity < MyEnergyConstants.BATTERY_MAX_CAPACITY) ? MyEnergyConstants.BATTERY_MAX_POWER_INPUT : 0f, }; if (additionalSinks != null) { additionalSinks.Insert(0, defaultSinkInfo); ResourceSink.Init(m_resourceSinkGroup, additionalSinks); } else { ResourceSink.Init(m_resourceSinkGroup, defaultSinkInfo); } ResourceSink.TemporaryConnectedEntity = m_owner; var defaultSourceInfo = new MyResourceSourceInfo { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, DefinedOutput = MyEnergyConstants.BATTERY_MAX_POWER_OUTPUT, // TODO: Load max output from definitions ProductionToCapacityMultiplier = 60 * 60 }; if (additionalSources != null) { additionalSources.Insert(0, defaultSourceInfo); ResourceSource.Init(m_resourceSourceGroup, additionalSources); } else { ResourceSource.Init(m_resourceSourceGroup, defaultSourceInfo); } ResourceSource.TemporaryConnectedEntity = m_owner; m_lastUpdateTime = MySession.Static.GameplayFrameCounter; if (builder == null) { ResourceSource.SetProductionEnabledByType(MyResourceDistributorComponent.ElectricityId, true); ResourceSource.SetRemainingCapacityByType(MyResourceDistributorComponent.ElectricityId, MyEnergyConstants.BATTERY_MAX_CAPACITY); ResourceSink.Update(); return; } ResourceSource.SetProductionEnabledByType(MyResourceDistributorComponent.ElectricityId, builder.ProducerEnabled); if (MySession.Static.SurvivalMode) { ResourceSource.SetRemainingCapacityByType(MyResourceDistributorComponent.ElectricityId, MathHelper.Clamp(builder.CurrentCapacity, 0f, MyEnergyConstants.BATTERY_MAX_CAPACITY)); } else { ResourceSource.SetRemainingCapacityByType(MyResourceDistributorComponent.ElectricityId, MyEnergyConstants.BATTERY_MAX_CAPACITY); } ResourceSink.Update(); }
private void FillSinkInfo() { OxygenSinkInfo = new MyResourceSinkInfo { ResourceTypeId = m_oxygenGasId, MaxRequiredInput = BlockDefinition.VentilationCapacityPerSecond, RequiredInputFunc = Sink_ComputeRequiredGas }; }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.SyncFlag = true; base.Init(objectBuilder, cubeGrid); MyObjectBuilder_OxygenTank tank = (MyObjectBuilder_OxygenTank)objectBuilder; this.InitializeConveyorEndpoint(); if (Sync.IsServer) { base.NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_FRAME; } if (MyFakes.ENABLE_INVENTORY_FIX) { base.FixSingleInventory(); if (this.GetInventory(0) != null) { this.GetInventory(0).Constraint = this.BlockDefinition.InputInventoryConstraint; } } MyInventory component = this.GetInventory(0); if (component == null) { component = new MyInventory(this.BlockDefinition.InventoryMaxVolume, this.BlockDefinition.InventorySize, MyInventoryFlags.CanReceive) { Constraint = this.BlockDefinition.InputInventoryConstraint }; base.Components.Add <MyInventoryBase>(component); component.Init(tank.Inventory); } component.ContentsChanged += new Action <MyInventoryBase>(this.MyGasTank_ContentsChanged); this.m_autoRefill.SetLocalValue(tank.AutoRefill); MyResourceSourceInfo item = new MyResourceSourceInfo { ResourceTypeId = this.BlockDefinition.StoredGasId, DefinedOutput = 0.05f * this.BlockDefinition.Capacity }; List <MyResourceSourceInfo> list1 = new List <MyResourceSourceInfo>(); list1.Add(item); List <MyResourceSourceInfo> sourceResourceData = list1; this.SourceComp.Init(this.BlockDefinition.ResourceSourceGroup, sourceResourceData); this.SourceComp.OutputChanged += new MyResourceOutputChangedDelegate(this.Source_OutputChanged); this.SourceComp.Enabled = base.Enabled; this.IsStockpiling = tank.IsStockpiling; MyResourceSinkInfo info2 = new MyResourceSinkInfo { ResourceTypeId = MyResourceDistributorComponent.ElectricityId, MaxRequiredInput = this.BlockDefinition.OperationalPowerConsumption, RequiredInputFunc = new Func <float>(this.ComputeRequiredPower) }; List <MyResourceSinkInfo> list3 = new List <MyResourceSinkInfo>(); list3.Add(info2); info2 = new MyResourceSinkInfo { ResourceTypeId = this.BlockDefinition.StoredGasId, MaxRequiredInput = this.Capacity, RequiredInputFunc = new Func <float>(this.ComputeRequiredGas) }; list3.Add(info2); List <MyResourceSinkInfo> sinkData = list3; base.ResourceSink.Init(this.BlockDefinition.ResourceSinkGroup, sinkData); base.ResourceSink.IsPoweredChanged += new Action(this.PowerReceiver_IsPoweredChanged); base.ResourceSink.CurrentInputChanged += new MyCurrentResourceInputChangedDelegate(this.Sink_CurrentInputChanged); float filledRatio = tank.FilledRatio; if (MySession.Static.CreativeMode && (filledRatio == 0f)) { filledRatio = 0.5f; } this.ChangeFilledRatio((double)MathHelper.Clamp(filledRatio, 0f, 1f), false); base.ResourceSink.Update(); base.AddDebugRenderComponent(new MyDebugRenderComponentDrawConveyorEndpoint(this.m_conveyorEndpoint)); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.IsWorkingChanged += new Action <MyCubeBlock>(this.MyOxygenTank_IsWorkingChanged); }