private void updateHighAltitudeCorrections()
        {
            var targetRelative           = Target - landingPrediction.Position;
            var targetRelativeNormalized = targetRelative;

            targetRelativeNormalized.Normalize();

            var overShootTarget = Target + targetRelativeNormalized * 1000.0f;

            targetRelativeNormalized = overShootTarget - landingPrediction.Position;
            targetRelativeNormalized.Normalize();

            var desiredDirection = targetRelativeNormalized;// * Math.Min(1.0f, targetRelative.Length() * 0.01f);

            desiredDirection.Normalize();
            VesselDirectionController.setTargetDirection(desiredDirection);
            var   vesselVelocity            = VesselController.getVelocity();
            float minimalCorrectiveThrottle = (float)VesselDirectionController.getOnTargetPercentage() *
                                              Math.Min(1.0f, targetRelative.Length() * 0.0001f) * 1.0f;// * Math.Min(1.0f, vesselVelocity.Length() * 0.005f);

            VesselController.setThrottle(minimalCorrectiveThrottle);
            Console.WriteLine("[High altitude pinpoint] Prediction mismatch {0}", targetRelative.Length());

            /*
             * var vesselVelocity = VesselController.getVelocity();
             * var vesselVelocityNormalized = vesselVelocity;
             * vesselVelocityNormalized.Normalize();
             * VesselDirectionController.setTargetDirection(-vesselVelocityNormalized);*/
        }
        public bool update()
        {
            var landingPrediction        = Forecast.predictLandPosition();
            var brakeAltitudePrediction  = Forecast.predictImmediateRetrogradeBurnStopAltitude();
            var targetRelative           = Target - landingPrediction.Position;
            var targetRelativeNormalized = targetRelative;

            targetRelativeNormalized.Normalize();

            float minimalCorrectiveThrottle = 0.0f;

            var desiredDirection = targetRelativeNormalized;

            desiredDirection.Normalize();
            VesselDirectionController.setTargetDirection(desiredDirection);
            minimalCorrectiveThrottle = (float)VesselDirectionController.getOnTargetPercentage() *
                                        Math.Min(1.0f, (float)Math.Pow(targetRelative.Length() * 0.0008f, 2.0f)) * 0.1f;

            VesselDirectionController.update();

            Console.WriteLine("Prediction mismatch {0}", targetRelative.Length());

            if ((targetRelative.Length() < 1000.0 && lastMissDistance < targetRelative.Length()) || targetRelative.Length() < 10.0)
            {
                VesselController.setThrottle(0.0);
                return(true);
            }

            lastMissDistance = targetRelative.Length();

            VesselController.setThrottle(minimalCorrectiveThrottle);

            return(false);
        }
示例#3
0
        public bool update()
        {
            var    orbit            = Forecast.predictOrbit();
            var    apo              = orbit.Apoapsis;
            double velocityNeeded   = VesselController.calculateOrbitalVelocityAtAltitude(Altitude);
            double currentVelocity  = VesselController.getOrbitalVelocity().Length();
            double shipAcceleration = VesselController.getEnginesAcceleration();
            double timeOfManouver   = (velocityNeeded - currentVelocity) / shipAcceleration;
            float  mixer            = (float)(apo / Altitude);
            var    downDirection    = VesselController.getGravity();

            downDirection.Normalize();
            VesselDirectionController.setTargetDirection(-downDirection);

            if (currentStage == Stage.Ascend)
            {
                Console.WriteLine("[Ascend] Apoapsis {0}", apo);

                if (orbit.Apoapsis < Altitude)
                {
                    VesselController.setThrottle(VesselDirectionController.getOnTargetPercentage());
                }
                else
                {
                    VesselController.setThrottle(0.0f);
                    return(true);
                }
            }

            VesselDirectionController.update();
            return(false);
        }
        public bool update()
        {
            var    orbit              = Forecast.predictOrbit();
            var    apo                = orbit.Apoapsis;
            double velocityNeeded     = VesselController.calculateOrbitalVelocityAtAltitude(Altitude);
            double currentVelocity    = VesselController.getOrbitalVelocity().Length();
            double shipAcceleration   = VesselController.getEnginesAcceleration();
            double timeOfManouver     = (velocityNeeded - currentVelocity) / shipAcceleration;
            var    velocityNormalized = VesselController.getVelocity();

            velocityNormalized.Normalize();
            float mixer         = (float)(apo / Altitude);
            var   downDirection = VesselController.getGravity();

            downDirection.Normalize();
            var tangential = Vector3.Transform(-downDirection, Quaternion.RotationYawPitchRoll(MathUtil.DegreesToRadians(-25.0f), 0.0f, 0.0f));
            var direction  = -downDirection * (1.0f - mixer) + tangential * (mixer);

            direction.Normalize();
            VesselDirectionController.setTargetDirection(direction);

            if (currentStage == Stage.Ascend)
            {
                Console.WriteLine("[Ascend] Apoapsis {0}", apo);

                if (orbit.Apoapsis < Altitude)
                {
                    VesselController.setThrottle(VesselDirectionController.getOnTargetPercentage());
                }
                else
                {
                    VesselController.setThrottle(0.0f);
                    return(true);
                }
            }

            VesselDirectionController.update();
            return(false);
        }
        public bool update()
        {
            var    orbit            = Forecast.predictOrbit();
            var    apo              = orbit.Apoapsis;
            double velocityNeeded   = VesselController.calculateOrbitalVelocityAtAltitude(Altitude);
            double currentVelocity  = VesselController.getOrbitalVelocity().Length();
            double shipAcceleration = VesselController.getEnginesAcceleration();
            double timeOfManouver   = (velocityNeeded - currentVelocity) / shipAcceleration;
            float  mixer            = (float)(apo / Altitude);
            var    downDirection    = VesselController.getGravity();

            downDirection.Normalize();
            var tangential = Vector3.Transform(downDirection, Quaternion.RotationYawPitchRoll(MathUtil.DegreesToRadians(90.0f), 0.0f, 0.0f));
            var direction  = -downDirection * (1.0f - mixer) + tangential * (mixer);

            if (mixer > 1.0)
            {
                float newMixer = 1.0f - (mixer - 1.0f);
                direction = downDirection * (1.0f - newMixer) + tangential * (newMixer);
            }
            VesselDirectionController.setTargetDirection(direction);

            if (currentStage == Stage.Ascend)
            {
                Console.WriteLine("[Ascend] Apoapsis {0}", apo);

                if (orbit.Apoapsis < Altitude)
                {
                    VesselController.setThrottle(VesselDirectionController.getOnTargetPercentage());
                }
                else
                {
                    VesselController.setThrottle(0.0f);
                    currentStage = Stage.WaitForCircularize;
                }
            }

            if (currentStage == Stage.WaitForCircularize)
            {
                VesselController.setThrottle(0.0f);
                Console.WriteLine("[Waiting] Time left {0}", orbit.TimeToApoapsis - timeOfManouver * 0.5);
                if (orbit.TimeToApoapsis < timeOfManouver * 0.5)
                {
                    currentStage = Stage.Circularize;
                }
            }
            if (currentStage == Stage.Circularize)
            {
                Console.WriteLine("[Circularize] Apoapsis {0} Periapsis {1} Delta V required {2}", apo, orbit.Periapsis, velocityNeeded - currentVelocity);
                double min = Math.Min(orbit.Periapsis, orbit.Apoapsis);
                if (min < Altitude)
                {
                    VesselController.setThrottle(clamp((Altitude - min) * 0.02, 0.0, 1.0));
                }
                else
                {
                    VesselController.setThrottle(0.0f);
                }
            }


            VesselDirectionController.update();
            return(false);
        }