public override void Init(MyObjectBuilder_EntityBase objectBuilder) { Block = (IMyFunctionalBlock)Entity; if (MyAPIGateway.Session.IsServer) { Block.AppendingCustomInfo += Block_AppendingCustomInfo; Block.AddUpgradeValue("Radiators", 0); Block.OnUpgradeValuesChanged += OnUpgradeValuesChanged; InitPowerSystem(); sink.Update(); if (WarpDriveSession.Instance != null) { initStart = WarpDriveSession.Instance.Runtime; } NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME; } else { } }
protected void doSetup(string powerPriority, float smallGridMW, float largeGridMW, params MyEntityUpdateEnum[] updateCycles) { NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; if (updateCycles.Length == 0) { IO.log("WARNING: " + this + " has no update cycles set!"); } foreach (MyEntityUpdateEnum e in updateCycles) { NeedsUpdate |= e; Entity.NeedsUpdate |= e; } thisBlock = Container.Entity as IMyFunctionalBlock; thisGrid = thisBlock.CubeGrid as IMyCubeGrid; //thisBlock.Enabled = false; //causes it to turn off every time you load the game //Sandbox.ModAPI.Ingame.TerminalBlockExtentions.ApplyAction(thisBlock, "OnOff_Off"); energySink = new MyResourceSinkComponent(1); energySink.Init(MyStringHash.GetOrCompute(powerPriority), thisGrid.GridSizeEnum == MyCubeSize.Small ? smallGridMW : largeGridMW, calcRequiredPower, (MyCubeBlock)thisBlock); if (thisBlock.Components.Contains(typeof(MyResourceSinkComponent))) { IO.log("Power sinks already present in " + this + " #" + Entity.EntityId + ":"); List <MyResourceSinkComponent> li = new List <MyResourceSinkComponent>(); Dictionary <Type, MyComponentBase> .ValueCollection.Enumerator e = thisBlock.Components.GetEnumerator(); while (e.MoveNext()) { if (e.Current is MyResourceSinkComponent) { MyResourceSinkComponent req = e.Current as MyResourceSinkComponent; IO.log(">> " + req.GetType() + " needing " + req.MaxRequiredInput + ", of " + req.AcceptedResources.ToString()); } } thisBlock.Components.Remove <MyResourceSinkComponent>(); } thisBlock.Components.Add(energySink); energySink.Update(); thisBlock.IsWorkingChanged += onWorkingChanged; thisBlock.AppendingCustomInfo += updateInfo; MyAPIGateway.TerminalControls.CustomControlGetter += filterControls; soundSource = new MultiSoundSource(thisBlock); IO.log("Loaded logic script " + this + " for block '" + thisBlock.CustomName + "' / '" + Entity.DisplayName + "' #" + Entity.EntityId + "; update rate = " + NeedsUpdate); }
public override void UpdateBeforeSimulation() { if (IsWorking()) { if (_range < _maxrange && _count == 30) { _range += (_maxrange / 20f); _tblock.SetEmissiveParts("Emissive0", Color.Green, (_range / _maxrange)); } else { _tblock.SetEmissiveParts("Emissive0", Color.Green, 1.0f); } if (!MyAPIGateway.Utilities.IsDedicated) { showRange(_range); } else { sendPoke(_range); } if (_count++ == 60) { gridEffects(); } } else if (_wasOn) { _tblock.SetEmissiveParts("Emissive0", Color.DarkRed, 0.20f); _range = 0f; } if (IsWorking() != _wasOn && _ublock.Components.TryGet(out _sink)) { _sink.Update(); _tblock.RefreshCustomInfo(); _wasOn = IsWorking(); } }
public void shieldStuff() { try { points = TeaShieldBase.recharge(fBlock, max, fBlock.Enabled && sink.IsPowerAvailable(electricity, powerCalc())); sink.Update(); if (!fBlock.Enabled || !fBlock.IsFunctional || !sink.IsPowerAvailable(electricity, powerCalc())) { for (int i = 1; i < 9; i++) { sbBlock.SetEmissiveParts("Emissive" + i, Color.Red, i == 6 ? 1f : 0f); } } else { sbBlock.SetEmissiveParts("Emissive7", Color.Yellow, 0.25f); sbBlock.SetEmissiveParts("Emissive8", Color.White, 1f); var perc = points / max; var blinkCalc = (int)(perc * 5) + 1; if (perc < 0.99f) { if (++chargeBlink > blinkCalc) { chargeBlink = 0; blink = !blink; for (int i = 1; i < 5; i++) { sbBlock.SetEmissiveParts("Emissive" + i, colour(perc), i == lx ? 1f : 0f); } lx = lx == 4 ? 1 : lx + 1; } sbBlock.SetEmissiveParts("Emissive5", colour(perc), blink ? (1.3f - perc) : 0.1f); sbBlock.SetEmissiveParts("Emissive6", perc < 0.9f ? Color.Cyan : Color.Green, 1f); } else { for (int i = 1; i < 7; i++) { sbBlock.SetEmissiveParts("Emissive" + i, Color.Green, 1f); } } } fBlock.RefreshCustomInfo(); } catch (Exception ex) { Echo("IAShields threw exception", ex.ToString()); } }
public void PlugIn(MyResourceSinkComponent consumer) { if (m_pluggedInConsumer == consumer) { return; } Debug.Assert(m_pluggedInConsumer == null, "Consumer already plugged in."); m_pluggedInConsumer = consumer; if (m_resourceDistributor != null) { m_resourceDistributor.AddSink(consumer); consumer.Update(); } }
public void InitResourceSink() { try { MyRadarPowerSink.SetMaxRequiredInputByType(Electricity, 100); MyRadarPowerSink.SetRequiredInputFuncByType(Electricity, PowerConsumptionFunc); MyRadarPowerSink.SetRequiredInputByType(Electricity, PowerConsumptionFunc()); MyRadarPowerSink.Update(); } catch (Exception Scrap) { RadarCore.LogError(RadarBlock.CustomName, Scrap); } }
protected void doSetup(string powerPriority, float maxPowerInMW, params MyEntityUpdateEnum[] updateCycles) { NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.EACH_10TH_FRAME; NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; Entity.NeedsUpdate |= MyEntityUpdateEnum.BEFORE_NEXT_FRAME; if (updateCycles.Length == 0) { IO.log("WARNING: " + this + " has no update cycles set!"); } foreach (MyEntityUpdateEnum e in updateCycles) { NeedsUpdate |= e; Entity.NeedsUpdate |= e; } thisBlock = Container.Entity as IMyFunctionalBlock; thisGrid = thisBlock.CubeGrid as IMyCubeGrid; energySink = new MyResourceSinkComponent(1); energySink.Init(MyStringHash.GetOrCompute(powerPriority), maxPowerInMW, calcRequiredPower, (MyCubeBlock)thisBlock); if (thisBlock.Components.Contains(typeof(MyResourceSinkComponent))) { IO.log("Power sinks already present in " + this + " #" + Entity.EntityId + ":"); List <MyResourceSinkComponent> li = new List <MyResourceSinkComponent>(); Dictionary <Type, MyComponentBase> .ValueCollection.Enumerator e = thisBlock.Components.GetEnumerator(); while (e.MoveNext()) { if (e.Current is MyResourceSinkComponent) { MyResourceSinkComponent req = e.Current as MyResourceSinkComponent; IO.log(">> " + req.GetType() + " needing " + req.MaxRequiredInput + ", of " + req.AcceptedResources.ToString()); } } thisBlock.Components.Remove <MyResourceSinkComponent>(); } thisBlock.Components.Add(energySink); energySink.Update(); thisBlock.IsWorkingChanged += onWorkingChanged; thisBlock.AppendingCustomInfo += updateInfo; soundSource = new MultiSoundSource(thisBlock); IO.log("Loaded logic script " + this + " for block '" + thisBlock.CustomName + "' / '" + Entity.DisplayName + "' #" + Entity.EntityId + "; update rate = " + NeedsUpdate); }
public void SetPower(bool Working = false) { var powerRequired = GetPowerRequired(); if (Working) { sink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerRequired); // In MW sink.SetMaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerRequired); // In MW } else { sink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, Power); // In MW sink.SetMaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId, Power); // In MW } sink.Update(); }
internal void UpdatePowerAndThrustStrength(Vector3 thrust, bool updateThrust) { //if ((Container.Entity.Physics as Sandbox.Engine.Physics.MyPhysicsBody).IsWelded) // thrust = Vector3.TransformNormal(thrust, (Container.Entity.Physics as Sandbox.Engine.Physics.MyPhysicsBody).WeldInfo.Transform); // Calculate ratio of usage for different directions. Vector3 thrustPositive = thrust / (m_maxPositiveThrust + 0.0000001f); Vector3 thrustNegative = -thrust / (m_maxNegativeThrust + 0.0000001f); thrustPositive = Vector3.Clamp(thrustPositive, Vector3.Zero, Vector3.One); thrustNegative = Vector3.Clamp(thrustNegative, Vector3.Zero, Vector3.One); foreach (var fuelKey in m_fuelTypeToIndex.Keys) { float requiredPower = 0f; var fuelType = fuelKey; if (Enabled) { int typeIndex = GetTypeIndex(ref fuelType); requiredPower += (thrustPositive.X > 0) ? thrustPositive.X * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Left) : 0; requiredPower += (thrustPositive.Y > 0) ? thrustPositive.Y * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Down) : 0; requiredPower += (thrustPositive.Z > 0) ? thrustPositive.Z * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Forward) : 0; requiredPower += (thrustNegative.X > 0) ? thrustNegative.X * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Right) : 0; requiredPower += (thrustNegative.Y > 0) ? thrustNegative.Y * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Up) : 0; requiredPower += (thrustNegative.Z > 0) ? thrustNegative.Z * GetMaxPowerRequirement(ref fuelType, ref Vector3I.Backward) : 0; requiredPower += m_totalThrustOverridePower; requiredPower = Math.Max(requiredPower, m_dataByFuelType[typeIndex].MinRequiredPowerInput); } SetRequiredFuelInput(ref fuelType, PowerAmountToFuel(ref fuelType, requiredPower)); } ResourceSink.Update(); ProfilerShort.Begin("Update thrust strengths"); if (updateThrust) { foreach (var dataByType in m_dataByFuelType) { UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Left], thrustPositive.X); UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Down], thrustPositive.Y); UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Forward], thrustPositive.Z); UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Right], thrustNegative.X); UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Up], thrustNegative.Y); UpdateThrustStrength(dataByType.ThrustsByDirection[Vector3I.Backward], thrustNegative.Z); } } ProfilerShort.End(); }
public MyGridConveyorSystem(MyCubeGrid grid) { m_grid = grid; m_lineEndpoints = null; m_linePoints = null; m_deserializedLines = null; ResourceSink = new MyResourceSinkComponent(); ResourceSink.Init( MyStringHash.GetOrCompute("Conveyors"), CONVEYOR_SYSTEM_CONSUMPTION, CalculateConsumption); ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink.Update(); }
public void UpdatePowerUsage(float new_power) { if (power_usage == new_power) { return; } power_ratio_available = 1.0f; engine_sound.CustomVolume = (float)(1.0 + new_power * 10); // 100KW = 100% volume if (new_power > MAX_POWER_USAGE_MW) { power_ratio_available = MAX_POWER_USAGE_MW / new_power; new_power = MAX_POWER_USAGE_MW; } // MyLog.Default.WriteLine(String.Format("set power to {0}", new_power)); power_usage = new_power; sinkComp.Update(); }
// Context: All public override void UpdateOnceBeforeFrame() { if (me.CubeGrid?.Physics == null) { return; } _state = new SyncableProjectorState(me, ProjectorState.Idle, 0); if (Constants.IsServer) { LoadStorage(); _settings.OnValueReceived += SaveStorage; BuildState = ProjectorState.Idle; me.IsWorkingChanged += Me_IsWorkingChanged; } else { _settings = new SyncableProjectorSettings(me, 0, true); _state.RequestFromServer(); _settings.RequestFromServer(); _state.OnValueReceived += ReceivedNewState; } MyProjectorDefinition def = (MyProjectorDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(me.BlockDefinition); minPower = def.RequiredPowerInput; sink = me.Components.Get <MyResourceSinkComponent>(); MyDefinitionId powerDef = MyResourceDistributorComponent.ElectricityId; sink.SetRequiredInputFuncByType(powerDef, GetCurrentPower); sink.Update(); _settings.OnValueReceived += RefreshUI; me.AppendingCustomInfo += CustomInfo; me.RefreshCustomInfo(); Settings.MapSettings config = IPSession.Instance.MapSettings; config.OnSubgridsChanged += ClearCachedComps; config.OnComponentCostModifierChanged += ClearCachedComps; config.OnExtraComponentChanged += ClearCachedComps; config.OnExtraCompCostChanged += ClearCachedComps; ProjectorControls.Create(); }
public override void UpdateOnceBeforeFrame() { try { _sink = _sink ?? Entity.Components.Get <MyResourceSinkComponent>(); if (_sink != null) { _sink.SetRequiredInputFuncByType(MyResourceDistributorComponent.ElectricityId, CalculateRequiredPowerInput); _sink.Update(); } } catch (Exception e) { MyAPIGateway.Utilities.ShowNotification("[ Error in " + GetType().FullName + ": " + e.Message + " ]", 10000, MyFontEnum.Red); MyLog.Default.WriteLine(e); } }
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(); }
// Context: Client private void ReceivedNewState() { if (_state.BuildState == State.Waiting || _state.BuildState == State.Building) { buildPower = GetPower(); } if (_state.BuildState == State.Waiting) { NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME; } else { Timer = 0; NeedsUpdate = MyEntityUpdateEnum.NONE; me.RefreshCustomInfo(); } sink.Update(); RefreshUI(); }
private void RecomputeWheelParameters() { m_wheelsChanged = false; float oldRequirement = m_maxRequiredPowerInput; m_maxRequiredPowerInput = 0.0f; foreach (var motor in m_wheels) { if (!IsUsed(motor)) { continue; } m_maxRequiredPowerInput += motor.RequiredPowerInput; } SinkComp.MaxRequiredInput = m_maxRequiredPowerInput; SinkComp.Update(); }
private void RecomputeWheelParameters() { m_wheelsChanged = false; float oldRequirement = m_maxRequiredPowerInput; m_maxRequiredPowerInput = 0.0f; foreach (var motor in m_wheels) { if (!IsUsed(motor)) { continue; } m_maxRequiredPowerInput += motor.RequiredPowerInput; } SinkComp.SetMaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId, m_maxRequiredPowerInput); SinkComp.Update(); }
public override void UpdateBeforeSimulation10() { m_sink.Update(); if (IsWorking()) { m_firewall.SetEmissiveParts(Emissive1, Color.Green, 1f); if (blockIndicatorCountdown > 0) { blockIndicatorCountdown--; m_firewall.SetEmissiveParts(Emissive2, Color.Cyan, 1f); } else { if (blockIndicatorCountdown > 0) { blockIndicatorCountdown--; } if (BlockedAttempts > 0 && blockIndicatorCountdown <= 0) { m_firewall.SetEmissiveParts(Emissive2, Color.OrangeRed, 1f); if (BlockedAttempts > 5) { BlockedAttempts = 5; } blockIndicatorCountdown = Math.Max(1, (int)Math.Ceiling(10f / (2f * BlockedAttempts))); BlockedAttempts--; } else { m_firewall.SetEmissiveParts(Emissive2, Color.Cyan, 1f); } } } else { m_firewall.SetEmissiveParts(Emissive1, Color.Red, 1f); m_firewall.SetEmissiveParts(Emissive2, Color.Red, 1f); } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { SyncFlag = true; var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup), BlockDefinition.RequiredPowerInput, CalculateRequiredPowerInput); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.RequiredInputChanged += Receiver_RequiredInputChanged; ResourceSink = sinkComp; base.Init(objectBuilder, cubeGrid); NeedsUpdate = MyEntityUpdateEnum.EACH_FRAME | MyEntityUpdateEnum.EACH_10TH_FRAME; sinkComp.Update(); var ob = objectBuilder as MyObjectBuilder_CameraBlock; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; IsWorkingChanged += MyCameraBlock_IsWorkingChanged; IsInFirstPersonView = true; if (ob.IsActive) { m_requestActivateAfterLoad = true; ob.IsActive = false; } OnChangeFov(ob.Fov); UpdateText(); }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { MyResourceSinkComponent component = new MyResourceSinkComponent(1); component.Init(this.BlockDefinition.ResourceSinkGroup, this.BlockDefinition.PowerConsumptionMoving, new Func <float>(this.UpdatePowerInput)); base.ResourceSink = component; base.Init(builder, cubeGrid); MyObjectBuilder_AdvancedDoor door = (MyObjectBuilder_AdvancedDoor)builder; base.m_open.SetLocalValue(door.Open); component.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); component.Update(); if (!base.Enabled || !base.ResourceSink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId)) { this.UpdateDoorPosition(); } this.OnStateChange(); if (base.m_open != null) { this.UpdateDoorPosition(); } base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); base.ResourceSink.Update(); }
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 void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { var doorDefinition = BlockDefinition as MyDoorDefinition; MyStringHash resourceSinkGroup; if (doorDefinition != null) { MaxOpen = doorDefinition.MaxOpen; m_openSound = new MySoundPair(doorDefinition.OpenSound); m_closeSound = new MySoundPair(doorDefinition.CloseSound); resourceSinkGroup = MyStringHash.GetOrCompute(doorDefinition.ResourceSinkGroup); } else { MaxOpen = 1.2f; m_openSound = new MySoundPair("BlockDoorSmallOpen"); m_closeSound = new MySoundPair("BlockDoorSmallClose"); resourceSinkGroup = MyStringHash.GetOrCompute("Doors"); } var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_DOOR, () => (Enabled && IsFunctional) ? sinkComp.MaxRequiredInput : 0f); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; ResourceSink = sinkComp; base.Init(builder, cubeGrid); //m_subpartsSize = 0.5f * (0.5f * SlimBlock.CubeGrid.GridSize - 0.3f); var ob = (MyObjectBuilder_Door)builder; m_open.Value = ob.State; if (ob.Opening == -1) { m_currOpening = IsFunctional ? 0 : MaxOpen; m_open.Value = !IsFunctional; } else { m_currOpening = ob.Opening; } if (!Enabled || !ResourceSink.IsPowered) { UpdateSlidingDoorsPosition(true); } OnStateChange(); if (m_open) { // required when reinitializing a door after the armor beneath it is destroyed if (Open && (m_currOpening == MaxOpen)) { UpdateSlidingDoorsPosition(true); } } sinkComp.Update(); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; }
private void UpdatePower() { if (!m_block.Enabled || !m_block.IsFunctional) { MyAPIGateway.Utilities.InvokeOnGameThread(() => { Sink.Update(); return; }); } float upgradeRangeAddition = 0f; float upgradeRangeMultiplicator = 1; float rangeToAdd = NaniteConstructionManager.Settings != null ? NaniteConstructionManager.Settings.OreDetectorRangePerUpgrade : RANGE_PER_UPGRADE; for (int i = 1; i <= (int)m_block.UpgradeValues["Range"]; i++) { upgradeRangeAddition += rangeToAdd; if (upgradeRangeMultiplicator == 1f) { upgradeRangeMultiplicator = 0.7f; } else if (upgradeRangeMultiplicator > 0f) { upgradeRangeMultiplicator -= 0.1f; } } _maxRange = minRange + upgradeRangeAddition; if (Range > _maxRange) { Range = _maxRange; } float powerPerRange = NaniteConstructionManager.Settings != null ? NaniteConstructionManager.Settings.OreDetectorPowerIncreasePerRangeUpgrade : POWER_PER_RANGE_UPGRADE; float powerPerFilter = NaniteConstructionManager.Settings != null ? NaniteConstructionManager.Settings.OreDetectorPowerIncreasePerFilterUpgrade : POWER_PER_FILTER_UPGRADE; float powerPerScanning = NaniteConstructionManager.Settings != null ? NaniteConstructionManager.Settings.OreDetectorPowerPercentIncreasedPerScanningUpgrade : POWER_PER_SCANNING_UPGRADE; float powerPerEfficiency = NaniteConstructionManager.Settings != null ? NaniteConstructionManager.Settings.OreDetectorPowerPercentReducedPerEfficiencyUpgrade : POWER_PER_POWEREFFICIENCY_UPGRADE; _power = basePower; _power += m_block.UpgradeValues["Range"] * powerPerRange; _power += m_block.UpgradeValues["Filter"] * powerPerFilter; _power *= 1 + (m_block.UpgradeValues["Scanning"] * powerPerScanning); _power *= 1 - (m_block.UpgradeValues["PowerEfficiency"] * powerPerEfficiency); if (NaniteConstructionManager.Settings != null) { _power *= NaniteConstructionManager.Settings.OreDetectorPowerMultiplicator; } MyAPIGateway.Utilities.InvokeOnGameThread(() => { Sink.Update(); }); Logging.Instance.WriteLine($"Updated Nanite Ore Detector power {_power}", 1); }
protected virtual void onWorkingChanged(IMyCubeBlock block) { energySink.Update(); }
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid) { MyStringHash orCompute; this.m_physicsInitiated = false; MyDoorDefinition blockDefinition = base.BlockDefinition as MyDoorDefinition; if (blockDefinition != null) { this.MaxOpen = blockDefinition.MaxOpen; this.m_openSound = new MySoundPair(blockDefinition.OpenSound, true); this.m_closeSound = new MySoundPair(blockDefinition.CloseSound, true); orCompute = MyStringHash.GetOrCompute(blockDefinition.ResourceSinkGroup); this.m_openingSpeed = blockDefinition.OpeningSpeed; } else { this.MaxOpen = 1.2f; this.m_openSound = new MySoundPair("BlockDoorSmallOpen", true); this.m_closeSound = new MySoundPair("BlockDoorSmallClose", true); orCompute = MyStringHash.GetOrCompute("Doors"); this.m_openingSpeed = 1f; } MyResourceSinkComponent sinkComp = new MyResourceSinkComponent(1); sinkComp.Init(orCompute, 3E-05f, delegate { if (!this.Enabled || !this.IsFunctional) { return(0f); } return(sinkComp.MaxRequiredInputByType(MyResourceDistributorComponent.ElectricityId)); }); sinkComp.IsPoweredChanged += new Action(this.Receiver_IsPoweredChanged); base.ResourceSink = sinkComp; base.Init(builder, cubeGrid); base.NeedsWorldMatrix = false; MyObjectBuilder_Door door = (MyObjectBuilder_Door)builder; base.m_open.SetLocalValue(door.State); if (door.Opening != -1f) { this.m_currOpening = MathHelper.Clamp(door.Opening, 0f, this.MaxOpen); } else { this.m_currOpening = base.IsFunctional ? 0f : this.MaxOpen; base.m_open.SetLocalValue(!base.IsFunctional); } if (!base.Enabled || !base.ResourceSink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId)) { this.UpdateSlidingDoorsPosition(); } this.OnStateChange(); if (((base.m_open != null) && base.Open) && (this.m_currOpening == this.MaxOpen)) { this.UpdateSlidingDoorsPosition(); } sinkComp.Update(); base.SlimBlock.ComponentStack.IsFunctionalChanged += new Action(this.ComponentStack_IsFunctionalChanged); if (!Sync.IsServer) { base.NeedsWorldMatrix = true; } }
public override void UpdateAfterSimulation100() { if (!MyAPIGateway.Multiplayer.IsServer) { return; } try { m_sink.Update(); if (!IsWorking() || m_hackingblock.OwnerId == 0) { CurrentState = States.Off; } else { List <IMySlimBlock> blocks = new List <IMySlimBlock>(); (m_hackingblock.CubeGrid as IMyCubeGrid).GetBlocks(blocks, isValidHackingTarget); if (blocks.Count > 0) { int targetIndex = m_random.Next(blocks.Count); for (int i = 0; i < blocks.Count; i++) { if (blocks[i].GetObjectBuilder().GetId().SubtypeName == "LargeFirewallBlock") { FirewallBlock firewall = blocks[i].FatBlock.GameLogic.GetAs <FirewallBlock>(); if (firewall == null) { LogManager.WriteLine("Firewall Has No Firewall Component"); } else if (firewall.IsWorking()) { targetIndex = i; } } } IMySlimBlock block = blocks[targetIndex]; Chance = getComputerCount(block); TargetId = block.FatBlock.EntityId; if (m_random.Next() % Chance == 0) { (block.FatBlock as MyCubeBlock).ChangeOwner(0, MyOwnershipShareModeEnum.Faction); (block.FatBlock as MyCubeBlock).ChangeBlockOwnerRequest(m_hackingblock.OwnerId, MyOwnershipShareModeEnum.Faction); // Success CurrentState = States.Success; } else { // Failure CurrentState = States.Hacking; } } else { // No Enemies TargetId = 0L; CurrentState = States.NoEnemies; } } } catch (Exception e) { LogManager.WriteException(e); } HackingComputerSync.SendHackingBlockStates(this); }
public override void UpdateBeforeSimulation() { base.UpdateBeforeSimulation(); try { if (cube?.CubeGrid?.Physics == null) //ignore ghost grids { return; } if (MyAPIGateway.Multiplayer.IsServer) { Vector3D direction; Vector3D origin; _currentShootTime = GetLastShootTime(); //fire weapon if (_currentShootTime != _lastShootTime && !_firstUpdate) { if (Entity is IMyLargeTurretBase) { Vector3D.CreateFromAzimuthAndElevation(turret.Azimuth, turret.Elevation, out direction); direction = Vector3D.TransformNormal(direction, turret.WorldMatrix); origin = turret.WorldMatrix.Translation + turret.WorldMatrix.Up * 1.75 + direction * 0.5; } else { direction = block.WorldMatrix.Forward; origin = block.WorldMatrix.Translation + direction * -2.5; //for cushion } var velocity = block.CubeGrid.Physics.LinearVelocity; //var projectile = new ArmorPiercingProjectileSimulation(origin, direction, velocity, this._desiredSpeed, this._maxTrajectory, 0f, 0f, _projectileDamage, 50f, Entity.EntityId, _trailColor, _trailScale, true, true, true); var fireData = new RailgunFireData() { ShooterVelocity = velocity, Origin = origin, Direction = direction, ShooterID = Entity.EntityId }; RailgunCore.ShootProjectileServer(fireData); //RailgunCore.AddProjectile(projectile); _isReloading = true; _currentReloadTicks = 0; //Apply recoil force var centerOfMass = block.CubeGrid.Physics.CenterOfMassWorld; var forceVector = -direction * _backkickForce; block.CubeGrid.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE, forceVector, block.GetPosition(), null); //MyAPIGateway.Utilities.ShowNotification("Shot", 3000); } _lastShootTime = _currentShootTime; sink.Update(); _firstUpdate = false; } ShowReloadMessage(); //MyAPIGateway.Utilities.ShowNotification($"Power draw: {GetPowerInput(false):n0} MW | reloading?: {_isReloading} | max: {sink.MaxRequiredInputByType(resourceId)} | current ticks {_currentReloadTicks}", 16, MyFontEnum.Blue); } catch (Exception e) { MyAPIGateway.Utilities.ShowNotification("Exception in update", 16, MyFontEnum.Red); MyLog.Default.WriteLine(e); } }
// Context: All public override void UpdateOnceBeforeFrame() { if (me.CubeGrid?.Physics == null) { return; } _state = new SyncableProjectorState(me, State.Idle, 0); if (Constants.IsServer) { LoadStorage(); _settings.OnValueReceived += SaveStorage; BuildState = State.Idle; me.IsWorkingChanged += Me_IsWorkingChanged; } else { _settings = new SyncableProjectorSettings(me, 0, true); _state.RequestFromServer(); _settings.RequestFromServer(); _state.OnValueReceived += ReceivedNewState; } MyProjectorDefinition def = (MyProjectorDefinition)MyDefinitionManager.Static.GetCubeBlockDefinition(me.BlockDefinition); minPower = def.RequiredPowerInput; sink = me.Components.Get <MyResourceSinkComponent>(); MyDefinitionId powerDef = MyResourceDistributorComponent.ElectricityId; sink.SetRequiredInputFuncByType(powerDef, GetCurrentPower); sink.Update(); _settings.OnValueReceived += RefreshUI; me.AppendingCustomInfo += CustomInfo; me.RefreshCustomInfo(); Settings.MapSettings config = IPSession.Instance.MapSettings; config.OnSubgridsChanged += ClearCachedComps; config.OnComponentCostModifierChanged += ClearCachedComps; config.OnExtraComponentChanged += ClearCachedComps; config.OnExtraCompCostChanged += ClearCachedComps; if (!controls) { // Terminal controls IMyTerminalControlSeparator sep = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlSeparator, IMyProjector>("BuildGridSep"); sep.Enabled = IsValid; sep.Visible = IsValid; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(sep); IMyTerminalControlButton btnBuild = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlButton, IMyProjector>("BuildGrid"); btnBuild.Enabled = IsWorking; btnBuild.Visible = IsValid; btnBuild.SupportsMultipleBlocks = true; btnBuild.Title = MyStringId.GetOrCompute("Build Grid"); btnBuild.Action = BuildClient; btnBuild.Tooltip = MyStringId.GetOrCompute("Builds the projection instantly.\nThere will be a cooldown after building."); MyAPIGateway.TerminalControls.AddControl <IMyProjector>(btnBuild); IMyTerminalControlButton btnCancel = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlButton, IMyProjector>("CancelBuildGrid"); btnCancel.Enabled = IsWorking; btnCancel.Visible = IsValid; btnCancel.SupportsMultipleBlocks = true; btnCancel.Title = MyStringId.GetOrCompute("Cancel"); btnCancel.Action = CancelClient; btnCancel.Tooltip = MyStringId.GetOrCompute("Cancels the build process."); MyAPIGateway.TerminalControls.AddControl <IMyProjector>(btnCancel); IMyTerminalControlCheckbox chkShift = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlCheckbox, IMyProjector>("MoveProjectionArea"); chkShift.Enabled = IsWorking; chkShift.Visible = IsValid; chkShift.SupportsMultipleBlocks = true; chkShift.Title = MyStringId.GetOrCompute("Loose Projection Area"); chkShift.OnText = MyStringId.GetOrCompute("On"); chkShift.OffText = MyStringId.GetOrCompute("Off"); chkShift.Tooltip = MyStringId.GetOrCompute("Allow the projection to spawn in a different area if the original area is occupied."); chkShift.Setter = SetLooseArea; chkShift.Getter = GetLooseArea; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(chkShift); IMyTerminalControlSlider sliderSpeed = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlSlider, IMyProjector>("BuildSpeed"); sliderSpeed.Enabled = IsWorking; sliderSpeed.Visible = IsValid; sliderSpeed.SupportsMultipleBlocks = true; sliderSpeed.Title = MyStringId.GetOrCompute("Speed"); sliderSpeed.Tooltip = MyStringId.GetOrCompute("Increasing the speed will use more energy."); sliderSpeed.SetLogLimits(Constants.minSpeed, Constants.maxSpeed); sliderSpeed.Writer = GetSpeedText; sliderSpeed.Getter = GetSpeed; sliderSpeed.Setter = SetSpeed; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(sliderSpeed); IMyTerminalControlTextbox txtTimeout = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlTextbox, IMyProjector>("GridTimer"); txtTimeout.Enabled = (b) => false; txtTimeout.Visible = IsValid; txtTimeout.Getter = GetTimer; txtTimeout.Setter = (b, s) => { }; txtTimeout.SupportsMultipleBlocks = false; txtTimeout.Title = MyStringId.GetOrCompute("Build Timer"); txtTimeout.Tooltip = MyStringId.GetOrCompute("The amount of time you must wait after building a grid to be able to build another."); MyAPIGateway.TerminalControls.AddControl <IMyProjector>(txtTimeout); // Terminal actions // Button panels are special and trigger on the server instead of the client, making everything more complicated. IMyTerminalAction aCancel = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("CancelBuildAction"); aCancel.Enabled = IsValid; aCancel.Action = CancelClient; // For all except button panels aCancel.ValidForGroups = true; aCancel.Name = new StringBuilder("Cancel Spawn Grid"); aCancel.Writer = (b, s) => s.Append("Cancel"); aCancel.InvalidToolbarTypes = new[] { MyToolbarType.ButtonPanel }.ToList(); MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aCancel); IMyTerminalAction aCancel2 = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("CancelBuildGrid"); aCancel2.Enabled = IsValid; aCancel2.Action = CancelClientUnsafe; // For only button panels aCancel2.ValidForGroups = true; aCancel2.Name = new StringBuilder("Cancel Spawn Grid"); aCancel2.Writer = (b, s) => s.Append("Cancel"); aCancel2.InvalidToolbarTypes = new List <MyToolbarType> { MyToolbarType.BuildCockpit, MyToolbarType.Character, MyToolbarType.LargeCockpit, MyToolbarType.None, MyToolbarType.Seat, MyToolbarType.Ship, MyToolbarType.SmallCockpit, MyToolbarType.Spectator }; MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aCancel2); IMyTerminalAction aBuild = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("BuildGridAction"); aBuild.Enabled = IsValid; aBuild.Action = BuildClient; // For all except button panels aBuild.ValidForGroups = true; aBuild.Name = new StringBuilder("Spawn Grid"); aBuild.Writer = (b, s) => s.Append("Spawn"); aBuild.InvalidToolbarTypes = new [] { MyToolbarType.ButtonPanel }.ToList(); MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aBuild); IMyTerminalAction aBuild2 = MyAPIGateway.TerminalControls.CreateAction <IMyProjector>("BuildGrid"); aBuild2.Enabled = IsValid; aBuild2.Action = BuildClientUnsafe; // For only button panels aBuild2.ValidForGroups = true; aBuild2.Name = new StringBuilder("Spawn Grid"); aBuild2.Writer = (b, s) => s.Append("Spawn"); aBuild2.InvalidToolbarTypes = new List <MyToolbarType> { MyToolbarType.BuildCockpit, MyToolbarType.Character, MyToolbarType.LargeCockpit, MyToolbarType.None, MyToolbarType.Seat, MyToolbarType.Ship, MyToolbarType.SmallCockpit, MyToolbarType.Spectator }; MyAPIGateway.TerminalControls.AddAction <IMyProjector>(aBuild2); IMyTerminalControlListbox itemList = MyAPIGateway.TerminalControls.CreateControl <IMyTerminalControlListbox, IMyProjector>("ComponentList"); itemList.Enabled = IsWorking; itemList.Visible = IsValid; itemList.ListContent = GetItemList; itemList.Multiselect = false; itemList.SupportsMultipleBlocks = false; itemList.Title = MyStringId.GetOrCompute("Components"); itemList.VisibleRowsCount = 10; itemList.ItemSelected = (b, l) => { }; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(itemList); // Programmable Block stuff IMyTerminalControlProperty <Dictionary <MyItemType, int> > itemListProp = MyAPIGateway.TerminalControls.CreateProperty <Dictionary <MyItemType, int>, IMyProjector>("RequiredComponents"); itemListProp.Enabled = IsWorking; itemListProp.Visible = IsValid; itemListProp.SupportsMultipleBlocks = false; itemListProp.Setter = (b, l) => { }; itemListProp.Getter = GetItemListPB; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(itemListProp); IMyTerminalControlProperty <int> gridTimeoutProp = MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("GridTimerProjection"); gridTimeoutProp.Enabled = IsWorking; gridTimeoutProp.Visible = IsValid; gridTimeoutProp.SupportsMultipleBlocks = false; gridTimeoutProp.Setter = (b, l) => { }; gridTimeoutProp.Getter = GetMaxTimerPB; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutProp); IMyTerminalControlProperty <int> gridTimeoutActive = MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("GridTimerCurrent"); gridTimeoutActive.Enabled = IsWorking; gridTimeoutActive.Visible = IsValid; gridTimeoutActive.SupportsMultipleBlocks = false; gridTimeoutActive.Setter = (b, l) => { }; gridTimeoutActive.Getter = GetCurrentTimerPB; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutActive); IMyTerminalControlProperty <int> buildState = MyAPIGateway.TerminalControls.CreateProperty <int, IMyProjector>("BuildState"); buildState.Enabled = IsWorking; buildState.Visible = IsValid; buildState.SupportsMultipleBlocks = false; buildState.Setter = (b, l) => { }; buildState.Getter = GetStatePB; MyAPIGateway.TerminalControls.AddControl <IMyProjector>(gridTimeoutActive); MyLog.Default.WriteLineAndConsole("Initialized Instant Projector."); controls = true; } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.Init(objectBuilder, cubeGrid); var medicalRoomDefinition = BlockDefinition as MyMedicalRoomDefinition; MyStringHash resourceSinkGroup; if (medicalRoomDefinition != null) { m_idleSound = new MySoundPair(medicalRoomDefinition.IdleSound); m_progressSound = new MySoundPair(medicalRoomDefinition.ProgressSound); resourceSinkGroup = MyStringHash.GetOrCompute(medicalRoomDefinition.ResourceSinkGroup); } else { m_idleSound = new MySoundPair("BlockMedical"); m_progressSound = new MySoundPair("BlockMedicalProgress"); resourceSinkGroup = MyStringHash.GetOrCompute("Utility"); } m_rechargeSocket = new MyRechargeSocket(); NeedsUpdate = MyEntityUpdateEnum.EACH_10TH_FRAME | MyEntityUpdateEnum.EACH_100TH_FRAME; SteamUserId = (objectBuilder as MyObjectBuilder_MedicalRoom).SteamUserId; if (SteamUserId != 0) //backward compatibility { MyPlayer controller = Sync.Players.GetPlayerById(new MyPlayer.PlayerId(SteamUserId)); if (controller != null) { IDModule.Owner = controller.Identity.IdentityId; IDModule.ShareMode = MyOwnershipShareModeEnum.Faction; } } SteamUserId = 0; m_takeSpawneeOwnership = (objectBuilder as MyObjectBuilder_MedicalRoom).TakeOwnership; m_setFactionToSpawnee = (objectBuilder as MyObjectBuilder_MedicalRoom).SetFaction; SyncObject = new SyncClass(this); SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; InitializeConveyorEndpoint(); SinkComp = new MyResourceSinkComponent(); SinkComp.Init( resourceSinkGroup, MyEnergyConstants.MAX_REQUIRED_POWER_MEDICAL_ROOM, () => (Enabled && IsFunctional) ? SinkComp.MaxRequiredInput : 0f); SinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; SinkComp.Update(); AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(SinkComp, this)); if (this.CubeGrid.CreatePhysics) { Components.Add <MyRespawnComponent>(new MyRespawnComponent()); } }
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid) { base.Init(objectBuilder, cubeGrid); m_radioBroadcaster = new MyRadioBroadcaster(this, 10000); if (((MyObjectBuilder_Beacon)objectBuilder).BroadcastRadius != 0) { m_radioBroadcaster.BroadcastRadius = ((MyObjectBuilder_Beacon)objectBuilder).BroadcastRadius; } m_radioBroadcaster.OnBroadcastRadiusChanged += OnBroadcastRadiusChanged; m_largeLight = cubeGrid.GridSizeEnum == MyCubeSize.Large; m_light = MyLights.AddLight(); m_light.Start(MyLight.LightTypeEnum.PointLight, 1.5f); m_light.LightOwner = MyLight.LightOwnerEnum.SmallShip; m_light.UseInForwardRender = true; m_light.Range = 1; m_light.GlareOn = true; m_light.GlareIntensity = m_largeLight ? 2 : 1; m_light.GlareQuerySize = m_largeLight ? 7.5f : 1.22f; m_light.GlareType = VRageRender.Lights.MyGlareTypeEnum.Distant; m_light.GlareMaterial = m_largeLight ? "GlareLsLight" : "GlareSsLight"; m_light.GlareMaxDistance = GLARE_MAX_DISTANCE; if (m_largeLight) { m_lightPositionOffset = new Vector3(0f, CubeGrid.GridSize * 0.5f, 0f); } else { m_lightPositionOffset = Vector3.Zero; } UpdateLightPosition(); var beaconDefinition = BlockDefinition as MyBeaconDefinition; Debug.Assert(beaconDefinition != null); var sinkComp = new MyResourceSinkComponent(); sinkComp.Init( MyStringHash.GetOrCompute(beaconDefinition.ResourceSinkGroup), MyEnergyConstants.MAX_REQUIRED_POWER_BEACON, UpdatePowerInput); sinkComp.IsPoweredChanged += Receiver_IsPoweredChanged; sinkComp.Update(); ResourceSink = sinkComp; AddDebugRenderComponent(new MyDebugRenderComponentDrawPowerReciever(ResourceSink, this)); AnimationRunning = true; SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged; IsWorkingChanged += MyBeacon_IsWorkingChanged; ShowOnHUD = false; UpdateText(); }