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();
}