private void CalculatePowerConsumption()
{
try
{
Debug.Write("Calculating power consumption.", 1, debug);
if (m_shipController != null)
{ // Computes remaining power of grid, forces gun to not overdraw that power
var shipPowerMax = m_shipController.GridResourceDistributor.MaxAvailableResourceByType(MyResourceDistributorComponent.ElectricityId);
var shipPowerUsed = m_shipController.GridResourceDistributor.TotalRequiredInputByType(MyResourceDistributorComponent.ElectricityId);
var remainingPower = shipPowerMax - shipPowerUsed;
remainingPower = (remainingPower < 0f) ? 0f : remainingPower;
PowerConsumption = (remainingPower < m_operationalPower) ? (remainingPower / 2) : m_operationalPower;
}
else
{
PowerConsumption = m_operationalPower;
}
SyncPowerConsumption();
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
if (m_resourceSink != null && m_electricityDefinition != null)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, PowerConsumption);
}
});
Debug.Write($"Power consumption is {PowerConsumption}.", 1, debug);
}
catch (Exception e)
{ Debug.HandleException(e); }
}
void updatePowerInput()
{
if (!m_sender)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
}
else if (m_functionalBlock.Enabled && m_functionalBlock.IsFunctional)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, m_transmittedPower);
}
else
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
}
}
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);
}
}
void InitResourceSink()
{
_sink.SetMaxRequiredInputByType(Electricity, _power);
_sink.SetRequiredInputFuncByType(Electricity, PowerConsumptionFunc);
_sink.SetRequiredInputByType(Electricity, PowerConsumptionFunc());
_sink.Update();
}
public override void UpdateOnceBeforeFrame()
{
resourceSink = Entity.Components.Get <MyResourceSinkComponent>();
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)Entity).GetInventory(0) as IMyInventory;
}
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 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();
}
void Recharge()
{
int chargesInInventory = (int)m_inventory.GetItemAmount(chargeDefinitionIds[damageUpgrades]);
if (chargesInInventory < attractorWeaponInfo.keepAtCharge)
{
if (resourceSink.RequiredInputByType(electricityDefinition) != (attractorWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (attractorWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (attractorWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = (attractorWeaponInfo.powerUsage / efficiencyUpgrades);
}
else
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
}
}
if (resourceSink.CurrentInputByType(electricityDefinition) == (attractorWeaponInfo.powerUsage / efficiencyUpgrades))
{
if (!overheated)
{
m_inventory.AddItems((MyFixedPoint)(attractorWeaponInfo.keepAtCharge - chargesInInventory), chargeObjectBuilders [damageUpgrades]);
}
}
}
else if (chargesInInventory > attractorWeaponInfo.keepAtCharge)
{
m_inventory.RemoveItemsOfType((MyFixedPoint)(chargesInInventory - attractorWeaponInfo.keepAtCharge), chargeObjectBuilders [damageUpgrades]);
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = 0.0001f;
}
}
// terminalBlock.RefreshCustomInfo ();
}
public override void UpdateBeforeSimulation()
{
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
if (!m_inventory.IsItemAt(0))
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
setPowerConsumption = 0.0001f;
}
else
{
if (setPowerConsumption != (pulseWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (pulseWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (pulseWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
charge += powerConsumption;
if (charge > (pulseWeaponInfo.energyPerProjectile / efficiencyUpgrades))
{
m_inventory.AddItems((MyFixedPoint)pulseWeaponInfo.projectilesPerCharge, chargeObjectBuilders [damageUpgrades]);
charge -= (pulseWeaponInfo.energyPerProjectile / efficiencyUpgrades);
}
}
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
}
terminalBlock.RefreshCustomInfo();
}
public override void UpdateBeforeSimulation()
{
if (!((IMyCollector)Container.Entity).Enabled)
{
_power = 0f;
}
_sink.SetMaxRequiredInputByType(PowerDef, _power);
_sink.SetRequiredInputByType(PowerDef, _power);
//sink.Update();
}
public override void UpdateBeforeSimulation()
{
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
if (!m_inventory.IsItemAt(0))
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
setPowerConsumption = 0.0001f;
}
else
{
reloadTimer++;
if (setPowerConsumption != pulseWeaponInfo.powerUsage)
{
resourceSink.SetRequiredInputByType(electricityDefinition, pulseWeaponInfo.powerUsage);
setPowerConsumption = pulseWeaponInfo.powerUsage;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
if (reloadTimer >= 300)
{
m_inventory.AddItems(pulseWeaponInfo.projectilesPerCharge, chargeObjectBuilders[damageUpgrades]);
reloadTimer = 0;
}
}
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = resourceSink.CurrentInputByType(electricityDefinition);
}
}
terminalBlock.RefreshCustomInfo();
}
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);
}
}
public override void UpdateOnceBeforeFrame()
{
if (UI == null)
{
UI = new LSE.TractorUI <Sandbox.ModAPI.Ingame.IMyLargeTurretBase>();
UI.CreateUI((Sandbox.ModAPI.IMyTerminalBlock)Entity);
}
resourceSink = Entity.Components.Get <MyResourceSinkComponent>();
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0021f);
setPowerConsumption = 0.0081f;
m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)Entity).GetInventory(0) as IMyInventory;
}
public override void UpdateOnceBeforeFrame()
{
RemoveSmokeEffects(subtypeName);
MyParticleEffect effect;
if (MyParticlesManager.TryCreateParticleEffect("Collision_Sparks", out effect))
{
effect.Loop = false;
effect.UserScale = 0.2f;
//MyAPIGateway.Utilities.ShowNotification("Spawned", 17);
}
resourceSink = Entity.Components.Get <MyResourceSinkComponent> ();
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
m_inventory = ((Sandbox.ModAPI.Ingame.IMyTerminalBlock)Entity).GetInventory(0) as IMyInventory;
}
public override void UpdateBeforeSimulation()
{
base.UpdateBeforeSimulation();
//MyAPIGateway.Utilities.ShowNotification ("YEP: " + m_subtypeName, 17);
if (m_functionalBlock.IsFunctional)
{
if (m_functionalBlock.Enabled)
{
m_info.enabled = true;
}
else
{
m_info.enabled = false;
}
}
else
{
m_info.enabled = false;
}
if (!m_sender)
{
if (m_currentRequiredInput != 0)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
m_oldTransmittedPower = 0;
m_currentRequiredInput = 0;
}
m_target = null;
}
else if (m_functionalBlock.Enabled && m_functionalBlock.IsFunctional)
{
if (m_target != null)
{
if (m_target.functionalBlock == null)
{
m_target = null;
}
else
{
if (!m_target.functionalBlock.Enabled)
{
m_target = null;
}
}
}
if (m_ticks % 100 == 0)
{
if (m_sender)
{
maintainConnection();
}
m_targetIdOld = m_targetId;
}
if (m_target != null)
{
if (m_targetVisible)
{
m_currentOutput = m_resourceSink.CurrentInputByType(m_electricityDefinition);
m_powerToTransfer = m_currentOutput * m_powerMultiplicator;
var transmitterComponent = m_target.functionalBlock.GameLogic.GetAs <OpticalPowerTransmitter>();
if ((transmitterComponent.m_receivingPower + m_powerToTransfer) > m_target.strength)
{
m_powerToTransfer = m_target.strength - transmitterComponent.m_receivingPower;
}
transmitterComponent.m_receivingPower += m_powerToTransfer;
transmitterComponent.m_senders++;
//MyAPIGateway.Utilities.ShowNotification ("ADD: " + m_target.functionalBlock.CubeGrid.EntityId + ":" + powerToTransfer, 17, MyFontEnum.DarkBlue);
TransmissionManager.totalPowerPerGrid [m_target.functionalBlock.CubeGrid.EntityId] = TransmissionManager.totalPowerPerGrid [m_target.functionalBlock.CubeGrid.EntityId] + m_powerToTransfer;
}
}
}
else
{
m_target = null;
if (m_currentRequiredInput != 0)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
m_oldTransmittedPower = 0;
m_currentRequiredInput = 0;
}
}
if (m_ticks % 100 == 0)
{
m_terminalBlock.RefreshCustomInfo();
}
if (m_sender)
{
m_saveInfo.ChannelTarget = m_targetId;
}
else
{
m_saveInfo.ChannelTarget = m_id;
}
m_saveInfo.Sender = m_sender;
m_saveInfo.Power = m_transmittedPower;
m_receivingPower = 0f;
m_senders = 0;
m_ticks++;
}
void calculateShieldPointsRecharge()
{
if (EnergyShieldsCore.Config.AlternativeRechargeMode.Enable)
{
if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).IsFunctional)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
m_currentShieldPoints = 0f;
}
}
else if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).Enabled)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else if (m_maximumShieldPoints == m_currentShieldPoints)
{
if (m_setPowerConsumption != 0.00001f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.00001f);
m_setPowerConsumption = 0.00001f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else
{
IMyCubeBlock cubeBlock = Entity as IMyCubeBlock;
float powerConsumption = getShieldDefinition().PowerConsumption *cubeBlock.UpgradeValues ["PowerConsumption"] * EnergyShieldsCore.Config.UpgradeModuleMultiplier.PowerMultiplier;
m_resourceSink.MaxRequiredInput = powerConsumption;
if (powerConsumption != m_setPowerConsumption)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerConsumption);
m_setPowerConsumption = powerConsumption;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
m_rechargeMultiplier = m_currentPowerConsumption / powerConsumption;
m_pointsToRecharge = getShieldDefinition().RechargeAtPeak *cubeBlock.UpgradeValues ["ShieldRecharge"]
* EnergyShieldsCore.Config.UpgradeModuleMultiplier.RechargeMultiplier * EnergyShieldsCore.Config.AlternativeRechargeMode.RechargeMultiplier * m_rechargeMultiplier;
if (m_ticksUntilRecharge > 0)
{
m_ticksUntilRecharge--;
m_pointsToRecharge = 0;
}
else
{
if (m_maximumShieldPoints > m_currentShieldPoints)
{
m_currentShieldPoints += m_pointsToRecharge;
}
}
if (m_maximumShieldPoints < m_currentShieldPoints)
{
if (m_overchargedTicks >= m_overchargeTimeout)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
m_overchargedTicks++;
}
else
{
m_overchargedTicks = 0;
}
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId)) {
* m_currentShieldPoints = 0f;
* }
*/
}
}
else
{
if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).IsFunctional)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
m_currentShieldPoints = 0f;
}
}
else if (!(Entity as Sandbox.ModAPI.IMyFunctionalBlock).Enabled)
{
if (m_setPowerConsumption != 0.000000f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.000000f);
m_setPowerConsumption = 0.000000f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else if (m_maximumShieldPoints == m_currentShieldPoints)
{
if (m_setPowerConsumption != 0.00001f)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, 0.00001f);
m_setPowerConsumption = 0.00001f;
m_pointsToRecharge = 0f;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId))
* {
* m_currentShieldPoints = 0f;
* }
*/
}
else
{
float multiplier = (m_currentShieldPoints / m_maximumShieldPoints);
if (multiplier > 0.99999f)
{
multiplier = 0.00001f;
}
else if ((multiplier > 0.9f) || (multiplier < 0.08f))
{
multiplier = 0.1f;
}
else if ((multiplier > 0.7f) || (multiplier < 0.12f))
{
multiplier = 0.2f;
}
else if ((multiplier > 0.5f) || (multiplier < 0.18f))
{
multiplier = 0.4f;
}
else if ((multiplier > 0.35f) || (multiplier < 0.22f))
{
multiplier = 0.7f;
}
else
{
multiplier = 1.0f;
}
IMyCubeBlock cubeBlock = Entity as IMyCubeBlock;
float powerConsumption = getShieldDefinition().PowerConsumption *cubeBlock.UpgradeValues ["PowerConsumption"] * EnergyShieldsCore.Config.UpgradeModuleMultiplier.PowerMultiplier * multiplier;
m_resourceSink.MaxRequiredInput = powerConsumption;
if (powerConsumption != m_setPowerConsumption)
{
m_resourceSink.SetRequiredInputByType(MyResourceDistributorComponent.ElectricityId, powerConsumption);
m_setPowerConsumption = powerConsumption;
}
m_currentPowerConsumption = m_resourceSink.CurrentInputByType(MyResourceDistributorComponent.ElectricityId);
m_rechargeMultiplier = m_currentPowerConsumption / powerConsumption;
m_pointsToRecharge = getShieldDefinition().RechargeAtPeak *cubeBlock.UpgradeValues ["ShieldRecharge"]
* EnergyShieldsCore.Config.UpgradeModuleMultiplier.RechargeMultiplier * EnergyShieldsCore.Config.AlternativeRechargeMode.RechargeMultiplier * m_rechargeMultiplier * multiplier;
m_currentShieldPoints += m_pointsToRecharge;
if (m_maximumShieldPoints < m_currentShieldPoints)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
if (m_maximumShieldPoints < m_currentShieldPoints)
{
if (m_overchargedTicks >= m_overchargeTimeout)
{
m_currentShieldPoints = m_maximumShieldPoints;
}
m_overchargedTicks++;
}
else
{
m_overchargedTicks = 0;
}
/*
* if (!m_resourceSink.IsPoweredByType (MyResourceDistributorComponent.ElectricityId)) {
* m_currentShieldPoints = 0f;
* }
*/
}
}
}
public override void UpdateBeforeSimulation()
{
int chargesInInventory = (int)m_inventory.GetItemAmount(chargeDefinitionIds [damageUpgrades]);
IMyCubeBlock cube = Entity as IMyCubeBlock;
long currentShootTime = ((MyObjectBuilder_InteriorTurret)cube.GetObjectBuilderCubeBlock()).GunBase.LastShootTime;
if (currentHeat > 0f)
{
if ((ticks - lastShootTimeTicks) > beamWeaponInfo.heatDissipationDelay)
{
currentHeat -= beamWeaponInfo.heatDissipationPerTick;
if (currentHeat <= 0f)
{
currentHeat = 0f;
overheated = false;
}
}
}
//MyAPIGateway.Utilities.ShowNotification("TIME: " + currentShootTime + " :: " + lastShootTime, 17, MyFontEnum.Red);
if (currentShootTime != lastShootTime)
{
// test
hitBool = false;
MyEntitySubpart subpart1 = cubeBlock.GetSubpart("InteriorTurretBase1");
MyEntitySubpart subpart2 = subpart1.GetSubpart("InteriorTurretBase2");;
//MyAPIGateway.Utilities.ShowNotification("Dif: " + (currentShootTime - lastShootTime), 17, MyFontEnum.Blue);
from = subpart2.WorldMatrix.Translation + subpart2.WorldMatrix.Forward * 1.25d;
to = subpart2.WorldMatrix.Translation + subpart2.WorldMatrix.Forward * 3000d;
LineD testRay = new LineD(from, to);
List <MyLineSegmentOverlapResult <MyEntity> > result = new List <MyLineSegmentOverlapResult <MyEntity> >();
MyGamePruningStructure.GetAllEntitiesInRay(ref testRay, result);
foreach (var resultItem in result)
{
IMyCubeGrid grid = resultItem.Element as IMyCubeGrid;
IMyDestroyableObject destroyableEntity = resultItem.Element as IMyDestroyableObject;
if (grid != null)
{
IMySlimBlock slimblock;
double hitd;
Vector3D?resultVec = grid.GetLineIntersectionExactAll(ref testRay, out hitd, out slimblock);
if (resultVec != null)
{
hitBool = true;
toTarget = from + subpart2.WorldMatrix.Forward * hitd;
if (!MyAPIGateway.Session.CreativeMode)
{
slimblock.DoDamage(beamWeaponInfo.damage * (currentHeat / beamWeaponInfo.maxHeat + 0.2f), MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
else
{
slimblock.DoDamage(beamWeaponInfo.damage * 1.2f, MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
//MyAPIGateway.Utilities.ShowNotification("" + s.BlockDefinition.Id.SubtypeId + " ::: " + resultItem.Distance, 17);
}
}
if (destroyableEntity != null)
{
IMyEntity ent = (IMyEntity)destroyableEntity;
double hitd = (from - ent.WorldMatrix.Translation).Length();
toTarget = from + subpart2.WorldMatrix.Forward * hitd;
hitBool = true;
if (!MyAPIGateway.Session.CreativeMode)
{
destroyableEntity.DoDamage(beamWeaponInfo.damage * (currentHeat / beamWeaponInfo.maxHeat + 0.2f), MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
else
{
destroyableEntity.DoDamage(beamWeaponInfo.damage * 1.2f, MyStringHash.GetOrCompute("Laser"), false, default(MyHitInfo), cubeBlock.EntityId);
}
}
}
// test
lastShootTime = currentShootTime;
lastShootTimeTicks = ticks;
currentHeat += beamWeaponInfo.heatPerTick;
if (currentHeat > beamWeaponInfo.maxHeat)
{
currentHeat = beamWeaponInfo.maxHeat;
overheated = true;
}
}
if (ticks - lastShootTimeTicks < 3)
{
var beamcolor = Color.DodgerBlue;
var beamcolor_aux = Color.LightSkyBlue;
var maincolor = new Vector4(beamcolor.X / 30, beamcolor.Y / 30, beamcolor.Z / 30, 1f);
var auxcolor = new Vector4(beamcolor_aux.X / 30, beamcolor_aux.Y / 30, beamcolor_aux.Z / 30, 1f);
var material = MyStringId.GetOrCompute("WeaponLaser");
if (hitBool == false)
{
if (!MyAPIGateway.Utilities.IsDedicated)
{
if (!MyAPIGateway.Session.CreativeMode)
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref auxcolor, 0.30f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref maincolor, 1.0f);
}
else
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref auxcolor, 0.30f * 1.2f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, to, material, ref maincolor, 1.0f * 1.2f);
}
}
}
else
{
if (!MyAPIGateway.Utilities.IsDedicated)
{
if (!MyAPIGateway.Session.CreativeMode)
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref auxcolor, 0.30f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref maincolor, 1.0f);
}
else
{
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref auxcolor, 0.30f * 1.2f);
VRage.Game.MySimpleObjectDraw.DrawLine(from, toTarget, material, ref maincolor, 1.0f * 1.2f);
}
}
}
}
if (chargesInInventory < beamWeaponInfo.keepAtCharge)
{
if (resourceSink.RequiredInputByType(electricityDefinition) != (beamWeaponInfo.powerUsage / efficiencyUpgrades))
{
resourceSink.SetRequiredInputByType(electricityDefinition, (beamWeaponInfo.powerUsage / efficiencyUpgrades));
setPowerConsumption = (beamWeaponInfo.powerUsage / efficiencyUpgrades);
powerConsumption = (beamWeaponInfo.powerUsage / efficiencyUpgrades);
}
else
{
if (!functionalBlock.Enabled)
{
powerConsumption = 0.0001f;
}
}
if (resourceSink.CurrentInputByType(electricityDefinition) == (beamWeaponInfo.powerUsage / efficiencyUpgrades))
{
if (!overheated)
{
m_inventory.AddItems((MyFixedPoint)(beamWeaponInfo.keepAtCharge - chargesInInventory), chargeObjectBuilders [damageUpgrades]);
}
}
}
else if (chargesInInventory > beamWeaponInfo.keepAtCharge)
{
m_inventory.RemoveItemsOfType((MyFixedPoint)(chargesInInventory - beamWeaponInfo.keepAtCharge), chargeObjectBuilders [damageUpgrades]);
}
else
{
if (setPowerConsumption != 0.0001f)
{
resourceSink.SetRequiredInputByType(electricityDefinition, 0.0001f);
setPowerConsumption = 0.0001f;
powerConsumption = 0.0001f;
}
}
terminalBlock.RefreshCustomInfo();
ticks++;
}