示例#1
0
        public override void AddTo(BindingManager manager)
        {
            manager.AddGetter("VESSELNAME", delegate(CPU cpu) { return(cpu.Vessel.vesselName); });
            manager.AddSetter("VESSELNAME", delegate(CPU cpu, object value) { cpu.Vessel.vesselName = value.ToString(); });

            manager.AddGetter("ALTITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.altitude); });
            manager.AddGetter("ALT:RADAR", delegate(CPU cpu) { return((float)cpu.Vessel.heightFromTerrain); });
            manager.AddGetter("MISSIONTIME", delegate(CPU cpu) { return((float)cpu.Vessel.missionTime); });
            manager.AddGetter("STATUS", delegate(CPU cpu) { return(cpu.Vessel.situation.ToString().Replace("_", " ")); });
            manager.AddGetter("APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.ApA); });
            manager.AddGetter("PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.PeA); });

            manager.AddGetter("ALT:APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.ApA); });
            manager.AddGetter("ALT:PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.PeA); });
            manager.AddGetter("ETA:APOAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.timeToAp); });
            manager.AddGetter("ETA:PERIAPSIS", delegate(CPU cpu) { return((float)cpu.Vessel.orbit.timeToPe); });

            manager.AddGetter("VELOCITY", delegate(CPU cpu) { return(cpu.Vessel.obt_velocity); });
            manager.AddGetter("ANGULARMOMENTUM", delegate(CPU cpu) { return(new Direction(cpu.Vessel.angularMomentum, true)); });
            manager.AddGetter("ANGULARVEL", delegate(CPU cpu) { return(new Direction(cpu.Vessel.angularVelocity, true)); });
            manager.AddGetter("MASS", delegate(CPU cpu) { return(cpu.Vessel.GetTotalMass()); });
            manager.AddGetter("VERTICALSPEED", delegate(CPU cpu) { return((float)cpu.Vessel.verticalSpeed); });
            manager.AddGetter("SURFACESPEED", delegate(CPU cpu) { return((float)cpu.Vessel.horizontalSrfSpeed); });

            manager.AddGetter("BODY", delegate(CPU cpu) { return(cpu.Vessel.mainBody.bodyName); });
            manager.AddGetter("LATITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.latitude); });
            manager.AddGetter("LONGITUDE", delegate(CPU cpu) { return((float)cpu.Vessel.longitude); });

            manager.AddGetter("UP", delegate(CPU cpu) { return(new Direction(cpu.Vessel.upAxis, false)); });

            manager.AddGetter("NODE", delegate(CPU cpu) {
                var vessel = cpu.Vessel;
                if (!vessel.patchedConicSolver.maneuverNodes.Any())
                {
                    throw new kOSException("No maneuver nodes present!");
                }
                var up     = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;
                var fwd    = vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(cpu.Vessel.orbit);
                var rotRef = Quaternion.LookRotation(fwd, up);

                Direction d = new Direction();
                d.Rotation  = rotRef;
                return(d);
            });

            manager.AddGetter("MAG:NODE", delegate(CPU cpu) {
                var vessel = cpu.Vessel;
                var orbit  = vessel.orbit;
                if (!vessel.patchedConicSolver.maneuverNodes.Any())
                {
                    throw new kOSException("No maneuver nodes present!");
                }
                var mag = vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(orbit).magnitude;

                return((float)mag);
            });

            manager.AddGetter("ETA:NODE", delegate(CPU cpu) {
                var vessel = cpu.Vessel;
                if (!vessel.patchedConicSolver.maneuverNodes.Any())
                {
                    throw new kOSException("No maneuver nodes present!");
                }
                var time     = vessel.patchedConicSolver.maneuverNodes[0].UT;
                var currTime = Planetarium.GetUniversalTime();

                return((float)(time - currTime));
            });

            manager.AddGetter("PROGRADE", delegate(CPU cpu)
            {
                var vessel = cpu.Vessel;
                var up     = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;

                Direction d = new Direction();
                d.Rotation  = Quaternion.LookRotation(cpu.Vessel.orbit.GetVel().normalized, up);
                return(d);
            });

            manager.AddGetter("RETROGRADE", delegate(CPU cpu)
            {
                var vessel = cpu.Vessel;
                var up     = (vessel.findLocalMOI(vessel.findWorldCenterOfMass()) - vessel.mainBody.position).normalized;

                Direction d    = new Direction();
                var vesselRoll = cpu.Vessel.GetTransform().eulerAngles.y;
                d.Rotation     = Quaternion.LookRotation(cpu.Vessel.orbit.GetVel().normalized * -1, up);
                return(d);
            });

            manager.AddGetter("FACING", delegate(CPU cpu)
            {
                var facing = cpu.Vessel.transform.up;
                return(new Direction(new Vector3d(facing.x, facing.y, facing.z).normalized, false));
            });

            manager.AddGetter("MAXTHRUST", delegate(CPU cpu)
            {
                return(VesselUtils.GetMaxThrust(cpu.Vessel));
            });

            manager.AddGetter("AV", delegate(CPU cpu) { return(cpu.Vessel.transform.InverseTransformDirection(cpu.Vessel.rigidbody.angularVelocity)); });

            manager.AddGetter("STAGE", delegate(CPU cpu) { return(new StageValues(cpu.Vessel)); });
        }
示例#2
0
 public BodyTarget(String name, ExecutionContext context) : this(VesselUtils.GetBodyByName(name), context)
 {
 }
示例#3
0
        private object GetResourceOfCurrentStage(String resourceName)
        {
            var activeEngines = VesselUtils.GetListOfActivatedEngines(vessel);

            return(Utils.ProspectForResource(resourceName, activeEngines));
        }
示例#4
0
        public override void Evaluate()
        {
            switch (RegexMatch.Groups[1].Value.ToUpper())
            {
            case "BODIES":
                StdOut("");
                StdOut("Name           Distance");
                StdOut("-------------------------------------");
                foreach (var body in FlightGlobals.fetch.bodies)
                {
                    StdOut(body.bodyName.PadLeft(14) + " " + Vector3d.Distance(body.position, Vessel.GetWorldPos3D()));
                }
                StdOut("");

                break;


            case "TARGETS":
                StdOut("");
                StdOut("Vessel Name              Distance");
                StdOut("-------------------------------------");

                float commRange = VesselUtils.GetCommRange(Vessel);

                foreach (Vessel vessel in FlightGlobals.Vessels)
                {
                    if (vessel != Vessel)
                    {
                        var vT = new VesselTarget(vessel, this);
                        if (vT.IsInRange(commRange))
                        {
                            StdOut(vT.target.vesselName.PadRight(24) + " " + vT.GetDistance().ToString("0.0").PadLeft(8));
                        }
                    }
                }

                StdOut("");

                break;

            case "RESOURCES":
                StdOut("");
                StdOut("Stage      Resource Name               Amount");
                StdOut("------------------------------------------------");

                foreach (Part part in Vessel.Parts)
                {
                    String stageStr = part.inverseStage.ToString();

                    foreach (PartResource resource in part.Resources)
                    {
                        StdOut(part.inverseStage.ToString() + " " + resource.resourceName.PadRight(20) + " " + resource.amount.ToString("0.00").PadLeft(8));
                    }
                }
                break;

            case "PARTS":
                StdOut("------------------------------------------------");

                foreach (Part part in Vessel.Parts)
                {
                    StdOut(part.ConstructID + " " + part.partInfo.name);
                }

                break;

            case "ENGINES":
                StdOut("------------------------------------------------");

                foreach (Part part in VesselUtils.GetListOfActivatedEngines(Vessel))
                {
                    foreach (PartModule module in part.Modules)
                    {
                        if (module is ModuleEngines)
                        {
                            var engineMod = (ModuleEngines)module;

                            StdOut(part.uid + "  " + part.inverseStage.ToString() + " " + engineMod.moduleName);
                        }
                    }
                }

                break;
            }

            State = ExecutionState.DONE;
        }
示例#5
0
            public void OnFlyByWire(ref FlightCtrlState c)
            {
                Expression e = cpu.GetDeepestChildContext().GetLock(propertyName);

                if (e != null)
                {
                    Value = e.GetValue();

                    if (propertyName == "throttle")
                    {
                        c.mainThrottle = (float)e.Double();
                    }

                    if (propertyName == "wheelthrottle")
                    {
                        c.wheelThrottle = (float)Utils.Clamp(e.Double(), -1, 1);
                    }

                    if (propertyName == "steering")
                    {
                        if (Value is String && ((string)Value).ToUpper() == "KILL")
                        {
                            SteeringHelper.KillRotation(c, vessel);
                        }
                        else if (Value is Direction)
                        {
                            SteeringHelper.SteerShipToward((Direction)Value, c, vessel);
                        }
                        else if (Value is Vector)
                        {
                            SteeringHelper.SteerShipToward(((Vector)Value).ToDirection(), c, vessel);
                        }
                        else if (Value is Node)
                        {
                            SteeringHelper.SteerShipToward(((Node)Value).GetBurnVector().ToDirection(), c, vessel);
                        }
                    }

                    if (propertyName == "wheelsteering")
                    {
                        float bearing = 0;

                        if (Value is VesselTarget)
                        {
                            bearing = VesselUtils.GetTargetBearing(vessel, ((VesselTarget)Value).target);
                        }
                        else if (Value is GeoCoordinates)
                        {
                            bearing = ((GeoCoordinates)Value).GetBearing(vessel);
                        }
                        else if (Value is double)
                        {
                            bearing = (float)(Math.Round((double)Value) - Mathf.Round(FlightGlobals.ship_heading));
                        }

                        if (vessel.horizontalSrfSpeed > 0.1f)
                        {
                            if (Mathf.Abs(VesselUtils.AngleDelta(VesselUtils.GetHeading(vessel), VesselUtils.GetVelocityHeading(vessel))) <= 90)
                            {
                                c.wheelSteer = Mathf.Clamp(bearing / -10, -1, 1);
                            }
                            else
                            {
                                c.wheelSteer = -Mathf.Clamp(bearing / -10, -1, 1);
                            }
                        }
                    }

                    if (cpu.GetLock(name) == null)
                    {
                        locked = false;
                    }
                }
            }
示例#6
0
        public override object GetSuffix(string suffixName)
        {
            if (suffixName == "DIRECTION")
            {
                var vector = (target.GetWorldPos3D() - context.Vessel.GetWorldPos3D());
                return(new Direction(vector, false));
            }

            if (suffixName == "DISTANCE")
            {
                return((float)GetDistance());
            }
            if (suffixName == "BEARING")
            {
                return(VesselUtils.GetTargetBearing(context.Vessel, target));
            }
            if (suffixName == "HEADING")
            {
                return(VesselUtils.GetTargetHeading(context.Vessel, target));
            }
            if (suffixName == "PROGRADE")
            {
                return(GetPrograde());
            }
            if (suffixName == "RETROGRADE")
            {
                return(GetRetrograde());
            }
            if (suffixName == "MAXTHRUST")
            {
                return(VesselUtils.GetMaxThrust(target));
            }
            if (suffixName == "VELOCITY")
            {
                return(new VesselVelocity(target));
            }
            if (suffixName == "GEOPOSITION")
            {
                return(new GeoCoordinates(target));
            }
            if (suffixName == "LATITUDE")
            {
                return(VesselUtils.GetVesselLattitude(target));
            }
            if (suffixName == "LONGITUDE")
            {
                return(VesselUtils.GetVesselLongitude(target));
            }
            if (suffixName == "FACING")
            {
                return(GetFacing());
            }
            if (suffixName == "UP")
            {
                return(new Direction(target.upAxis, false));
            }
            if (suffixName == "NORTH")
            {
                return(new Direction(VesselUtils.GetNorthVector(target), false));
            }
            if (suffixName == "BODY")
            {
                return(target.mainBody.bodyName);
            }
            if (suffixName == "ANGULARMOMENTUM")
            {
                return(new Direction(target.angularMomentum, true));
            }
            if (suffixName == "ANGULARVEL")
            {
                return(new Direction(target.angularVelocity, true));
            }
            if (suffixName == "MASS")
            {
                return(target.GetTotalMass());
            }
            if (suffixName == "VERTICALSPEED")
            {
                return(target.verticalSpeed);
            }
            if (suffixName == "SURFACESPEED")
            {
                return(target.horizontalSrfSpeed);
            }
            if (suffixName == "AIRSPEED")
            {
                return((target.orbit.GetVel() - FlightGlobals.currentMainBody.getRFrmVel(target.GetWorldPos3D())).magnitude);                          //the velocity of the vessel relative to the air);
            }
            if (suffixName == "VESSELNAME")
            {
                return(target.vesselName);
            }
            if (suffixName == "ALTITUDE")
            {
                return(target.altitude);
            }
            if (suffixName == "APOAPSIS")
            {
                return(target.orbit.ApA);
            }
            if (suffixName == "PERIAPSIS")
            {
                return(target.orbit.PeA);
            }
            if (suffixName == "SENSOR")
            {
                return(new VesselSensors(target));
            }
            if (suffixName == "TERMVELOCITY")
            {
                return(VesselUtils.GetTerminalVelocity(target));
            }
            if (suffixName == "OBT")
            {
                return(new OrbitInfo(target.orbit));
            }

            // Is this a resource?
            double dblValue;

            if (VesselUtils.TryGetResource(target, suffixName, out dblValue))
            {
                return(dblValue);
            }

            return(base.GetSuffix(suffixName));
        }
示例#7
0
 public float GetBearing(Vessel vessel)
 {
     return(VesselUtils.AngleDelta(VesselUtils.GetHeading(vessel), GetHeadingFromVessel(vessel)));
 }
示例#8
0
 private static bool CheckCommRange(Vessel vessel)
 {
     return(VesselUtils.GetDistanceToKerbinSurface(vessel) < VesselUtils.GetCommRange(vessel));
 }
示例#9
0
            private void UpdateWheelSteering(ref FlightCtrlState c)
            {
                float bearing = 0;

                if (_value is VesselTarget)
                {
                    bearing = VesselUtils.GetTargetBearing(_shared.Vessel, ((VesselTarget)_value).target);
                }
                else if (_value is GeoCoordinates)
                {
                    bearing = ((GeoCoordinates)_value).GetBearing(_shared.Vessel);
                }
                else if (_value is double)
                {
                    bearing = (float)(Math.Round((double)_value) - Mathf.Round(FlightGlobals.ship_heading));
                }

                if (_shared.Vessel.horizontalSrfSpeed > 0.1f)
                {
                    if (Mathf.Abs(VesselUtils.AngleDelta(VesselUtils.GetHeading(_shared.Vessel), VesselUtils.GetVelocityHeading(_shared.Vessel))) <= 90)
                    {
                        c.wheelSteer = Mathf.Clamp(bearing / -10, -1, 1);
                    }
                    else
                    {
                        c.wheelSteer = -Mathf.Clamp(bearing / -10, -1, 1);
                    }
                }
            }
示例#10
0
 public BodyTarget(String name, Vessel currentVessel) : this(VesselUtils.GetBodyByName(name), currentVessel)
 {
 }
示例#11
0
 public override bool CheckRange()
 {
     return(VesselUtils.GetDistanceToKerbinSurface(vessel) < VesselUtils.GetCommRange(vessel));
 }