public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
{
ResourceSink = new MyResourceSinkComponent();
ResourceSink.Init(
MyStringHash.GetOrCompute(BlockDefinition.ResourceSinkGroup),
BlockDefinition.PowerConsumptionMoving,
UpdatePowerInput);
base.Init(builder, cubeGrid);
var ob = (MyObjectBuilder_AirtightDoorGeneric)builder;
m_open.Value = ob.Open;
m_currOpening = ob.CurrOpening;
m_openingSpeed = BlockDefinition.OpeningSpeed;
m_sound = new MySoundPair(BlockDefinition.Sound);
m_subpartMovementDistance = BlockDefinition.SubpartMovementDistance;
if (!Enabled || !ResourceSink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId))
{
UpdateDoorPosition();
}
OnStateChange();
ResourceSink.IsPoweredChanged += Receiver_IsPoweredChanged;
ResourceSink.Update();
SlimBlock.ComponentStack.IsFunctionalChanged += ComponentStack_IsFunctionalChanged;
ResourceSink.Update();
}
public override void UpdateBeforeSimulation()
{
//((IMyHandheldGunObject<MyGunBase>)Entity).CurrentAmmunition = 100;
//((IMyHandheldGunObject<MyGunBase>)Entity).CurrentMagazineAmmunition = 100;
if ((m_ticks % 20) == 0)
{
if (((IMyHandheldGunObject <MyGunBase>)Entity).CurrentMagazineAmmunition < 10)
{
if (m_resourceSink.IsPoweredByType(ElectricityDefinitionsId))
{
((IMyHandheldGunObject <MyGunBase>)Entity).CurrentMagazineAmmunition += 1;
((MyObjectBuilder_AutomaticRifle)Entity.GetObjectBuilder()).CurrentAmmo = ((IMyHandheldGunObject <MyGunBase>)Entity).CurrentMagazineAmmunition;
}
MyAPIGateway.Utilities.ShowNotification("Tick", 40, VRage.Game.MyFontEnum.Red);
((IMyHandheldGunObject <MyGunBase>)Entity).CurrentAmmunition = ((IMyHandheldGunObject <MyGunBase>)Entity).CurrentMagazineAmmunition;
//m_resourceSource.SetProductionEnabledByType(ElectricityDefinitionsId, false);
}
}
else
{
//m_resourceSource.SetProductionEnabledByType(ElectricityDefinitionsId, true);
}
m_resourceSink.Update();
MyAPIGateway.Utilities.ShowNotification("Läuft: " + ((IMyHandheldGunObject <MyGunBase>)Entity).DefinitionId, 17);
MyAPIGateway.Utilities.ShowNotification("" + ((IMyHandheldGunObject <MyGunBase>)Entity).CurrentAmmunition + ":" + ((IMyHandheldGunObject <MyGunBase>)Entity).CurrentMagazineAmmunition, 17);
m_ticks++;
}
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 void UpdateStatus()
{
if (!m_block.Enabled || !m_block.IsFunctional || !Sink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId) || m_tooCloseToOtherDetector)
{
m_detectorState = DetectorStates.Disabled;
}
else if (m_depositGroupsByEntity.Count == 0)
{
m_detectorState = DetectorStates.Enabled;
}
if (m_detectorState != m_lastDetectorState || m_tooCloseToOtherDetector != m_tooCloseOld)
{
m_tooCloseOld = m_tooCloseToOtherDetector;
m_lastDetectorState = m_detectorState;
MessageHub.SendToPlayerInSyncRange(new MessageOreDetectorStateChange()
{
EntityId = m_block.EntityId,
State = m_lastDetectorState,
TooClose = m_tooCloseToOtherDetector
}, m_block.GetPosition());
}
}
public bool isFunctioning()
{
return(energySink.IsPoweredByType(MyResourceDistributorComponent.ElectricityId) && shouldUsePower());
}
public override void UpdateBeforeSimulation()
{
if (!block_initialized)
{
InitLate();
}
frame++;
if (frame % 10 == 0)
{
(Entity as IMyTerminalBlock).RefreshCustomInfo();
}
if (!(bool)SettingsStore.Get(Entity, "power_on", true))
{
UpdatePowerUsage(0);
UpdatePowerState(false);
return;
}
// this will be one frame late ... but close enough??
// power requested that can be satisfied by the network * power required that can be requested given our max
float power_ratio = sinkComp.SuppliedRatioByType(MyResourceDistributorComponent.ElectricityId) * power_ratio_available;
if (!sinkComp.IsPoweredByType(MyResourceDistributorComponent.ElectricityId))
{
power_ratio = 0;
}
// MyLog.Default.WriteLine(String.Format("power ratio is {0}", power_ratio));
float height = (float)SettingsStore.Get(Entity, "height_offset", 1.25f);
double forceLimit = (double)(float)SettingsStore.Get(Entity, "force_slider", 100000.0f);
var hoverCenter = Entity.WorldMatrix.Translation;
var searchCenter = Entity.WorldMatrix.Translation + Entity.WorldMatrix.Down * 2.499;
// DebugDraw.Sphere(searchCenter, 2.5f, Color.Green);
var rail_pos = new Vector3D(0, 0, 0);
var weight_sum = 0.0f;
HashSet <RailGuide> lostGuides = new HashSet <RailGuide>();
RailGuide anyRailGuide = null;
foreach (var guide in activeRailGuides)
{
if (!guide.getGuidance(hoverCenter, ref rail_pos, ref weight_sum, height))
{
// lost rail lock
lostGuides.Add(guide);
continue;
}
anyRailGuide = guide;
}
foreach (var guide in lostGuides)
{
activeRailGuides.Remove(guide);
}
lostGuides.Clear();
if (weight_sum < 0.9f)
{
// not confident in our rail lock, look for possible new rails
var area = new BoundingSphereD(searchCenter, 2.5);
var items = MyAPIGateway.Entities.GetEntitiesInSphere(ref area);
rail_pos = Vector3D.Zero;
weight_sum = 0.0f;
foreach (var ent in items)
{
var guide = RailGuide.fromEntity(ent);
if (guide != null)
{
var test = guide.getGuidance(hoverCenter, ref rail_pos, ref weight_sum, height);
if (test)
{
activeRailGuides.Add(guide);
anyRailGuide = guide;
}
}
}
}
// MyLog.Default.WriteLine(String.Format("{0}:- hovering at {1}", Entity.EntityId, hoverCenter));
if (activeRailGuides.Count == 0)
{
UpdatePowerUsage(0);
UpdatePowerState(true); // powered but idle
return;
}
// average by weight
rail_pos /= weight_sum;
var guidance = rail_pos - hoverCenter;
// MyLog.Default.WriteLine(String.Format("{0}: rail pos is {1}, due to weight correction by {2}; guidance {3}", Entity.EntityId, rail_pos, weight_sum, guidance));
DebugDraw.Sphere(rail_pos, 0.15f, Color.Blue);
DebugDraw.Sphere(rail_pos * 0.5 + hoverCenter * 0.5, 0.1f, Color.Blue);
DebugDraw.Sphere(hoverCenter, 0.1f, Color.Blue);
// DebugDraw.Sphere(searchCenter, 0.1f, Color.Green);
float force_magnitude = 0;
// correction force, pushes engine towards rail guide
{
var len = guidance.Length() / 2.5; // 0 .. 1
if (len > 0.001)
{
var weight = len;
if (weight > 0.99)
{
weight = 0.99; // always some force
}
const double splitPoint = 0.5;
if (weight > splitPoint)
{
weight = 1.0 - (weight - splitPoint) / (1.0 - splitPoint);
}
else
{
weight = weight / splitPoint;
}
var factor = Math.Pow(weight, 2.0); // spiken
var guidanceForce = forceLimit * Vector3D.Normalize(guidance) * factor;
this.avgCorrectF.update(guidanceForce);
DebugDraw.Sphere(searchCenter, 0.1f, Color.Yellow);
anyRailGuide.applyForces(Entity, this.avgCorrectF.value * power_ratio);
force_magnitude += (float)this.avgCorrectF.value.Length();
}
}
// dampening force, reduces oscillation over time
var dF = guidance - this.avgGuidance.value;
{
// var len = guidance.Length() / 2.5;
// if (len > 0.99) len = 0.99;
// var factor = Math.Pow(len, 0.3);
var factor = 1.0;
var dampenForce = forceLimit * 0.5 * dF * factor; // separate slider?
this.avgDampenF.update(dampenForce);
DebugDraw.Sphere(searchCenter + this.avgDampenF.value * 0.000001f, 0.1f, Color.Red);
anyRailGuide.applyForces(Entity, this.avgDampenF.value * power_ratio);
force_magnitude += (float)this.avgDampenF.value.Length();
}
this.avgGuidance.update(guidance);
UpdatePowerUsage(force_magnitude * FORCE_POWER_COST_MW_N);
UpdatePowerState(true);
}