float GetPowerInput(bool count = true)
{
//if (block.Enabled == false)
//return 0f;
var s = Settings.GetSettings(Entity);
if (!block.Enabled && (!s.Recharging || !_isReloading))
{
return(0f);
}
var requiredInput = turret != null?CalculateTurretPowerDraw(turret.Range) : _idlePowerDrawBase;
if (!_isReloading)
{
_enabledStatus = block.Enabled;
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
_ticksSinceLastReload++;
if (_ticksSinceLastReload > _reloadTicks)
{
block.Enabled = false;
}
else
{
_enabledStatus = block.Enabled;
}
if (!s.Recharging)
{
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
//if (block.IsWorking) //check if power is overloaded
if (count && sink.IsPoweredByType(resourceId)) //SuppliedRatioByType(resourceId) == 1f)
{
_currentReloadTicks++;
}
if (_currentReloadTicks >= _reloadTicks)
{
_isReloading = false;
_currentReloadTicks = 0;
_ticksSinceLastReload = 0;
block.Enabled = _enabledStatus; //reset to enabled after reloaded
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
var scaledReloadPowerDraw = _reloadPowerDraw - _currentReloadTicks * _powerDrawDecrementPerTick;
requiredInput = Math.Max(requiredInput, scaledReloadPowerDraw);
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
public override void UpdateOnceBeforeFrame()
{
if (firstrun)
{
var info = new List <MyUpgradeModuleInfo>();
hyperDriveBlock.GetUpgradeList(out info);
Maxhyper = info.FirstOrDefault(x => x.UpgradeType == "WarpFactor").Modifier;
ResourceSink.SetMaxRequiredInputByType(_electricity, HyperFunctions.MinimumPowertoActivate());
ResourceSink.SetRequiredInputByType(_electricity, HyperFunctions.PowerConsumption());
ResourceSink.SetRequiredInputFuncByType(_electricity, HyperFunctions.PowerConsumption);
ResourceSink.Update();
hyperDriveBlock.AppendingCustomInfo += HyperFunctions.hyperDriveBlock_AppendingCustomInfo;
Maxhyper = Maxhyper * 100f;
emitter = new Sandbox.Game.Entities.MyEntity3DSoundEmitter(hyperDriveBlock as MyEntity);
MyEntity3DSoundEmitter.PreloadSound(pair);
HyperFunctions.CreatehyperUI();
firstrun = false;
White = Color.White;
MyVisualScriptLogicProvider.ScreenColorFadingSetColor(White);
}
}
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);
}
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();
}
public void initMe()
{
try
{
max = getMax();
if (fBlock.Name != "NaN" && !fBlock.Name.Contains("-"))
{
float.TryParse(fBlock.Name, out points);
}
if (points > max)
{
points = 0f;
}
if (!TeaShieldBase.shieldList.Contains(sBlock))
{
TeaShieldBase.shieldList.Add(sBlock);
}
sink = fBlock.ResourceSink as MyResourceSinkComponent;
sink.SetMaxRequiredInputByType(electricity, max / 1000);
sink.SetRequiredInputFuncByType(electricity, powerCalc);
sink.Update();
fBlock.AppendingCustomInfo += appendCustomInfo;
added = true;
for (int i = 1; i < 9; i++)
{
sbBlock.SetEmissiveParts("Emissive" + i, Color.Red, i == 6 ? 1f : 0f);
}
}
catch (Exception ex)
{
Echo("IAShields threw exception", ex.ToString());
}
}
void InitResourceSink()
{
_sink.SetMaxRequiredInputByType(Electricity, _power);
_sink.SetRequiredInputFuncByType(Electricity, PowerConsumptionFunc);
_sink.SetRequiredInputByType(Electricity, PowerConsumptionFunc());
_sink.Update();
}
static public void Init()
{
//var info = new List<MyJumpDriveInfo>();
//hyperDriveBlock.GetUpgradeList(out info);
//Maxhyper = info.FirstOrDefault(x => x.UpgradeType == "WarpFactor").Modifier;
ResourceSink.SetMaxRequiredInputByType(_electricity, MinimumPowertoActivate());
ResourceSink.SetRequiredInputByType(_electricity, PowerConsumption());
ResourceSink.SetRequiredInputFuncByType(_electricity, PowerConsumption);
ResourceSink.Update();
HyperDriveLogic.hyperDriveBlock.AppendingCustomInfo += hyperDriveBlock_AppendingCustomInfo;
HyperDriveLogic.Maxhyper = HyperDriveLogic.Maxhyper * 100f;
emitter = new Sandbox.Game.Entities.MyEntity3DSoundEmitter(HyperDriveLogic.hyperDriveBlock as MyEntity);
MyEntity3DSoundEmitter.PreloadSound(pair);
UIGen.CreatehyperUI();
//HyperFunctions.HideVanillaActions();
HyperDriveLogic.firstrun = false;
White = Color.White;
MyVisualScriptLogicProvider.ScreenColorFadingSetColor(White);
}
public override void UpdateBeforeSimulation()
{
if (!((IMyCollector)Container.Entity).Enabled)
{
_power = 0f;
}
_sink.SetMaxRequiredInputByType(PowerDef, _power);
_sink.SetRequiredInputByType(PowerDef, _power);
//sink.Update();
}
public virtual void Unregister(MyEntity entity, Vector3I forwardVector)
{
Debug.Assert(entity != null);
Debug.Assert(IsRegistered(entity, forwardVector));
MyDefinitionId fuelType = FuelType(entity);
int typeIndex = GetTypeIndex(ref fuelType);
ResourceSink.SetMaxRequiredInputByType(fuelType, ResourceSink.MaxRequiredInputByType(fuelType) - PowerAmountToFuel(ref fuelType, MaxPowerConsumption(entity)));
m_dataByFuelType[typeIndex].ThrustsByDirection[forwardVector].Remove(entity);
m_thrustsChanged = true;
--ThrustCount;
}
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);
}
}
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();
}
float GetPowerInput(bool count = true)
{
var s = Settings.GetSettings(Entity);
if (!block.Enabled && (!s.Recharging || !_isReloading))
{
return(0f);
}
var requiredInput = turret != null?CalculateTurretPowerDraw(turret.Range) : _idlePowerDrawBase;
if (!_isReloading)
{
_enabledStatus = block.Enabled;
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
_ticksSinceLastReload++;
if (_ticksSinceLastReload > _reloadTicks)
{
block.Enabled = false;
}
else
{
_enabledStatus = block.Enabled;
}
if (!s.Recharging)
{
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
if (count)
{
var suppliedRatio = sink.SuppliedRatioByType(resourceId);
if (suppliedRatio == 1)
{
_currentReloadTicks += 1;
}
else
{
_currentReloadTicks += suppliedRatio * 0.5f; // nerfed recharge rate if overloaded
}
}
if (_currentReloadTicks >= _reloadTicks)
{
_isReloading = false;
_currentReloadTicks = 0;
_ticksSinceLastReload = 0;
block.Enabled = _enabledStatus; //reset to enabled after reloaded
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}
var scaledReloadPowerDraw = _reloadPowerDraw; //_reloadPowerDraw - _currentReloadTicks * _powerDrawDecrementPerTick;
requiredInput = Math.Max(requiredInput, scaledReloadPowerDraw);
sink.SetMaxRequiredInputByType(resourceId, requiredInput);
return(requiredInput);
}