/// <summary> /// Adds thruster to thrustersInDirection /// </summary> /// <param name="thruster">The new thruster</param> private void newThruster(MyThrust thruster) { Log.DebugLog("thruster == null", Logger.severity.ERROR, condition: thruster == null); if (TP_ThrustOverride == null) { TP_ThrustOverride = thruster.GetProperty("Override") as ITerminalProperty <float>; } using (lock_thrustersInDirection.AcquireExclusiveUsing()) m_thrustersInDirection[(int)Base6Directions.GetFlippedDirection(thruster.Orientation.Forward)].Add(thruster); if (TP_ThrustOverride.GetValue(thruster) != 0f) { TP_ThrustOverride.SetValue(thruster, 0f); } }
public static float CalculatedThrustScalar(MyThrust thruster, bool inAtmosphere, float planetaryInfluence) { float result = 1f; MyThrustDefinition definition = thruster.BlockDefinition; if (definition.NeedsAtmosphereForInfluence && !inAtmosphere) { result = definition.EffectivenessAtMinInfluence; } else if (Math.Abs(definition.MaxPlanetaryInfluence - definition.MinPlanetaryInfluence) > 0) { float value = (planetaryInfluence - definition.MinPlanetaryInfluence) * definition.InvDiffMinMaxPlanetaryInfluence; result = MathHelper.Lerp(definition.EffectivenessAtMinInfluence, definition.EffectivenessAtMaxInfluence, MathHelper.Clamp(value, 0f, 1f)); } return(result); }
public void SetupGrid() { foreach (MyCubeBlock block in _thisGrid.GetFatBlocks()) { MyThrust myThrust = block as MyThrust; if (myThrust != null) { _gridSystems.ControllableThrusters.AddNewThruster(myThrust); WriteToLog("SetupGrid", $"Adding Thruster {myThrust.GridThrustDirection}", LogType.General); continue; } MyGyro myGyro = block as MyGyro; if (myGyro != null) { _gridSystems.ControllableGyros.Add(myGyro); WriteToLog("SetupGrid", $"Adding Gyro", LogType.General); continue; } IMyTextSurface surface = block as IMyTextSurface; if (surface != null) { if (((IMyTerminalBlock)surface).CustomData.Contains("DebugL")) { _gridSystems.DebugScreens.AddLeftScreen(surface); _gridSystems.DebugScreens.WriteToLeft(new StringBuilder("Left Debug Screen Detected")); WriteToLog("SetupGrid", $"Adding Left Debug Screen", LogType.General); } if (((IMyTerminalBlock)surface).CustomData.Contains("DebugR")) { _gridSystems.DebugScreens.AddRightScreen(surface); _gridSystems.DebugScreens.WriteToRight(new StringBuilder("Right Debug Screen Detected")); WriteToLog("SetupGrid", $"Adding Right Debug Screen", LogType.General); } continue; } IMyLandingGear gear = block as IMyLandingGear; if (gear == null) { continue; } _gridSystems.ControllableLandingGear.Add(gear); } }
internal void <UpdateFlameAnimatorData> b__8_0(FlameData d, MyThrust t) { MatrixD localMatrix = t.PositionComp.LocalMatrix; d.LightPosition = Vector3D.TransformNormal(t.Flames[0].Position, localMatrix) + localMatrix.Translation; d.Flames = t.Flames; d.FlareSize = t.Flares.Size; d.Glares = t.Flares.SubGlares; d.GridScale = t.CubeGrid.GridScale; d.FlareIntensity = t.Flares.Intensity; d.FlamePointMaterial = t.FlamePointMaterial; d.FlameLengthMaterial = t.FlameLengthMaterial; d.GlareQuerySize = t.CubeGrid.GridSize / 2.5f; d.IdleColor = t.BlockDefinition.FlameIdleColor; d.FullColor = t.BlockDefinition.FlameFullColor; d.FlameLengthScale = t.BlockDefinition.FlameLengthScale; }
private bool ApplyHeatup(MyThrust thruster, ref ThrusterBoostInfo boostInfo) { var t = (IMyThrust)thruster; var thrustLevel = t.CurrentThrust / t.MaxThrust; var heatQuant = thrustLevel * HEAT_QUANT; boostInfo.CurrentHeatLevel += heatQuant; if (boostInfo.CurrentHeatLevel >= MAX_HEAT) { boostInfo.CurrentHeatLevel = MAX_HEAT; DisableBooster(thruster, ref boostInfo); return(true); } return(false); }
private void UpdateThrusterOverheatMode(MyThrust thruster, bool enableBoost, ref ThrusterBoostInfo boostInfo) { ApplyCooldown(thruster, ref boostInfo); if (boostInfo.CurrentHeatLevel <= 0f) { thruster.RemoveEffect("Damage"); if (enableBoost) { EnableBooster(thruster, ref boostInfo); boostInfo.Mode = ThrusterMode.Boost; } else { boostInfo.Mode = ThrusterMode.Normal; } } }
private void UpdateThrusterBoostMode(MyThrust thruster, bool enableBoost, ref ThrusterBoostInfo boostInfo) { if (enableBoost) { var overheat = ApplyHeatup(thruster, ref boostInfo); if (overheat) { DisableBooster(thruster, ref boostInfo); boostInfo.Mode = ThrusterMode.Overheat; thruster.SetEffect("Damage", true); } } else { DisableBooster(thruster, ref boostInfo); boostInfo.Mode = ThrusterMode.Normal; } }
private static bool IsOverridden(MyThrust thrust) { var thruster = thrust as MyThrust; if (thruster == null) { return(false); } bool autopilotEnabled = false; MyEntityThrustComponent thrustComp; if (thruster.CubeGrid.Components.TryGet(out thrustComp)) { autopilotEnabled = thrustComp.AutopilotEnabled; } return(thruster.Enabled && thruster.IsFunctional && thruster.ThrustOverride > 0 && !autopilotEnabled); }
private float GetThrusterMaxForce(MyThrust thruster) { float thrusterForce = thruster.BlockDefinition.ForceMagnitude * (thruster as IMyThrust).ThrustMultiplier; if (thruster.BlockDefinition.EffectivenessAtMaxInfluence != 1f || thruster.BlockDefinition.EffectivenessAtMinInfluence != 1f) { if (!CapableAtmo && thruster.BlockDefinition.EffectivenessAtMaxInfluence > thruster.BlockDefinition.EffectivenessAtMinInfluence) { CapableAtmo = true; } if (!CapableSpace && thruster.BlockDefinition.EffectivenessAtMinInfluence > thruster.BlockDefinition.EffectivenessAtMaxInfluence) { CapableSpace = true; } if (m_airDensity <= thruster.BlockDefinition.MinPlanetaryInfluence) { thrusterForce *= thruster.BlockDefinition.EffectivenessAtMinInfluence; } else if (m_airDensity >= thruster.BlockDefinition.MaxPlanetaryInfluence) { thrusterForce *= thruster.BlockDefinition.EffectivenessAtMaxInfluence; } else { float effectRange = thruster.BlockDefinition.EffectivenessAtMaxInfluence - thruster.BlockDefinition.EffectivenessAtMinInfluence; float influenceRange = thruster.BlockDefinition.MaxPlanetaryInfluence - thruster.BlockDefinition.MinPlanetaryInfluence; float effectiveness = (m_airDensity - thruster.BlockDefinition.MinPlanetaryInfluence) * effectRange / influenceRange + thruster.BlockDefinition.EffectivenessAtMinInfluence; //Log.DebugLog("for thruster " + thruster.DisplayNameText + ", effectiveness: " + effectiveness + ", max force: " + thrusterForce + ", effect range: " + effectRange + ", influence range: " + influenceRange); thrusterForce *= effectiveness; } } else { CapableAtmo = true; CapableSpace = true; } return(thrusterForce); }
public void AddNewThruster(MyThrust myThrust) { if (myThrust == null || _thisIController == null) { return; } ControllableThruster thruster = null; if (_thisIController.WorldMatrix.Forward * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Forward); } if (_thisIController.WorldMatrix.Backward * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Back); } if (_thisIController.WorldMatrix.Left * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Left); } if (_thisIController.WorldMatrix.Right * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Right); } if (_thisIController.WorldMatrix.Up * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Up); } if (_thisIController.WorldMatrix.Down * -1 == myThrust.WorldMatrix.Forward) { thruster = new ControllableThruster(myThrust, ThrustDirection.Down); } if (thruster == null) { return; } thruster.OnClose += CloseThruster; _thrusters[thruster.ThrustDirection].Add(thruster); RecalculateMaxEffectiveThrust(); }
/// <summary> /// if removed is a thruster, remove it from thrustersInDirection /// </summary> /// <remarks> /// if a working block is destroyed, block_IsWorkingChange() is called first /// </remarks> /// <param name="removed">block that was removed</param> private void grid_OnBlockRemoved(IMySlimBlock removed) { try { if (removed.FatBlock == null) { return; } MyThrust asThrust = removed.FatBlock as MyThrust; if (asThrust == null) { return; } using (lock_thrustersInDirection.AcquireExclusiveUsing()) m_thrustersInDirection[(int)Base6Directions.GetFlippedDirection(asThrust.Orientation.Forward)].Remove(asThrust); Log.DebugLog("removed thruster = " + removed.FatBlock.DefinitionDisplayNameText + "/" + asThrust.DisplayNameText, Logger.severity.DEBUG); return; } catch (Exception e) { Log.AlwaysLog("Exception: " + e, Logger.severity.ERROR); } }
public MySyncThruster(MyThrust block) { m_block = block; }
public static float CalculatedCurrentPower(MyThrust thruster) { return((((IMyThrust)thruster).CurrentThrust / ((IMyThrust)thruster).MaxThrust) * thruster.MaxPowerConsumption); }
public override void Close() { linkedThruster = null; }
public static float CalculatedMaxThrust(MyThrust thruster, bool inAtmosphere) { return(thruster.BlockDefinition.ForceMagnitude * ((IMyThrust)thruster).ThrustMultiplier * CalculatedThrustScalar(thruster, inAtmosphere)); }
public static float AdjustedMaxPower(MyThrust thruster, bool inAtmosphere) { // Atmospheric thrusters get scaled based on where in the atmospheric layer they are return(thruster.MaxPowerConsumption * CalculatedThrustScalar(thruster, inAtmosphere)); }
public MyDebugRenderComponentThrust(MyThrust thrust) : base(thrust) { this.m_thrust = thrust; }
public override void UpdateBeforeSimulation() { try { if (!block.IsFunctional) // only works if it's at full integrity, power status is irelevant { return; } MyCubeGrid grid = block.CubeGrid; if (grid.Physics == null || !grid.Physics.Enabled) { return; } if (linkedThruster == null) { if (++linkSkip >= 60) { linkSkip = 0; Vector3I pos = grid.WorldToGridInteger(block.WorldMatrix.Translation + block.WorldMatrix.Backward * grid.GridSize); IMySlimBlock slim = grid.GetCubeBlock(pos) as IMySlimBlock; MyThrust thrust = slim?.FatBlock as MyThrust; if (thrust != null) { double alignDot = Math.Round(Vector3.Dot(thrust.WorldMatrix.Backward, block.WorldMatrix.Backward), 1); if (alignDot == 1 && ThrustReversersMod.Instance.LinkableThrusters.Contains(thrust.BlockDefinition.Id.SubtypeName)) { linkedThruster = thrust; ThrustBlock logic = linkedThruster.GameLogic.GetAs <ThrustBlock>(); logic.Reverser = this; } } } return; } if (linkedThruster.Closed || linkedThruster.MarkedForClose) { linkedThruster = null; return; } if (!linkedThruster.IsWorking) { return; } float closedRatio = (block.FullyClosed ? 1 : (block.FullyOpen ? 0 : (1 - (block.OpenRatio / def.OpeningSequence[0].MaxOpen)))); // HACK OpenRatio fix ReflectedThrust = Math.Max(closedRatio - 0.4f, 0) / 0.6f; if (ReflectedThrust > 0 && linkedThruster.CurrentStrength > 0) { Vector3D force = linkedThruster.WorldMatrix.Forward * linkedThruster.BlockDefinition.ForceMagnitude * linkedThruster.CurrentStrength * 1.75 * ReflectedThrust; Vector3D forceAt = (ThrustReversersMod.Instance.RealisticThrustersInstalled ? linkedThruster.WorldMatrix.Translation : grid.Physics.CenterOfMassWorld); // Realistic Thrusters Mod support grid.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_FORCE, force, forceAt, null); } } catch (Exception e) { Log.Error(e); } }
public bool IsRegistered(MyThrust thrust) { Debug.Assert(thrust != null); return(m_thrustsByDirection[thrust.ThrustForwardVector].Contains(thrust)); }
private static bool IsOverridden(MyThrust thrust) { return(thrust.Enabled && thrust.IsFunctional && thrust.ThrustOverride > 0); }
// ReSharper disable once InconsistentNaming private static void InitPatch(MyThrust __instance) { _thrustOverride.GetSync <float>(__instance).ValueChangedInRange(0, 100); }
public ThrustWrapper(MySlimBlock block) : base(block) { Block = (MyThrust)block.FatBlock; }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { Block = (MyThrust)Entity; Block.IsWorkingChanged += WorkingChanged; }
public override void UpdateOnceBeforeFrame() { try { if (ThrustReversersMod.Instance == null || !ThrustReversersMod.Instance.IsPlayer) { return; } thrust = (MyThrust)Entity; MyCubeGrid grid = thrust.CubeGrid; if (grid?.Physics == null || !grid.Physics.Enabled) { return; } ThrustReversersMod.Instance.ThrustLogicDraw.Add(this); switch (thrust.BlockDefinition.Id.SubtypeName) { case "LargeBlockLargeAtmosphericThrust": maxViewDistSq = 1200; length = 5f; thickness = 1.6f; trailOffset = -3f; lightOffset = 0.75f; lightJetOffset = 1.75f; pointOffset = 0f; pointScaleMul = 1.3f; coneOffset = -3.5f; coneHeight = 18f; coneRadius = 2.65f; break; case "LargeBlockSmallAtmosphericThrust": maxViewDistSq = 800; length = 3f; thickness = 0.5f; trailOffset = -1f; lightOffset = 0f; lightJetOffset = 1.75f; pointOffset = 0f; pointScaleMul = 1.4f; coneOffset = -1.75f; coneHeight = 10f; coneRadius = 0.8f; break; case "SmallBlockLargeAtmosphericThrust": maxViewDistSq = 500; length = 1f; thickness = 0.325f; trailOffset = -0.5f; lightOffset = 0.75f; lightJetOffset = 1.75f; pointOffset = 0.325f; pointScaleMul = 1.1f; coneOffset = 0f; coneHeight = 2f; coneRadius = 0.4225f; break; case "SmallBlockSmallAtmosphericThrust": maxViewDistSq = 300; length = 0.75f; thickness = 0.1f; trailOffset = -0.5f; lightOffset = 0.75f; lightJetOffset = 1.5f; pointOffset = 0.15f; pointScaleMul = 1.4f; coneOffset = -0.05f; coneHeight = 1.2f; coneRadius = 0.15f; break; } maxViewDistSq *= maxViewDistSq; light = MyLights.AddLight(); light.Start("ThrustLight"); light.LightOn = false; lightJet = MyLights.AddLight(); lightJet.Start("ThrustJetLight"); lightJet.LightOn = false; } catch (Exception e) { Log.Error(e); } }
private static bool IsOverridden(MyThrust thrust) { return(thrust.Enabled && thrust.IsFunctional && thrust.ThrustOverride > 0 && !thrust.CubeGrid.GridSystems.ThrustSystem.AutopilotEnabled); }
public override void OnAddedToContainer() { base.OnAddedToContainer(); m_thrust = Container.Entity as MyThrust; }
private static bool IsUsed(MyThrust thrust) { // Overridden thrusts are calculated separately return(thrust.Enabled && thrust.IsFunctional && thrust.ThrustOverride == 0); }
public override void Init(MyObjectBuilder_EntityBase objectBuilder) { Block = (MyThrust)Entity; NeedsUpdate |= MyEntityUpdateEnum.EACH_FRAME; }
public override void OnAddedToContainer(MyComponentContainer container) { base.OnAddedToContainer(container); m_thrust = Entity as MyThrust; }