public bool AtWaypoint(Waypoint w)
{
if (w.Position != Vector3.One && w.Position != Vector3.Zero)
{
var speed = (float)(Controller.GetShipVelocities().LinearVelocity - w.Velocity).Length();
Vector3D posError = Destination - Reference.WorldMatrix.Translation;
var distance = (float)posError.Length();
if (distance > 0.25f || speed > 0.25f)
{
return(false);
}
}
if (w.Direction != Vector3.One && w.Direction != Vector3.Zero)
{
if (VectorHelpers.VectorAngleBetween(Reference.WorldMatrix.Forward, ForwardDir) > 0.03f)
{
return(false);
}
}
if (w.DirectionUp != Vector3.One && w.DirectionUp != Vector3.Zero)
{
if (VectorHelpers.VectorAngleBetween(Reference.WorldMatrix.Up, UpDir) > 0.03f)
{
return(false);
}
}
return(true);
}
void GetRotationAngles(Vector3D v_target, Vector3D v_front, Vector3D v_left, Vector3D v_up, out double yaw, out double pitch)
{
//Dependencies: VectorProjection() | VectorAngleBetween()
var projectTargetUp = VectorHelpers.VectorProjection(v_target, v_up);
var projTargetFrontLeft = v_target - projectTargetUp;
yaw = VectorHelpers.VectorAngleBetween(v_front, projTargetFrontLeft);
if (Vector3D.IsZero(projTargetFrontLeft) && !Vector3D.IsZero(projectTargetUp)) //check for straight up case
{
pitch = MathHelper.PiOver2;
}
else
{
pitch = VectorHelpers.VectorAngleBetween(v_target, projTargetFrontLeft); //pitch should not exceed 90 degrees by nature of this definition
}
//---Check if yaw angle is left or right
//multiplied by -1 to convert from right hand rule to left hand rule
yaw = -1 * Math.Sign(v_left.Dot(v_target)) * yaw;
//---Check if pitch angle is up or down
pitch = Math.Sign(v_up.Dot(v_target)) * pitch;
//---Check if target vector is pointing opposite the front vector
if (Math.Abs(yaw) <= 1E-6 && v_target.Dot(v_front) < 0)
{
yaw = Math.PI;
}
}
void SetGyroPowers(bool fake = false)
{
if (fake)
{
return;
}
if (reference == null)
{
return;
}
double yawAngle = 0, pitchAngle = 0, spinAngle = 0;
if (targetDirection != Vector3.Zero || targetUp != Vector3.Zero)
{
if (targetDirection != Vector3.Zero)
{
GetRotationAngles(targetDirection, reference.WorldMatrix.Forward, reference.WorldMatrix.Left, reference.WorldMatrix.Up, out yawAngle, out pitchAngle);
}
if (targetUp != Vector3.Zero)
{
var projectedTargetUp = targetUp - reference.WorldMatrix.Forward.Dot(targetUp) * reference.WorldMatrix.Forward;
spinAngle = -1 * VectorHelpers.VectorAngleBetween(reference.WorldMatrix.Up, projectedTargetUp) * Math.Sign(reference.WorldMatrix.Left.Dot(targetUp));
}
if (DYaw == 0)
{
DYaw = yawAngle;
}
if (DPitch == 0)
{
DPitch = pitchAngle;
}
IYaw += yawAngle * kRunEveryXUpdates;
IPitch += pitchAngle * kRunEveryXUpdates;
// no point in trying to spin over 180 deg in a direction.
IYaw = MathHelper.Clamp(IYaw, -1.0, 1.0);
IPitch = MathHelper.Clamp(IPitch, -1.0, 1.0);
ApplyGyroOverride(pitchAngle * RP + (pitchAngle - DPitch) * RD * kInverseTimeStep + IPitch * RI, yawAngle * RP + (yawAngle - DYaw) * RD * kInverseTimeStep + IYaw * RI, spinAngle * RP, gyros, reference);
}
if (!Persist && Math.Abs(yawAngle) < 0.01f && Math.Abs(pitchAngle) < 0.01f && Math.Abs(spinAngle) < 0.01f)
{
targetDirection = Vector3.Zero;
targetUp = Vector3.Zero;
}
if (targetDirection == Vector3.Zero && targetUp == Vector3.Zero)
{
ClearGyros();
}
}
public void Turn(MatrixD Reference, Vector3D target)
{
if (Reference == MatrixD.Zero)
{
return;
}
MatrixD orientationMatrix = MatrixD.Identity;
orientationMatrix.Translation = Reference.Translation;
Vector3D orientationForward = Controller.WorldMatrix.Forward + Controller.WorldMatrix.Down + Controller.WorldMatrix.Left;
orientationForward.Normalize();
orientationMatrix.Forward = orientationForward;
Vector3D orientationUp = Reference.Forward;
orientationUp -= VectorHelpers.VectorProjection(orientationUp, orientationForward);
orientationUp.Normalize();
orientationMatrix.Up = orientationUp;
Vector3D OrientationRight = orientationForward.Cross(orientationUp);
orientationMatrix.Right = OrientationRight;
var gravDir = Controller.GetNaturalGravity();
gravDir.Normalize();
double yawAngle, pitchAngle, spinAngle;
GravAngle = VectorHelpers.VectorAngleBetween(gravDir, orientationMatrix.Forward);
if (target != Vector3D.Zero && GravAngle < Math.PI * 0.1)
{
Vector3D TargetDir = target - orientationMatrix.Translation;
TargetDir.Normalize();
var projectedTargetUp = TargetDir - VectorHelpers.VectorProjection(TargetDir, orientationForward);
spinAngle = -1 * VectorHelpers.VectorAngleBetween(orientationMatrix.Up, projectedTargetUp) * Math.Sign(orientationMatrix.Left.Dot(TargetDir));
}
else
{
spinAngle = 0;
SpinPID.Reset();
}
TrigHelpers.GetRotationAngles(gravDir, orientationMatrix.Forward, orientationMatrix.Left, orientationMatrix.Up, out yawAngle, out pitchAngle);
TrigHelpers.ApplyGyroOverride(PitchPID.Control(pitchAngle), YawPID.Control(yawAngle), SpinPID.Control(spinAngle), Gyros, orientationMatrix);
}
public bool AtWaypoint(Waypoint w)
{
if (Persist)
{
return(false);
}
if (w.Position != Vector3.One && w.Position != Vector3.Zero)
{
var speed = (float)(controller.GetShipVelocities().LinearVelocity - w.Velocity).Length();
Vector3D posError = (targetPosition - reference.WorldMatrix.Translation);
var distance = (float)posError.Length();
if (distance > 0.25f || speed > 0.25f)
{
return(false);
}
}
if (w.Direction != Vector3.One && w.Direction != Vector3.Zero)
{
double yawAngle, pitchAngle;
GetRotationAngles(w.Direction, reference.WorldMatrix.Forward, reference.WorldMatrix.Left, reference.WorldMatrix.Up, out yawAngle, out pitchAngle);
if (Math.Abs(yawAngle) > 0.03f || Math.Abs(pitchAngle) > 0.03f)
{
return(false);
}
}
if (w.DirectionUp != Vector3.One && w.DirectionUp != Vector3.Zero)
{
var projectedTargetUp = targetUp - reference.WorldMatrix.Forward.Dot(targetUp) * reference.WorldMatrix.Forward;
var spinAngle = -1 * VectorHelpers.VectorAngleBetween(reference.WorldMatrix.Up, projectedTargetUp) * Math.Sign(reference.WorldMatrix.Left.Dot(targetUp));
if (Math.Abs(spinAngle) > 0.03f)
{
return(false);
}
}
return(true);
}
public void Update()
{
LifeTimeTicks++;
// Startup Subroutine
if (LifeTimeTicks == 1)
{
foreach (var engine in Drive.HoverEngines)
{
engine.AltitudeMin = 1;
engine.PushOnly = true;
}
}
if (LifeTimeTicks == 60)
{
foreach (var engine in Drive.HoverEngines)
{
engine.AltitudeMin = 2;
}
}
if (LifeTimeTicks == 120)
{
foreach (var engine in Drive.HoverEngines)
{
engine.AltitudeMin = 7;
}
}
if (LifeTimeTicks % kRunEveryXUpdates == 0)
{
Vector3D PlanetDir = PlanetPos - Controller.WorldMatrix.Translation;
PlanetDir.Normalize();
// Orient Self
Drive.Turn(Gats.Count > 0 ? Gats[0].WorldMatrix : Controller.WorldMatrix, target);
// Aim Turret
if (TurretRotor != null)
{
if (target != Vector3D.Zero && Drive.GravAngle < Math.PI * 0.1)
{
var TurretAngle = TrigHelpers.FastAsin(Gats[0].WorldMatrix.Forward.Dot(PlanetDir));
Vector3D TargetDir = target - Gats[0].WorldMatrix.Translation;
var targetDist = TargetDir.Length();
TargetDir.Normalize();
var TargetAngle = TrigHelpers.FastAsin(TargetDir.Dot(PlanetDir));
var angleDiff = TargetAngle - TurretAngle;
if (VectorHelpers.VectorAngleBetween(Gats[0].WorldMatrix.Forward, TargetDir) < 0.05 && targetDist < 800)
{
Fire();
}
TurretRotor.TargetVelocityRPM = (float)TurretPID.Control(angleDiff);
}
else
{
TurretPID.Reset();
TurretRotor.TargetVelocityRPM = 0;
}
}
// Check your fire
fireTicks--;
if (fireTicks == -1)
{
foreach (var gat in Gats)
{
TerminalPropertiesHelper.SetValue(gat, "Shoot", false);
}
}
// Check Movement
if (Destination != Vector3D.Zero)
{
Drive.Drive(Destination);
if (Drive.Arrived)
{
Destination = Vector3D.Zero;
Drive.Flush();
}
}
}
}
public void Update(TimeSpan timestamp, UpdateFrequency updateFlags)
{
runs++;
if (runs % 5 == 0)
{
statusBuilder.Clear();
indicatorBuilder.Clear();
bool firing = false;
var index = Indicator.CustomName.IndexOf('|') + 1;
if (index <= 0)
{
return;
}
string originalName = Indicator.CustomName.Substring(0, index);
if (Context.WCAPI == null)
{
return;
}
var gravDir = IntelProvider.Controller.GetNaturalGravity();
var gravStr = gravDir.Normalize();
if (!active)
{
indicatorBuilder.Append("OFF");
NeutralControl(gravDir);
}
else
{
var target = Context.WCAPI.GetAiFocus(Context.Reference.CubeGrid.EntityId);
if (!target.HasValue || target.Value.IsEmpty())
{
indicatorBuilder.Append("NO TGT");
NeutralControl(gravDir);
}
else
{
var velocity = IntelProvider.Controller.GetShipVelocities().LinearVelocity;
var relativeVector = target.Value.Position - IntelProvider.Controller.WorldMatrix.Translation;
var relativeVelocity = target.Value.Velocity - velocity;
var planarVector = relativeVector - VectorHelpers.VectorProjection(relativeVector, gravDir);
planarVector.Normalize();
var targetPos = target.Value.Position - gravDir * range + planarVector * 50;
statusBuilder.AppendLine((gravDir * range).ToString());
Drive.Move(targetPos);
if ((targetPos - IntelProvider.Controller.WorldMatrix.Translation).Length() < 100)
{
Drive.Move(Vector3D.Zero);
}
Drive.Drift(target.Value.Velocity);
var VerticalAngleToTarget = VectorHelpers.VectorAngleBetween(gravDir, relativeVector);
planarVector -= gravDir * Math.Tan(VerticalAngleToTarget > 20 * Math.PI / 180 ? 0 : VerticalAngleToTarget);
Drive.Turn(planarVector);
Drive.Spin(-gravDir);
indicatorBuilder.Append("TGT:");
indicatorBuilder.Append(target.Value.Name.Length > 4 ? target.Value.Name.Substring(0, 4) : target.Value.Name);
indicatorBuilder.Append(" - DIST:");
indicatorBuilder.Append(relativeVector.Length().ToString("F"));
indicatorBuilder.Append(" - STUS:");
// Fire control
if (VerticalAngleToTarget > 20 * Math.PI / 180)
{
indicatorBuilder.Append(" APPROACH");
}
else
{
indicatorBuilder.Append(" AIM ");
var angleToTargetDegrees = VectorHelpers.VectorAngleBetween(Gun.WorldMatrix.Forward, relativeVector) * 180 / Math.PI;
indicatorBuilder.Append(angleToTargetDegrees.ToString("F"));
if (angleToTargetDegrees < 0.5 && Context.WCAPI.IsWeaponReadyToFire(Gun))
{
indicatorBuilder.Clear();
indicatorBuilder.Append("FIRING!");
firing = true;
}
}
}
}
Indicator.CustomName = originalName + " " + indicatorBuilder.ToString();
Context.WCAPI.ToggleWeaponFire(Gun, firing, true);
}
}
public void Update(TimeSpan timestamp, UpdateFrequency updateFlags)
{
runs++;
if (runs % 10 == 0)
{
indicatorBuilder.Clear();
var index = Indicator.CustomName.IndexOf('|') + 1;
if (index <= 0)
{
return;
}
string originalName = Indicator.CustomName.Substring(0, index);
if (Context.WCAPI == null)
{
return;
}
var rotationIndicator = Vector3.NegativeInfinity;
var movementIndicator = Vector3.NegativeInfinity;
if (!active)
{
indicatorBuilder.Append("OFF");
}
else
{
var target = Context.WCAPI.GetAiFocus(Context.Reference.CubeGrid.EntityId);
if (target == null)
{
indicatorBuilder.Append("NO TGT");
}
else
{
var gravDir = IntelProvider.Controller.GetNaturalGravity();
var gravStr = gravDir.Normalize();
var velocity = IntelProvider.Controller.GetShipVelocities().LinearVelocity;
var relativeVector = target.Value.Position - IntelProvider.Controller.WorldMatrix.Translation;
var relativeVelocity = target.Value.Velocity - velocity;
var heightSquared = VectorHelpers.VectorProjection(relativeVector, gravDir).LengthSquared();
var relativeplanarDir = relativeVector - VectorHelpers.VectorProjection(relativeVector, gravDir);
var relativeplanarDist = relativeplanarDir.Normalize();
var relativePlanarVelocity = relativeVelocity - VectorHelpers.VectorProjection(relativeVelocity, gravDir);
// Attack dir
var relativeAttackPoint = AttackHelpers.GetAttackPoint(relativeVelocity, relativeVector, projectileSpeed);
var attackPlanarVector = relativeAttackPoint - VectorHelpers.VectorProjection(relativeAttackPoint, gravDir);
var attackPlanarLeft = IntelProvider.Controller.WorldMatrix.Left - VectorHelpers.VectorProjection(IntelProvider.Controller.WorldMatrix.Left, gravDir);
attackPlanarLeft.Normalize();
var attackPlanarForward = IntelProvider.Controller.WorldMatrix.Forward - VectorHelpers.VectorProjection(IntelProvider.Controller.WorldMatrix.Forward, gravDir);
attackPlanarForward.Normalize();
var spinAngle = VectorHelpers.VectorAngleBetween(attackPlanarForward, attackPlanarVector) * Math.Sign(-attackPlanarLeft.Dot(attackPlanarVector));
rotationIndicator.Y = (float)spinAngle;
// Movement
var myPlanarVelocity = velocity - VectorHelpers.VectorProjection(relativeAttackPoint, gravDir);
var targetPlanarDist = Math.Sqrt(range * range - heightSquared);
var targetPlanarPoint = relativeplanarDir * (relativeplanarDist - targetPlanarDist);
var desiredRelativeVelocity = targetPlanarPoint * 0.5 + relativePlanarVelocity - myPlanarVelocity;
desiredRelativeVelocity.Normalize();
movementIndicator.X = (float)desiredRelativeVelocity.Dot(IntelProvider.Controller.WorldMatrix.Right);
movementIndicator.Z = (float)desiredRelativeVelocity.Dot(IntelProvider.Controller.WorldMatrix.Backward);
indicatorBuilder.Append("TGT:");
indicatorBuilder.Append(target.Value.Name.Substring(0, 4));
indicatorBuilder.Append(" - DIST:");
indicatorBuilder.Append(relativeVector.Length().ToString("F"));
indicatorBuilder.Append(" - ");
indicatorBuilder.Append(movementIndicator.X.ToString("F"));
indicatorBuilder.Append(",");
indicatorBuilder.Append(movementIndicator.Z.ToString("F"));
indicatorBuilder.Append(" -- ");
indicatorBuilder.Append(spinAngle.ToString("F"));
}
}
Indicator.CustomName = originalName + " " + indicatorBuilder.ToString();
Drive.RotationIndicatorOverride = rotationIndicator;
Drive.MoveIndicatorOverride = movementIndicator;
}
}
public void Update(TimeSpan timestamp, UpdateFrequency updateFlags)
{
if (runs % 240 == 0)
{
statusBuilder.Clear();
foreach (var tube in LandpedoTubes)
{
tube.CheckLandpedo();
// statusBuilder.AppendLine(tube.GetStatus());
}
}
if (runs % 10 == 0)
{
statusBuilder.Clear();
var targets = IntelProvider.GetFleetIntelligences(timestamp);
var canonicalTime = IntelProvider.CanonicalTimeDiff + timestamp;
DeadLandpedos.Clear();
foreach (var landpedo in Landpedos)
{
statusBuilder.AppendLine("LANDPEDO===");
if (landpedo.Fired)
{
landpedo.DeadCount--;
}
if (!landpedo.IsOK())
{
DeadLandpedos.Add(landpedo);
continue;
}
landpedo.runs++;
var landpedoPosition = landpedo.Controller.WorldMatrix.Translation;
var landpedoVelocity = landpedo.Controller.GetShipVelocities().LinearVelocity;
var gravDir = landpedo.Controller.GetNaturalGravity();
var gravStr = gravDir.Normalize();
var planarVelocity = landpedoVelocity - VectorHelpers.VectorProjection(landpedoVelocity, gravDir);
if (landpedo.TargetID != -1)
{
var key = MyTuple.Create(IntelItemType.Enemy, landpedo.TargetID);
if (targets.ContainsKey(key))
{
var target = targets[key];
landpedo.TargetPosition = target.GetPositionFromCanonicalTime(canonicalTime);
landpedo.TargetVelocity = target.GetVelocity();
}
}
statusBuilder.AppendLine(landpedo.TargetPosition.ToString());
if (landpedo.TargetPosition != Vector3D.Zero)
{
var relativeVector = landpedo.TargetPosition - landpedoPosition;
var planarVector = relativeVector - VectorHelpers.VectorProjection(relativeVector, gravDir);
var targetPoint = AttackHelpers.GetAttackPoint(landpedo.TargetVelocity, landpedo.TargetPosition - landpedoPosition, landpedo.lastSpeed);
if (targetPoint == Vector3D.Zero)
{
targetPoint = landpedo.TargetPosition - landpedoPosition;
}
var targetPointDist = targetPoint.Length();
var planarDist = planarVector.Length();
var velocity = landpedo.Controller.GetShipVelocities().LinearVelocity;
var verticalVelocity = VectorHelpers.VectorProjection(velocity, gravDir);
var planarLeft = landpedo.Controller.WorldMatrix.Left - VectorHelpers.VectorProjection(landpedo.Controller.WorldMatrix.Left, gravDir);
planarLeft.Normalize();
var planarForward = landpedo.Controller.WorldMatrix.Forward - VectorHelpers.VectorProjection(landpedo.Controller.WorldMatrix.Forward, gravDir);
planarForward.Normalize();
double altitude;
landpedo.Controller.TryGetPlanetElevation(MyPlanetElevation.Surface, out altitude);
if (targetPointDist > 350 || landpedo.Launchers.Count == 0)
{
landpedo.desiredAltitude = planarVector.Length() > 200 ? 10 : 50;
planarVector.Normalize();
MatrixD orientationMatrix = MatrixD.Identity;
orientationMatrix.Translation = landpedo.Controller.WorldMatrix.Translation;
orientationMatrix.Up = -gravDir;
orientationMatrix.Left = planarLeft;
orientationMatrix.Forward = planarForward;
var spinAngle = VectorHelpers.VectorAngleBetween(planarForward, planarVector) * Math.Sign(-planarLeft.Dot(planarVector));
// var planarVelocity = velocity - verticalVelocity;
// var velocityAdjust = planarVelocity - VectorHelpers.VectorProjection(velocity, planarVector);
// velocityAdjust.Normalize();
// planarVector -= velocityAdjust;
// var MoveIndicator = Vector3D.TransformNormal(planarVector, MatrixD.Transpose(orientationMatrix));
var rangeVector = planarVector;
var waypointVector = rangeVector;
var distTargetSq = rangeVector.LengthSquared();
var targetPlanarVelocity = landpedo.TargetVelocity - VectorHelpers.VectorProjection(landpedo.TargetVelocity, gravDir);
Vector3D velocityVector = targetPlanarVelocity - planarVelocity;
var speed = planarVelocity.Length();
Vector3D AccelerationVector;
double alignment = planarVelocity.Dot(ref waypointVector);
if (alignment > 0)
{
Vector3D rangeDivSqVector = waypointVector / waypointVector.LengthSquared();
Vector3D compensateVector = velocityVector - (velocityVector.Dot(ref waypointVector) * rangeDivSqVector);
Vector3D targetANVector;
var targetAccel = (landpedo.lastTargetVelocity - targetPlanarVelocity) * 0.16667;
targetANVector = targetAccel - (targetAccel.Dot(ref waypointVector) * rangeDivSqVector);
bool accelerating = speed > landpedo.lastSpeed + 1;
if (accelerating)
{
AccelerationVector = planarVelocity + (10 * 1.5 * (compensateVector + (0.5 * targetANVector)));
}
else
{
AccelerationVector = planarVelocity + (10 * (compensateVector + (0.5 * targetANVector)));
}
}
// going backwards or perpendicular
else
{
AccelerationVector = (waypointVector * 0.1) + velocityVector;
}
landpedo.lastTargetVelocity = landpedo.TargetVelocity;
landpedo.lastSpeed = speed;
var MoveIndicator = Vector3D.TransformNormal(AccelerationVector, MatrixD.Transpose(orientationMatrix));
MoveIndicator.Y = 0;
MoveIndicator.Normalize();
statusBuilder.AppendLine(MoveIndicator.ToString());
landpedo.Drive.MoveIndicators = MoveIndicator;
landpedo.Drive.RotationIndicators = new Vector3(0, spinAngle, 0);
landpedo.Drive.Drive();
if (verticalVelocity.Length() > 10 && verticalVelocity.Dot(gravDir) > 0)
{
landpedo.Drive.maxFlightPitch = 20;
landpedo.Drive.maxFlightRoll = 20;
}
else
{
landpedo.Drive.maxFlightPitch = 60;
landpedo.Drive.maxFlightRoll = 60;
}
if (targetPointDist < 1000)
{
landpedo.Drive.maxFlightPitch = 20;
}
}
else if (landpedo.TargetID != -1)
{
var key = MyTuple.Create(IntelItemType.Enemy, landpedo.TargetID);
if (!targets.ContainsKey(key))
{
return;
}
var target = targets[key];
var posDiff = target.GetPositionFromCanonicalTime(canonicalTime) - landpedoPosition;
var avgVel = 400 * Math.Sqrt(posDiff.Length() / 400);
var relativeAttackPoint = AttackHelpers.GetAttackPoint(landpedo.TargetVelocity - velocity, posDiff, avgVel);
targetPointDist = relativeAttackPoint.Length();
double yawAngle, pitchAngle;
TrigHelpers.GetRotationAngles(relativeAttackPoint, landpedo.Controller.WorldMatrix.Forward, landpedo.Controller.WorldMatrix.Left, landpedo.Controller.WorldMatrix.Up, out yawAngle, out pitchAngle);
TrigHelpers.ApplyGyroOverride(landpedo.PitchPID.Control(pitchAngle), landpedo.YawPID.Control(yawAngle), 0, landpedo.Gyros, landpedo.Controller.WorldMatrix);
if ((targetPointDist < 125 || landpedo.minDist < planarDist))
{
foreach (var weapon in landpedo.Launchers)
{
weapon.Enabled = true;
}
landpedo.Fired = true;
}
landpedo.minDist = Math.Min(landpedo.minDist, planarDist);
}
var verticalThrustRatio = TrigHelpers.FastCos(VectorHelpers.VectorAngleBetween(landpedo.Controller.WorldMatrix.Down, gravDir));
var desiredThrust = ((landpedo.desiredAltitude - altitude) + verticalVelocity.LengthSquared() * 0.1 + gravStr) * landpedo.Controller.CalculateShipMass().PhysicalMass / verticalThrustRatio;
var individualThrust = desiredThrust / landpedo.Thrusters.Count();
if (individualThrust <= 0)
{
individualThrust = 0.001;
}
foreach (var thruster in landpedo.Thrusters)
{
thruster.Enabled = ((verticalVelocity.Length() > 20 && verticalVelocity.Dot(gravDir) < 0) || ((verticalVelocity.Length() > 2 && verticalVelocity.Dot(gravDir) < 0) && targetPointDist < 1000)) ? false : true;
thruster.ThrustOverride = (float)individualThrust;
}
statusBuilder.AppendLine($"{landpedo.Drive.thrustController.CalculateThrustToHover()}");
statusBuilder.AppendLine($"{landpedo.Drive.thrustController.upThrusters.Count} : {landpedo.Drive.thrustController.downThrusters.Count}");
}
}
foreach (var landpedo in DeadLandpedos)
{
Landpedos.Remove(landpedo);
}
}
runs++;
}
// Gets the maximum angle deviation from vertical the drone is allowed to operate in
double GetMaxAngleConstraint()
{
var gravAngle = VectorHelpers.VectorAngleBetween(gravDir, Controller.WorldMatrix.Down);
return(Math.Max(gravAngle, MaxAngleDegrees * Math.PI / 180));
}
public void Update(TimeSpan timestamp, UpdateFrequency updateFlags)
{
runs++;
if (runs % 30 == 0)
{
MaxLiftThrust = 0;
MaxLateralThrust = 0;
MaxDownThrust = 0;
foreach (var kvp in Thrusters)
{
if (kvp.Key == Base6Directions.Direction.Down)
{
foreach (var thruster in kvp.Value)
{
MaxLiftThrust += thruster.MaxEffectiveThrust;
}
}
else if (kvp.Key == Base6Directions.Direction.Forward)
{
foreach (var thruster in kvp.Value)
{
MaxLateralThrust += thruster.MaxEffectiveThrust;
}
}
else if (kvp.Key == Base6Directions.Direction.Up)
{
foreach (var thruster in kvp.Value)
{
MaxDownThrust += thruster.MaxEffectiveThrust;
}
}
ThrusterManagers[kvp.Key].RecalculateThrust();
}
}
if (runs % 5 == 0)
{
StatusBuilder.Clear();
shipMass = Controller.CalculateShipMass().PhysicalMass;
gravDir = Controller.GetNaturalGravity();
double yawAngle, pitchAngle, spinAngle;
yawAngle = pitchAngle = spinAngle = 0;
MatrixD orientationMatrix = new MatrixD();
var flatCurrentDir = Controller.WorldMatrix.Forward - VectorHelpers.VectorProjection(Controller.WorldMatrix.Forward, gravDir);
flatCurrentDir.Normalize();
var flatLeftDir = Vector3D.Cross(flatCurrentDir, gravDir);
if (gravDir != Vector3D.Zero)
{
gravStr = gravDir.Length();
gravDir.Normalize();
// Rotational Control
var targetDir = Vector3D.Zero;
if (ForwardDir != Vector3D.Zero)
{
targetDir = ForwardDir;
}
else if (FullAuto)
{
targetDir = Controller.WorldMatrix.Forward - VectorHelpers.VectorProjection(Controller.WorldMatrix.Forward, gravDir);
}
if (targetDir != Vector3D.Zero)
{
if (UpDir == Vector3D.Zero)
{
var angleFromVertical = VectorHelpers.VectorAngleBetween(targetDir, gravDir) - Math.PI * 0.5;
var maxAngleFromVertical = GetMaxAngleConstraint();
angleFromVertical = Math.Max(Math.Min(angleFromVertical, maxAngleFromVertical), -maxAngleFromVertical);
var flatAimDir = targetDir - VectorHelpers.VectorProjection(targetDir, gravDir);
flatAimDir.Normalize();
var downDir = TrigHelpers.FastCos(angleFromVertical) * gravDir + TrigHelpers.FastSin(angleFromVertical) * flatAimDir;
orientationMatrix.Forward = Controller.WorldMatrix.Down;
orientationMatrix.Left = Controller.WorldMatrix.Left;
orientationMatrix.Up = Controller.WorldMatrix.Forward;
spinAngle = -VectorHelpers.VectorAngleBetween(flatAimDir, flatCurrentDir) * Math.Sign(Controller.WorldMatrix.Left.Dot(flatAimDir));
TrigHelpers.GetRotationAngles(downDir, orientationMatrix.Forward, orientationMatrix.Left, orientationMatrix.Up, out yawAngle, out pitchAngle);
}
else
{
orientationMatrix = reference.WorldMatrix;
TrigHelpers.GetRotationAngles(ForwardDir, reference.WorldMatrix.Forward, reference.WorldMatrix.Left, reference.WorldMatrix.Up, out yawAngle, out pitchAngle);
var projectedTargetUp = UpDir - reference.WorldMatrix.Forward.Dot(UpDir) * reference.WorldMatrix.Forward;
spinAngle = -1 * VectorHelpers.VectorAngleBetween(reference.WorldMatrix.Up, projectedTargetUp) * Math.Sign(reference.WorldMatrix.Left.Dot(UpDir));
}
}
}
else if (ForwardDir != Vector3D.Zero)
{
orientationMatrix = reference.WorldMatrix;
TrigHelpers.GetRotationAngles(ForwardDir, reference.WorldMatrix.Forward, reference.WorldMatrix.Left, reference.WorldMatrix.Up, out yawAngle, out pitchAngle);
if (UpDir != Vector3D.Zero)
{
var projectedTargetUp = UpDir - reference.WorldMatrix.Forward.Dot(UpDir) * reference.WorldMatrix.Forward;
spinAngle = -1 * VectorHelpers.VectorAngleBetween(reference.WorldMatrix.Up, projectedTargetUp) * Math.Sign(reference.WorldMatrix.Left.Dot(UpDir));
}
}
if (yawAngle != 0 || pitchAngle != 0 || spinAngle != 0)
{
TrigHelpers.ApplyGyroOverride(PitchPID.Control(pitchAngle), YawPID.Control(yawAngle), gravDir == Vector3D.Zero ? spinAngle : SpinPID.Control(spinAngle), Gyros, orientationMatrix);
}
else
{
foreach (var gyro in Gyros)
{
if (gyro.GyroOverride)
{
gyro.GyroOverride = false;
}
}
}
// Translational Control
if (Destination == Vector3D.Zero && TargetDrift == Vector3D.Zero)
{
foreach (var kvp in ThrusterManagers)
{
kvp.Value.SetThrust(0);
}
if (FullAuto)
{
Controller.DampenersOverride = true;
}
}
else
{
Controller.DampenersOverride = false;
// Compute direction of motion
var destinationDir = Destination - Reference.GetPosition();
var destinationDist = destinationDir.Length();
destinationDir.Normalize();
// Compute current motion to find desired acceleration
var currentVel = Controller.GetShipVelocities().LinearVelocity;
if (destinationDist < 0.25 && currentVel.Length() < 0.25 && TargetDrift == Vector3D.Zero)
{
foreach (var kvp in ThrusterManagers)
{
kvp.Value.SetThrust(0);
}
Controller.DampenersOverride = true;
Destination = Vector3D.Zero;
}
else
{
Vector3D desiredVel = Vector3D.Zero;
if (Destination != Vector3D.Zero)
{
var maxSpeed = Math.Min(MaxSpeed, GetMaxSpeedFromBrakingDistance(destinationDist, GetMaxAccelFromAngleDeviation((float)GetMaxAngleConstraint() * MaxAngleTolerance)) * 0.9);
maxSpeed = Math.Min(maxSpeed, destinationDist * destinationDist + 0.5);
desiredVel = destinationDir * maxSpeed;
}
desiredVel += TargetDrift;
var adjustVector = currentVel - VectorHelpers.VectorProjection(currentVel, desiredVel);
var desiredAccel = desiredVel - currentVel - adjustVector * 2;
// Transform desired acceleration into remote control frame
var gridDesiredAccel = Vector3D.TransformNormal(desiredAccel, MatrixD.Transpose(Controller.WorldMatrix));
double accelMagnitude = gridDesiredAccel.Length();
if (accelMagnitude < PrecisionThreshold)
{
gridDesiredAccel *= Math.Max(accelMagnitude / PrecisionThreshold, .1);
}
gridDesiredAccel.X = XPID.Control(gridDesiredAccel.X);
gridDesiredAccel.Y = YPID.Control(gridDesiredAccel.Y);
gridDesiredAccel.Z = ZPID.Control(gridDesiredAccel.Z);
double MinScale = 10;
var gridGravDir = Vector3D.TransformNormal(gravDir, MatrixD.Transpose(Controller.WorldMatrix));
foreach (var kvp in ThrusterManagers)
{
var desiredDirectionalThrust = -1 * Base6Directions.GetVector(kvp.Key).Dot(gridDesiredAccel) * shipMass;
var gravAssist = Base6Directions.GetVector(kvp.Key).Dot(gridGravDir) * shipMass;
if (desiredDirectionalThrust > 0)
{
MinScale = Math.Min((kvp.Value.MaxThrust - gravAssist) / desiredDirectionalThrust, MinScale);
}
}
gridDesiredAccel *= MinScale;
gridDesiredAccel -= gridGravDir * gravStr;
foreach (var kvp in ThrusterManagers)
{
kvp.Value.SetThrust(-1 * Base6Directions.GetVector(kvp.Key).Dot(gridDesiredAccel + gridGravDir) * shipMass);
}
}
}
}
}
public void Do(Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence> IntelItems, TimeSpan canonicalTime, Profiler profiler)
{
if (canonicalTime == TimeSpan.Zero)
{
return;
}
runs++;
if (MonitorSubsystem != null &&
(MonitorSubsystem.GetPercentage(MonitorOptions.Hydrogen) < 0.2 ||
MonitorSubsystem.GetPercentage(MonitorOptions.Cargo) < 0.02 ||
MonitorSubsystem.GetPercentage(MonitorOptions.Power) < 0.1))
{
GoHome(canonicalTime);
return;
}
IMyShipController controller = Autopilot.Controller;
Vector3D linearVelocity = controller.GetShipVelocities().LinearVelocity;
var currentPosition = controller.WorldMatrix.Translation;
LeadTask.Destination.MaxSpeed = Autopilot.CruiseSpeed;
if (!TargetPositionSet)
{
if (IntelKey.Item1 == IntelItemType.Waypoint && IntelItems.ContainsKey(IntelKey))
{
TargetPosition = IntelItems[IntelKey].GetPositionFromCanonicalTime(canonicalTime);
PatrolMaxSpeed = ((Waypoint)IntelItems[IntelKey]).MaxSpeed;
}
TargetPositionSet = true;
}
EnemyShipIntel orbitIntel = null;
EnemyShipIntel shootIntel = null;
double closestIntelDist = CombatSystem.AlertDist;
foreach (var intel in IntelItems)
{
if (intel.Key.Item1 != IntelItemType.Enemy)
{
continue;
}
var enemyIntel = (EnemyShipIntel)intel.Value;
if (!EnemyShipIntel.PrioritizeTarget(enemyIntel))
{
continue;
}
if (IntelProvider.GetPriority(enemyIntel.ID) < 2)
{
continue;
}
double dist = (enemyIntel.GetPositionFromCanonicalTime(canonicalTime) - controller.WorldMatrix.Translation).Length();
if (IntelKey.Item1 == IntelItemType.Enemy && enemyIntel.ID != IntelKey.Item2 && FocusedTarget)
{
continue;
}
if (enemyIntel.CubeSize == MyCubeSize.Small)
{
dist -= 300;
}
if (IntelProvider.GetPriority(enemyIntel.ID) == 3)
{
dist -= 600;
}
if (IntelProvider.GetPriority(enemyIntel.ID) == 4)
{
dist -= 1200;
}
if (dist < closestIntelDist)
{
closestIntelDist = dist;
shootIntel = enemyIntel;
if (enemyIntel.Radius > 30)
{
orbitIntel = enemyIntel;
}
}
}
if (shootIntel == null && CombatSystem.TargetIntel != null && IntelProvider.GetPriority(CombatSystem.TargetIntel.ID) >= 2)
{
shootIntel = CombatSystem.TargetIntel;
}
if (orbitIntel == null)
{
orbitIntel = shootIntel;
}
var gravdir = Autopilot.Controller.GetNaturalGravity();
if (gravdir != Vector3D.Zero)
{
gravdir.Normalize();
}
// No Target
if (orbitIntel == null)
{
// Plot Intercept
if (IntelKey.Item1 == IntelItemType.Enemy && IntelItems.ContainsKey(IntelKey) && EnemyShipIntel.PrioritizeTarget((EnemyShipIntel)IntelItems[IntelKey]) && IntelProvider.GetPriority(IntelKey.Item2) >= 2)
{
var target = IntelItems[IntelKey];
LeadTask.Destination.Position = currentPosition + AttackHelpers.GetAttackPoint(target.GetVelocity(), target.GetPositionFromCanonicalTime(canonicalTime) + target.GetVelocity() * 0.08 - currentPosition, Autopilot.CruiseSpeed);
}
// Go to Position ( Scramble )
else if (TargetPosition != Vector3.Zero)
{
LeadTask.Destination.MaxSpeed = PatrolMaxSpeed;
LeadTask.Destination.Position = TargetPosition;
}
else
{
GoHome(canonicalTime);
return;
}
Vector3D toTarget = LeadTask.Destination.Position - Program.Me.WorldMatrix.Translation;
if (toTarget.LengthSquared() > 400)
{
if (gravdir == Vector3D.Zero)
{
LeadTask.Destination.Direction = toTarget;
}
else
{
LeadTask.Destination.Direction = Vector3D.Zero;
}
}
else
{
LeadTask.Destination.Direction = Vector3D.Zero;
}
LastAcceleration = Vector3D.Zero;
LastReference = MatrixD.Zero;
LastEnemyVelocity = Vector3D.Zero;
LastEnemyPosition = Vector3D.Zero;
LastRelativeAttackPoint = Vector3D.Zero;
// targetLastPoweredRun = 0;
}
// Orbiting a Target
else
{
CombatSystem.MarkEngaged();
LeadTask.Destination.MaxSpeed = Autopilot.CombatSpeed;
Vector3D targetPosition = orbitIntel.GetPositionFromCanonicalTime(canonicalTime);
var periodicFactor = runs * Math.PI * CombatSystem.EngageTheta / 4;
Vector3D periodicDirection = Math.Sin(periodicFactor) * controller.WorldMatrix.Left + Math.Cos(periodicFactor) * controller.WorldMatrix.Up;
var Acceleration = linearVelocity - LastLinearVelocity;
if (LastAcceleration == Vector3D.Zero)
{
LastAcceleration = Acceleration;
}
if (LastReference == MatrixD.Zero)
{
LastReference = controller.WorldMatrix;
}
if (LastEnemyVelocity == Vector3D.Zero)
{
LastEnemyVelocity = shootIntel.GetVelocity();
}
if (LastEnemyPosition == Vector3D.Zero)
{
LastEnemyPosition = shootIntel.GetPositionFromCanonicalTime(canonicalTime);
}
var enemyAcceleration = shootIntel.GetVelocity() - LastEnemyVelocity;
var enemyVelocityAdjust = shootIntel.GetVelocity() * 2 - LastEnemyVelocity;
var CurrentAccelerationPreviousFrame = Vector3D.TransformNormal(Acceleration, MatrixD.Transpose(LastReference));
var accelerationAdjust = Vector3D.TransformNormal(CurrentAccelerationPreviousFrame, controller.WorldMatrix);
var velocityAdjust = linearVelocity + accelerationAdjust * 0.4;
velocityAdjust *= CombatSystem.OwnSpeedMultiplier;
Vector3D relativeAttackPoint = AttackHelpers.GetAttackPoint(enemyVelocityAdjust - velocityAdjust, shootIntel.GetPositionFromCanonicalTime(canonicalTime) + enemyVelocityAdjust * 0.25 - controller.WorldMatrix.Translation - velocityAdjust * 0.25, CombatSystem.ProjectileSpeed);
relativeAttackPoint.Normalize();
if (LastRelativeAttackPoint == Vector3D.Zero)
{
LastRelativeAttackPoint = relativeAttackPoint;
}
LastAcceleration = linearVelocity - LastLinearVelocity;
LeadTask.Destination.Direction = relativeAttackPoint;
if ((controller.WorldMatrix.Translation - targetPosition).Length() < CombatSystem.FireDist &&
VectorHelpers.VectorAngleBetween(LeadTask.Destination.Direction, controller.WorldMatrix.Forward) < CombatSystem.FireTolerance)
{
CombatSystem.Fire();
}
Vector3D dirTargetToMe = controller.WorldMatrix.Translation - targetPosition;
var distTargetToMe = dirTargetToMe.Length();
dirTargetToMe.Normalize();
if (Mode == 0)
{
Vector3D dirTargetToOrbitTarget = Vector3D.Cross(dirTargetToMe, controller.WorldMatrix.Up);
dirTargetToOrbitTarget.Normalize();
if (gravdir == Vector3D.Zero)
{
LeadTask.Destination.DirectionUp = Math.Sin(CombatSystem.EngageTheta) * controller.WorldMatrix.Right + Math.Cos(CombatSystem.EngageTheta) * controller.WorldMatrix.Up;
LeadTask.Destination.Position = targetPosition + orbitIntel.GetVelocity() + dirTargetToMe * CombatSystem.EngageDist + dirTargetToOrbitTarget * 200;
}
else
{
var flatDirTargetToMe = dirTargetToMe - VectorHelpers.VectorProjection(dirTargetToMe, gravdir);
flatDirTargetToMe.Normalize();
LeadTask.Destination.Position = targetPosition + orbitIntel.GetVelocity() + flatDirTargetToMe * CombatSystem.EngageDist * 0.9 - gravdir * 300 + periodicDirection * 100;
}
LeadTask.Destination.Velocity = orbitIntel.GetVelocity() * 0.5;
}
else if (Mode == 2)
{
LeadTask.Destination.Position = targetPosition + dirTargetToMe * (CombatSystem.EngageDist + (CombatSystem.EngageDist - distTargetToMe));
LeadTask.Destination.Velocity = orbitIntel.GetVelocity();
}
LastReference = controller.WorldMatrix;
LastEnemyVelocity = shootIntel.GetVelocity();
LastEnemyPosition = shootIntel.GetPositionFromCanonicalTime(canonicalTime);
LastRelativeAttackPoint = relativeAttackPoint;
//var n = VectorHelpers.VectorProjection(enemyAcceleration, gravdir).Length() / enemyAcceleration.Length();
//
//if (targetLastPoweredRun == 0 || n < 0.6)
// targetLastPoweredRun = runs;
//
//if (runs - targetLastPoweredRun > 20)
// IntelProvider.SetPriority(shootIntel.ID, 1);
}
if (!Attack)
{
Vector3D toTarget = TargetPosition - Program.Me.WorldMatrix.Translation;
if (toTarget.LengthSquared() > 100)
{
LeadTask.Destination.Position = TargetPosition;
}
else
{
LeadTask.Destination.Position = Vector3D.Zero;
}
LeadTask.Destination.Velocity = Vector3D.Zero;
}
if (Mode == 1)
{
//TODO: Add support for disabling dampeners in this mode - let pilot have full control aside from aiming
LeadTask.Destination.Position = controller.GetPosition();
LeadTask.Destination.Velocity = Vector3D.Zero;
if (shootIntel == null)
{
LeadTask.Destination.Direction = Vector3D.Zero;
LeadTask.Destination.DirectionUp = Vector3D.Zero;
}
}
LastLinearVelocity = linearVelocity;
if (LeadTask.Status == TaskStatus.Incomplete)
{
LeadTask.Do(IntelItems, canonicalTime, profiler);
}
}
public void SelectTarget(List <EnemyShipIntel> targets, TimeSpan timestamp)
{
// Auto reset
targetAzimuth = restAzimuth;
targetElevation = restElevation;
if (Elevation == null || Azimuth == null)
{
return;
}
var reference = WeaponGroup.Reference;
if (!WeaponGroup.Active)
{
return;
}
if (!active)
{
return;
}
var myVel = Host.IntelProvider.Controller.GetShipVelocities().LinearVelocity;
var canonicalTime = Host.IntelProvider.CanonicalTimeDiff + timestamp;
foreach (var target in targets)
{
var targetVel = target.GetVelocity();
var targetPos = target.GetPositionFromCanonicalTime(canonicalTime);
// Get attack position
var relativeAttackPoint = AttackHelpers.GetAttackPoint(targetVel - myVel, targetPos - (reference.WorldMatrix.Translation), projectileSpeed);
var relativeAttackDirection = Vector3D.Normalize(relativeAttackPoint);
// Check range
if (relativeAttackPoint.Length() > range)
{
continue;
}
// Calculate azimuth angle
var azimuthVector = relativeAttackDirection - VectorHelpers.VectorProjection(relativeAttackDirection, Azimuth.WorldMatrix.Up);
var azimuthAngle = VectorHelpers.VectorAngleBetween(azimuthVector, Azimuth.WorldMatrix.Backward) * Math.Sign(azimuthVector.Dot(Azimuth.WorldMatrix.Left));
//statusBuilder.AppendLine("AZM: " + (azimuthAngle * 180 / Math.PI).ToString());
// Check if azimuth is OK
if (azimuthAngle > AzimuthMax || azimuthAngle < AzimuthMin)
{
continue;
}
// Calculate elevation angle
var elevationAngle = VectorHelpers.VectorAngleBetween(azimuthVector, relativeAttackDirection) * Math.Sign(relativeAttackDirection.Dot(Azimuth.WorldMatrix.Up));
if (elevationAngle > ElevationMax || elevationAngle < ElevationMin)
{
continue;
}
//statusBuilder.AppendLine("ELV: " + (elevationAngle * 180 / Math.PI).ToString());
// Found best target, set target az, el, and return
targetAzimuth = azimuthAngle;
targetElevation = elevationAngle;
return;
}
}
public void Drive(Vector3D Destination)
{
if (Destination == Vector3D.Zero)
{
return;
}
if (GravAngle > Math.PI * 0.1)
{
foreach (var engine in HoverEngines)
{
engine.Block.Enabled = true;
engine.OverridePercentage = 0;
engine.AltitudeMin = DesiredAltitude / VertiHoriForceRatio;
}
return;
}
var gravDir = Controller.GetNaturalGravity();
var gravStr = gravDir.Length();
gravDir.Normalize();
var destDir = Destination - Controller.WorldMatrix.Translation;
destDir -= VectorHelpers.VectorProjection(destDir, gravDir);
var dist = destDir.Length();
Arrived = dist < 20;
destDir.Normalize();
var maxSpeed = SpeedLimit == 0 ? Math.Min(100, GetMaxSpeedFromBrakingDistance((float)dist)) : SpeedLimit;
var currentVel = Controller.GetShipVelocities().LinearVelocity;
var horiVel = currentVel - VectorHelpers.VectorProjection(Controller.GetShipVelocities().LinearVelocity, gravDir);
var vertiVel = currentVel.Dot(-gravDir);
var accelDir = maxSpeed * destDir - horiVel;
accelDir.Normalize();
var mass = Controller.CalculateShipMass().PhysicalMass;
var gravForce = gravStr * mass;
DirForces.Clear();
Dirs.Clear();
Dirs.Add(Controller.WorldMatrix.Forward);
Dirs.Add(Controller.WorldMatrix.Down);
Dirs.Add(Controller.WorldMatrix.Left);
float alpha = 0;
double altitude;
Controller.TryGetPlanetElevation(MyPlanetElevation.Surface, out altitude);
DesiredVerticalVel = DesiredAltitude - altitude;
var altAdjust = DesiredVerticalVel - vertiVel;
Vector3D PrimaryDriveDir = Vector3D.Zero;
Vector3D SecondaryDriveDir = Vector3D.Zero;
Vector3D OpposDriveDir = Vector3D.Zero;
foreach (var dir in Dirs)
{
var engineDir = dir;
engineDir -= VectorHelpers.VectorProjection(engineDir, gravDir);
engineDir.Normalize();
var engineAngleDiff = VectorHelpers.VectorAngleBetween(engineDir, accelDir);
if (engineAngleDiff < 0.3333333333333 * Math.PI)
{
DirForces[dir] = 0;
OpposDriveDir = dir;
}
else if (engineAngleDiff > 2 * 0.3333333333333 * Math.PI)
{
DirForces[dir] = 1f;
PrimaryDriveDir = dir;
}
else
{
var aPrime = 1 / (TrigHelpers.fastTan(engineAngleDiff - Math.PI * 0.333333333) * sqrt3inv + 1);
DirForces[dir] = (float)(1 - aPrime) * 2;
SecondaryDriveDir = dir;
alpha = DirForces[dir];
}
}
var primaryDriveForce = MaxForce * VerticalForceRatio;
var secondaryDriveForce = primaryDriveForce * alpha;
var totalUpForce = primaryDriveForce + secondaryDriveForce;
var multiplier = (gravForce + altAdjust * mass) / totalUpForce;
Status = $"{altAdjust}, {dist}";
if (PrimaryDriveDir != Vector3D.Zero)
{
DirForces[PrimaryDriveDir] = Math.Max(0.01f, (float)multiplier);
}
if (SecondaryDriveDir != Vector3D.Zero)
{
DirForces[SecondaryDriveDir] = (float)Math.Max(0.01f, alpha * (float)multiplier);
}
var altMin = 1;
if (altitude > 7)
{
altMin = 6;
}
if (altitude > 40)
{
altMin = 10;
}
foreach (var engine in HoverEngines)
{
engine.AltitudeMin = altMin;
engine.Block.Enabled = OpposDriveDir != engine.Block.WorldMatrix.Forward;
engine.OverridePercentage = DirForces[engine.Block.WorldMatrix.Forward];
}
}