# Parts¶

The following classes allow interaction with a vessels individual parts.

## Parts¶

class Parts

Instances of this class are used to interact with the parts of a vessel. An instance can be obtained by calling Vessel.Parts.

IList<Part> All { get; }

A list of all of the vessels parts.

Game Scenes: All
Part Root { get; }

The vessels root part.

Game Scenes: All

Note

See the discussion on Trees of Parts.

Part Controlling { get; set; }

The part from which the vessel is controlled.

Game Scenes: All
IList<Part> WithName (String name)

A list of parts whose Part.Name is name.

Parameters: All
IList<Part> WithTitle (String title)

A list of all parts whose Part.Title is title.

Parameters: All
IList<Part> WithTag (String tag)

A list of all parts whose Part.Tag is tag.

Parameters: All
IList<Part> WithModule (String moduleName)

A list of all parts that contain a Module whose Module.Name is moduleName.

Parameters: All
IList<Part> InStage (Int32 stage)

A list of all parts that are activated in the given stage.

Parameters: All

Note

See the discussion on Staging.

IList<Part> InDecoupleStage (Int32 stage)

A list of all parts that are decoupled in the given stage.

Parameters: All

Note

See the discussion on Staging.

IList<Module> ModulesWithName (String moduleName)

A list of modules (combined across all parts in the vessel) whose Module.Name is moduleName.

Parameters: All
IList<Antenna> Antennas { get; }

A list of all antennas in the vessel.

Game Scenes: All
IList<CargoBay> CargoBays { get; }

A list of all cargo bays in the vessel.

Game Scenes: All
IList<ControlSurface> ControlSurfaces { get; }

A list of all control surfaces in the vessel.

Game Scenes: All
IList<Decoupler> Decouplers { get; }

A list of all decouplers in the vessel.

Game Scenes: All
IList<DockingPort> DockingPorts { get; }

A list of all docking ports in the vessel.

Game Scenes: All
IList<Engine> Engines { get; }

A list of all engines in the vessel.

Game Scenes: All

Note

This includes any part that generates thrust. This covers many different types of engine, including liquid fuel rockets, solid rocket boosters, jet engines and RCS thrusters.

IList<Experiment> Experiments { get; }

A list of all science experiments in the vessel.

Game Scenes: All
IList<Fairing> Fairings { get; }

A list of all fairings in the vessel.

Game Scenes: All
IList<Intake> Intakes { get; }

A list of all intakes in the vessel.

Game Scenes: All
IList<Leg> Legs { get; }

A list of all landing legs attached to the vessel.

Game Scenes: All
IList<LaunchClamp> LaunchClamps { get; }

A list of all launch clamps attached to the vessel.

Game Scenes: All
IList<Light> Lights { get; }

A list of all lights in the vessel.

Game Scenes: All
IList<Parachute> Parachutes { get; }

A list of all parachutes in the vessel.

Game Scenes: All
IList<Radiator> Radiators { get; }

A list of all radiators in the vessel.

Game Scenes: All
IList<RCS> RCS { get; }

A list of all RCS blocks/thrusters in the vessel.

Game Scenes: All
IList<ReactionWheel> ReactionWheels { get; }

A list of all reaction wheels in the vessel.

Game Scenes: All
IList<ResourceConverter> ResourceConverters { get; }

A list of all resource converters in the vessel.

Game Scenes: All
IList<ResourceHarvester> ResourceHarvesters { get; }

A list of all resource harvesters in the vessel.

Game Scenes: All
IList<Sensor> Sensors { get; }

A list of all sensors in the vessel.

Game Scenes: All
IList<SolarPanel> SolarPanels { get; }

A list of all solar panels in the vessel.

Game Scenes: All
IList<Wheel> Wheels { get; }

A list of all wheels in the vessel.

Game Scenes: All

## Part¶

class Part

Represents an individual part. Vessels are made up of multiple parts. Instances of this class can be obtained by several methods in Parts.

String Name { get; }

Internal name of the part, as used in part cfg files. For example “Mark1-2Pod”.

Game Scenes: All
String Title { get; }

Title of the part, as shown when the part is right clicked in-game. For example “Mk1-2 Command Pod”.

Game Scenes: All
String Tag { get; set; }

The name tag for the part. Can be set to a custom string using the in-game user interface.

Game Scenes: All

Note

This string is shared with kOS if it is installed.

Boolean Highlighted { get; set; }

Whether the part is highlighted.

Game Scenes: All
Tuple<Double, Double, Double> HighlightColor { get; set; }

The color used to highlight the part, as an RGB triple.

Game Scenes: All
Double Cost { get; }

The cost of the part, in units of funds.

Game Scenes: All
Vessel Vessel { get; }

The vessel that contains this part.

Game Scenes: All
Part Parent { get; }

The parts parent. Returns null if the part does not have a parent. This, in combination with Part.Children, can be used to traverse the vessels parts tree.

Game Scenes: All

Note

See the discussion on Trees of Parts.

IList<Part> Children { get; }

The parts children. Returns an empty list if the part has no children. This, in combination with Part.Parent, can be used to traverse the vessels parts tree.

Game Scenes: All

Note

See the discussion on Trees of Parts.

Boolean AxiallyAttached { get; }

Whether the part is axially attached to its parent, i.e. on the top or bottom of its parent. If the part has no parent, returns false.

Game Scenes: All

Note

See the discussion on Attachment Modes.

Boolean RadiallyAttached { get; }

Whether the part is radially attached to its parent, i.e. on the side of its parent. If the part has no parent, returns false.

Game Scenes: All

Note

See the discussion on Attachment Modes.

Int32 Stage { get; }

The stage in which this part will be activated. Returns -1 if the part is not activated by staging.

Game Scenes: All

Note

See the discussion on Staging.

Int32 DecoupleStage { get; }

The stage in which this part will be decoupled. Returns -1 if the part is never decoupled from the vessel.

Game Scenes: All

Note

See the discussion on Staging.

Boolean Massless { get; }

Whether the part is massless.

Game Scenes: All
Double Mass { get; }

The current mass of the part, including resources it contains, in kilograms. Returns zero if the part is massless.

Game Scenes: All
Double DryMass { get; }

The mass of the part, not including any resources it contains, in kilograms. Returns zero if the part is massless.

Game Scenes: All
Boolean Shielded { get; }

Whether the part is shielded from the exterior of the vessel, for example by a fairing.

Game Scenes: All
Single DynamicPressure { get; }

The dynamic pressure acting on the part, in Pascals.

Game Scenes: All
Double ImpactTolerance { get; }

The impact tolerance of the part, in meters per second.

Game Scenes: All
Double Temperature { get; }

Temperature of the part, in Kelvin.

Game Scenes: All
Double SkinTemperature { get; }

Temperature of the skin of the part, in Kelvin.

Game Scenes: All
Double MaxTemperature { get; }

Maximum temperature that the part can survive, in Kelvin.

Game Scenes: All
Double MaxSkinTemperature { get; }

Maximum temperature that the skin of the part can survive, in Kelvin.

Game Scenes: All
Single ThermalMass { get; }

A measure of how much energy it takes to increase the internal temperature of the part, in Joules per Kelvin.

Game Scenes: All
Single ThermalSkinMass { get; }

A measure of how much energy it takes to increase the skin temperature of the part, in Joules per Kelvin.

Game Scenes: All
Single ThermalResourceMass { get; }

A measure of how much energy it takes to increase the temperature of the resources contained in the part, in Joules per Kelvin.

Game Scenes: All
Single ThermalConductionFlux { get; }

The rate at which heat energy is conducting into or out of the part via contact with other parts. Measured in energy per unit time, or power, in Watts. A positive value means the part is gaining heat energy, and negative means it is losing heat energy.

Game Scenes: All
Single ThermalConvectionFlux { get; }

The rate at which heat energy is convecting into or out of the part from the surrounding atmosphere. Measured in energy per unit time, or power, in Watts. A positive value means the part is gaining heat energy, and negative means it is losing heat energy.

Game Scenes: All
Single ThermalRadiationFlux { get; }

The rate at which heat energy is radiating into or out of the part from the surrounding environment. Measured in energy per unit time, or power, in Watts. A positive value means the part is gaining heat energy, and negative means it is losing heat energy.

Game Scenes: All
Single ThermalInternalFlux { get; }

The rate at which heat energy is begin generated by the part. For example, some engines generate heat by combusting fuel. Measured in energy per unit time, or power, in Watts. A positive value means the part is gaining heat energy, and negative means it is losing heat energy.

Game Scenes: All
Single ThermalSkinToInternalFlux { get; }

The rate at which heat energy is transferring between the part’s skin and its internals. Measured in energy per unit time, or power, in Watts. A positive value means the part’s internals are gaining heat energy, and negative means its skin is gaining heat energy.

Game Scenes: All
Resources Resources { get; }

A Resources object for the part.

Game Scenes: All
Boolean Crossfeed { get; }

Whether this part is crossfeed capable.

Game Scenes: All
Boolean IsFuelLine { get; }

Whether this part is a fuel line.

Game Scenes: All
IList<Part> FuelLinesFrom { get; }

The parts that are connected to this part via fuel lines, where the direction of the fuel line is into this part.

Game Scenes: All

Note

See the discussion on Fuel Lines.

IList<Part> FuelLinesTo { get; }

The parts that are connected to this part via fuel lines, where the direction of the fuel line is out of this part.

Game Scenes: All

Note

See the discussion on Fuel Lines.

IList<Module> Modules { get; }

The modules for this part.

Game Scenes: All
Antenna Antenna { get; }

A Antenna if the part is an antenna, otherwise null.

Game Scenes: All
CargoBay CargoBay { get; }

A CargoBay if the part is a cargo bay, otherwise null.

Game Scenes: All
ControlSurface ControlSurface { get; }

A ControlSurface if the part is an aerodynamic control surface, otherwise null.

Game Scenes: All
Decoupler Decoupler { get; }

A Decoupler if the part is a decoupler, otherwise null.

Game Scenes: All
DockingPort DockingPort { get; }

A DockingPort if the part is a docking port, otherwise null.

Game Scenes: All
Engine Engine { get; }

An Engine if the part is an engine, otherwise null.

Game Scenes: All
Experiment Experiment { get; }

An Experiment if the part is a science experiment, otherwise null.

Game Scenes: All
Fairing Fairing { get; }

A Fairing if the part is a fairing, otherwise null.

Game Scenes: All
Intake Intake { get; }

An Intake if the part is an intake, otherwise null.

Game Scenes: All

Note

This includes any part that generates thrust. This covers many different types of engine, including liquid fuel rockets, solid rocket boosters and jet engines. For RCS thrusters see RCS.

Leg Leg { get; }

A Leg if the part is a landing leg, otherwise null.

Game Scenes: All
LaunchClamp LaunchClamp { get; }

A LaunchClamp if the part is a launch clamp, otherwise null.

Game Scenes: All
Light Light { get; }

A Light if the part is a light, otherwise null.

Game Scenes: All
Parachute Parachute { get; }

A Parachute if the part is a parachute, otherwise null.

Game Scenes: All
Radiator Radiator { get; }

A Radiator if the part is a radiator, otherwise null.

Game Scenes: All
RCS RCS { get; }

A RCS if the part is an RCS block/thruster, otherwise null.

Game Scenes: All
ReactionWheel ReactionWheel { get; }

A ReactionWheel if the part is a reaction wheel, otherwise null.

Game Scenes: All
ResourceConverter ResourceConverter { get; }

A ResourceConverter if the part is a resource converter, otherwise null.

Game Scenes: All
ResourceHarvester ResourceHarvester { get; }

A ResourceHarvester if the part is a resource harvester, otherwise null.

Game Scenes: All
Sensor Sensor { get; }

A Sensor if the part is a sensor, otherwise null.

Game Scenes: All
SolarPanel SolarPanel { get; }

A SolarPanel if the part is a solar panel, otherwise null.

Game Scenes: All
Wheel Wheel { get; }

A Wheel if the part is a wheel, otherwise null.

Game Scenes: All
Tuple<Double, Double, Double> Position (ReferenceFrame referenceFrame)

The position of the part in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All

Note

This is a fixed position in the part, defined by the parts model. It s not necessarily the same as the parts center of mass. Use Part.CenterOfMass to get the parts center of mass.

Tuple<Double, Double, Double> CenterOfMass (ReferenceFrame referenceFrame)

The position of the parts center of mass in the given reference frame. If the part is physicsless, this is equivalent to Part.Position.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> BoundingBox (ReferenceFrame referenceFrame)

The axis-aligned bounding box of the part in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned position vectors are in. The positions of the minimum and maximum vertices of the box, as position vectors. All

Note

This is computed from the collision mesh of the part. If the part is not collidable, the box has zero volume and is centered on the Part.Position of the part.

Tuple<Double, Double, Double> Direction (ReferenceFrame referenceFrame)

The direction the part points in, in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned direction is in. The direction as a unit vector. All
Tuple<Double, Double, Double> Velocity (ReferenceFrame referenceFrame)

The linear velocity of the part in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned velocity vector is in. The velocity as a vector. The vector points in the direction of travel, and its magnitude is the speed of the body in meters per second. All
Tuple<Double, Double, Double, Double> Rotation (ReferenceFrame referenceFrame)

The rotation of the part, in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned rotation is in. The rotation as a quaternion of the form $$(x, y, z, w)$$. All
Tuple<Double, Double, Double> MomentOfInertia { get; }

The moment of inertia of the part in $$kg.m^2$$ around its center of mass in the parts reference frame (ReferenceFrame).

Game Scenes: All
IList<Double> InertiaTensor { get; }

The inertia tensor of the part in the parts reference frame (ReferenceFrame). Returns the 3x3 matrix as a list of elements, in row-major order.

Game Scenes: All
ReferenceFrame ReferenceFrame { get; }

The reference frame that is fixed relative to this part, and centered on a fixed position within the part, defined by the parts model.

• The origin is at the position of the part, as returned by Part.Position.
• The axes rotate with the part.
• The x, y and z axis directions depend on the design of the part.
Game Scenes: All

Note

For docking port parts, this reference frame is not necessarily equivalent to the reference frame for the docking port, returned by DockingPort.ReferenceFrame.

Mk1 Command Pod reference frame origin and axes

ReferenceFrame CenterOfMassReferenceFrame { get; }

The reference frame that is fixed relative to this part, and centered on its center of mass.

• The origin is at the center of mass of the part, as returned by Part.CenterOfMass.
• The axes rotate with the part.
• The x, y and z axis directions depend on the design of the part.
Game Scenes: All

Note

For docking port parts, this reference frame is not necessarily equivalent to the reference frame for the docking port, returned by DockingPort.ReferenceFrame.

Force AddForce (Tuple<Double, Double, Double> force, Tuple<Double, Double, Double> position, ReferenceFrame referenceFrame)

Exert a constant force on the part, acting at the given position.

Parameters: force – A vector pointing in the direction that the force acts, with its magnitude equal to the strength of the force in Newtons. position – The position at which the force acts, as a vector. referenceFrame – The reference frame that the force and position are in. An object that can be used to remove or modify the force. All
void InstantaneousForce (Tuple<Double, Double, Double> force, Tuple<Double, Double, Double> position, ReferenceFrame referenceFrame)

Exert an instantaneous force on the part, acting at the given position.

Parameters: force – A vector pointing in the direction that the force acts, with its magnitude equal to the strength of the force in Newtons. position – The position at which the force acts, as a vector. referenceFrame – The reference frame that the force and position are in. All

Note

The force is applied instantaneously in a single physics update.

class Force

Obtained by calling Part.AddForce.

Part Part { get; }

The part that this force is applied to.

Game Scenes: All
Tuple<Double, Double, Double> ForceVector { get; set; }

The force vector, in Newtons.

Returns: A vector pointing in the direction that the force acts, with its magnitude equal to the strength of the force in Newtons. All
Tuple<Double, Double, Double> Position { get; set; }

The position at which the force acts, in reference frame ReferenceFrame.

Returns: The position as a vector. All
ReferenceFrame ReferenceFrame { get; set; }

The reference frame of the force vector and position.

Game Scenes: All
void Remove ()

Remove the force.

Game Scenes: All

## Module¶

class Module

This can be used to interact with a specific part module. This includes part modules in stock KSP, and those added by mods.

In KSP, each part has zero or more PartModules associated with it. Each one contains some of the functionality of the part. For example, an engine has a “ModuleEngines” part module that contains all the functionality of an engine.

String Name { get; }

Name of the PartModule. For example, “ModuleEngines”.

Game Scenes: All
Part Part { get; }

The part that contains this module.

Game Scenes: All
IDictionary<String, String> Fields { get; }

The modules field names and their associated values, as a dictionary. These are the values visible in the right-click menu of the part.

Game Scenes: All
Boolean HasField (String name)

Returns true if the module has a field with the given name.

Parameters: name – Name of the field. All
String GetField (String name)

Returns the value of a field.

Parameters: name – Name of the field. All
void SetFieldInt (String name, Int32 value)

Set the value of a field to the given integer number.

Parameters: name – Name of the field. value – Value to set. All
void SetFieldFloat (String name, Single value)

Set the value of a field to the given floating point number.

Parameters: name – Name of the field. value – Value to set. All
void SetFieldString (String name, String value)

Set the value of a field to the given string.

Parameters: name – Name of the field. value – Value to set. All
void ResetField (String name)

Set the value of a field to its original value.

Parameters: name – Name of the field. All
IList<String> Events { get; }

A list of the names of all of the modules events. Events are the clickable buttons visible in the right-click menu of the part.

Game Scenes: All
Boolean HasEvent (String name)

true if the module has an event with the given name.

Parameters: All
void TriggerEvent (String name)

Trigger the named event. Equivalent to clicking the button in the right-click menu of the part.

Parameters: All
IList<String> Actions { get; }

A list of all the names of the modules actions. These are the parts actions that can be assigned to action groups in the in-game editor.

Game Scenes: All
Boolean HasAction (String name)

true if the part has an action with the given name.

Parameters: All
void SetAction (String name, Boolean value = true)

Set the value of an action with the given name.

Parameters: All

## Specific Types of Part¶

The following classes provide functionality for specific types of part.

### Antenna¶

class Antenna

An antenna. Obtained by calling Part.Antenna.

Part Part { get; }

The part object for this antenna.

Game Scenes: All
AntennaState State { get; }

The current state of the antenna.

Game Scenes: All
Boolean Deployable { get; }

Whether the antenna is deployable.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the antenna is deployed.

Game Scenes: All

Note

Fixed antennas are always deployed. Returns an error if you try to deploy a fixed antenna.

Boolean CanTransmit { get; }

Whether data can be transmitted by this antenna.

Game Scenes: All
void Transmit ()

Transmit data.

Game Scenes: All
void Cancel ()

Cancel current transmission of data.

Game Scenes: All
Boolean AllowPartial { get; set; }

Whether partial data transmission is permitted.

Game Scenes: All
Double Power { get; }

The power of the antenna.

Game Scenes: All
Boolean Combinable { get; }

Whether the antenna can be combined with other antennae on the vessel to boost the power.

Game Scenes: All
Double CombinableExponent { get; }

Exponent used to calculate the combined power of multiple antennae on a vessel.

Game Scenes: All
Single PacketInterval { get; }

Interval between sending packets in seconds.

Game Scenes: All
Single PacketSize { get; }

Amount of data sent per packet in Mits.

Game Scenes: All
Double PacketResourceCost { get; }

Units of electric charge consumed per packet sent.

Game Scenes: All
enum AntennaState

The state of an antenna. See Antenna.State.

Deployed

Antenna is fully deployed.

Retracted

Antenna is fully retracted.

Deploying

Antenna is being deployed.

Retracting

Antenna is being retracted.

Broken

Antenna is broken.

### Cargo Bay¶

class CargoBay

A cargo bay. Obtained by calling Part.CargoBay.

Part Part { get; }

The part object for this cargo bay.

Game Scenes: All
CargoBayState State { get; }

The state of the cargo bay.

Game Scenes: All
Boolean Open { get; set; }

Whether the cargo bay is open.

Game Scenes: All
enum CargoBayState

The state of a cargo bay. See CargoBay.State.

Open

Cargo bay is fully open.

Closed

Cargo bay closed and locked.

Opening

Cargo bay is opening.

Closing

Cargo bay is closing.

### Control Surface¶

class ControlSurface

An aerodynamic control surface. Obtained by calling Part.ControlSurface.

Part Part { get; }

The part object for this control surface.

Game Scenes: All
Boolean PitchEnabled { get; set; }

Whether the control surface has pitch control enabled.

Game Scenes: All
Boolean YawEnabled { get; set; }

Whether the control surface has yaw control enabled.

Game Scenes: All
Boolean RollEnabled { get; set; }

Whether the control surface has roll control enabled.

Game Scenes: All
Single AuthorityLimiter { get; set; }

The authority limiter for the control surface, which controls how far the control surface will move.

Game Scenes: All
Boolean Inverted { get; set; }

Whether the control surface movement is inverted.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the control surface has been fully deployed.

Game Scenes: All
Single SurfaceArea { get; }

Surface area of the control surface in $$m^2$$.

Game Scenes: All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> AvailableTorque { get; }

The available torque, in Newton meters, that can be produced by this control surface, in the positive and negative pitch, roll and yaw axes of the vessel. These axes correspond to the coordinate axes of the Vessel.ReferenceFrame.

Game Scenes: All

### Decoupler¶

class Decoupler

A decoupler. Obtained by calling Part.Decoupler

Part Part { get; }

The part object for this decoupler.

Game Scenes: All
Vessel Decouple ()

Fires the decoupler. Returns the new vessel created when the decoupler fires. Throws an exception if the decoupler has already fired.

Game Scenes: All

Note

When called, the active vessel may change. It is therefore possible that, after calling this function, the object(s) returned by previous call(s) to SpaceCenter.ActiveVessel no longer refer to the active vessel.

Boolean Decoupled { get; }

Whether the decoupler has fired.

Game Scenes: All
Boolean Staged { get; }

Whether the decoupler is enabled in the staging sequence.

Game Scenes: All
Single Impulse { get; }

The impulse that the decoupler imparts when it is fired, in Newton seconds.

Game Scenes: All

### Docking Port¶

class DockingPort

A docking port. Obtained by calling Part.DockingPort

Part Part { get; }

The part object for this docking port.

Game Scenes: All
DockingPortState State { get; }

The current state of the docking port.

Game Scenes: All
Part DockedPart { get; }

The part that this docking port is docked to. Returns null if this docking port is not docked to anything.

Game Scenes: All
Vessel Undock ()

Undocks the docking port and returns the new Vessel that is created. This method can be called for either docking port in a docked pair. Throws an exception if the docking port is not docked to anything.

Game Scenes: All

Note

When called, the active vessel may change. It is therefore possible that, after calling this function, the object(s) returned by previous call(s) to SpaceCenter.ActiveVessel no longer refer to the active vessel.

Single ReengageDistance { get; }

The distance a docking port must move away when it undocks before it becomes ready to dock with another port, in meters.

Game Scenes: All
Boolean HasShield { get; }

Whether the docking port has a shield.

Game Scenes: All
Boolean Shielded { get; set; }

The state of the docking ports shield, if it has one.

Returns true if the docking port has a shield, and the shield is closed. Otherwise returns false. When set to true, the shield is closed, and when set to false the shield is opened. If the docking port does not have a shield, setting this attribute has no effect.

Game Scenes: All
Tuple<Double, Double, Double> Position (ReferenceFrame referenceFrame)

The position of the docking port, in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All
Tuple<Double, Double, Double> Direction (ReferenceFrame referenceFrame)

The direction that docking port points in, in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned direction is in. The direction as a unit vector. All
Tuple<Double, Double, Double, Double> Rotation (ReferenceFrame referenceFrame)

The rotation of the docking port, in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned rotation is in. The rotation as a quaternion of the form $$(x, y, z, w)$$. All
ReferenceFrame ReferenceFrame { get; }

The reference frame that is fixed relative to this docking port, and oriented with the port.

• The origin is at the position of the docking port.
• The axes rotate with the docking port.
• The x-axis points out to the right side of the docking port.
• The y-axis points in the direction the docking port is facing.
• The z-axis points out of the bottom off the docking port.
Game Scenes: All

Note

This reference frame is not necessarily equivalent to the reference frame for the part, returned by Part.ReferenceFrame.

Docking port reference frame origin and axes

Inline docking port reference frame origin and axes

enum DockingPortState

The state of a docking port. See DockingPort.State.

Ready

The docking port is ready to dock to another docking port.

Docked

The docking port is docked to another docking port, or docked to another part (from the VAB/SPH).

Docking

The docking port is very close to another docking port, but has not docked. It is using magnetic force to acquire a solid dock.

Undocking

The docking port has just been undocked from another docking port, and is disabled until it moves away by a sufficient distance (DockingPort.ReengageDistance).

Shielded

The docking port has a shield, and the shield is closed.

Moving

The docking ports shield is currently opening/closing.

### Engine¶

class Engine

An engine, including ones of various types. For example liquid fuelled gimballed engines, solid rocket boosters and jet engines. Obtained by calling Part.Engine.

Note

For RCS thrusters Part.RCS.

Part Part { get; }

The part object for this engine.

Game Scenes: All
Boolean Active { get; set; }

Whether the engine is active. Setting this attribute may have no effect, depending on Engine.CanShutdown and Engine.CanRestart.

Game Scenes: All
Single Thrust { get; }

The current amount of thrust being produced by the engine, in Newtons.

Game Scenes: All
Single AvailableThrust { get; }

The amount of thrust, in Newtons, that would be produced by the engine when activated and with its throttle set to 100%. Returns zero if the engine does not have any fuel. Takes the engine’s current Engine.ThrustLimit and atmospheric conditions into account.

Game Scenes: All
Single MaxThrust { get; }

The amount of thrust, in Newtons, that would be produced by the engine when activated and fueled, with its throttle and throttle limiter set to 100%.

Game Scenes: All
Single MaxVacuumThrust { get; }

The maximum amount of thrust that can be produced by the engine in a vacuum, in Newtons. This is the amount of thrust produced by the engine when activated, Engine.ThrustLimit is set to 100%, the main vessel’s throttle is set to 100% and the engine is in a vacuum.

Game Scenes: All
Single ThrustLimit { get; set; }

The thrust limiter of the engine. A value between 0 and 1. Setting this attribute may have no effect, for example the thrust limit for a solid rocket booster cannot be changed in flight.

Game Scenes: All
IList<Thruster> Thrusters { get; }

The components of the engine that generate thrust.

Game Scenes: All

Note

For example, this corresponds to the rocket nozzel on a solid rocket booster, or the individual nozzels on a RAPIER engine. The overall thrust produced by the engine, as reported by Engine.AvailableThrust, Engine.MaxThrust and others, is the sum of the thrust generated by each thruster.

Single SpecificImpulse { get; }

The current specific impulse of the engine, in seconds. Returns zero if the engine is not active.

Game Scenes: All
Single VacuumSpecificImpulse { get; }

The vacuum specific impulse of the engine, in seconds.

Game Scenes: All
Single KerbinSeaLevelSpecificImpulse { get; }

The specific impulse of the engine at sea level on Kerbin, in seconds.

Game Scenes: All
IList<String> PropellantNames { get; }

The names of the propellants that the engine consumes.

Game Scenes: All
IDictionary<String, Single> PropellantRatios { get; }

The ratio of resources that the engine consumes. A dictionary mapping resource names to the ratio at which they are consumed by the engine.

Game Scenes: All

Note

For example, if the ratios are 0.6 for LiquidFuel and 0.4 for Oxidizer, then for every 0.6 units of LiquidFuel that the engine burns, it will burn 0.4 units of Oxidizer.

IList<Propellant> Propellants { get; }

The propellants that the engine consumes.

Game Scenes: All
Boolean HasFuel { get; }

Whether the engine has any fuel available.

Game Scenes: All

Note

The engine must be activated for this property to update correctly.

Single Throttle { get; }

The current throttle setting for the engine. A value between 0 and 1. This is not necessarily the same as the vessel’s main throttle setting, as some engines take time to adjust their throttle (such as jet engines).

Game Scenes: All
Boolean ThrottleLocked { get; }

Whether the Control.Throttle affects the engine. For example, this is true for liquid fueled rockets, and false for solid rocket boosters.

Game Scenes: All
Boolean CanRestart { get; }

Whether the engine can be restarted once shutdown. If the engine cannot be shutdown, returns false. For example, this is true for liquid fueled rockets and false for solid rocket boosters.

Game Scenes: All
Boolean CanShutdown { get; }

Whether the engine can be shutdown once activated. For example, this is true for liquid fueled rockets and false for solid rocket boosters.

Game Scenes: All
Boolean HasModes { get; }

Whether the engine has multiple modes of operation.

Game Scenes: All
String Mode { get; set; }

The name of the current engine mode.

Game Scenes: All
IDictionary<String, Engine> Modes { get; }

The available modes for the engine. A dictionary mapping mode names to Engine objects.

Game Scenes: All
void ToggleMode ()

Toggle the current engine mode.

Game Scenes: All
Boolean AutoModeSwitch { get; set; }

Whether the engine will automatically switch modes.

Game Scenes: All
Boolean Gimballed { get; }

Whether the engine is gimballed.

Game Scenes: All
Single GimbalRange { get; }

The range over which the gimbal can move, in degrees. Returns 0 if the engine is not gimballed.

Game Scenes: All
Boolean GimbalLocked { get; set; }

Whether the engines gimbal is locked in place. Setting this attribute has no effect if the engine is not gimballed.

Game Scenes: All
Single GimbalLimit { get; set; }

The gimbal limiter of the engine. A value between 0 and 1. Returns 0 if the gimbal is locked.

Game Scenes: All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> AvailableTorque { get; }

The available torque, in Newton meters, that can be produced by this engine, in the positive and negative pitch, roll and yaw axes of the vessel. These axes correspond to the coordinate axes of the Vessel.ReferenceFrame. Returns zero if the engine is inactive, or not gimballed.

Game Scenes: All
class Propellant

A propellant for an engine. Obtains by calling Engine.Propellants.

String Name { get; }

The name of the propellant.

Game Scenes: All
Double CurrentAmount { get; }

The current amount of propellant.

Game Scenes: All
Double CurrentRequirement { get; }

The required amount of propellant.

Game Scenes: All
Double TotalResourceAvailable { get; }

The total amount of the underlying resource currently reachable given resource flow rules.

Game Scenes: All
Double TotalResourceCapacity { get; }

The total vehicle capacity for the underlying propellant resource, restricted by resource flow rules.

Game Scenes: All
Boolean IgnoreForIsp { get; }

If this propellant should be ignored when calculating required mass flow given specific impulse.

Game Scenes: All
Boolean IgnoreForThrustCurve { get; }

If this propellant should be ignored for thrust curve calculations.

Game Scenes: All
Boolean DrawStackGauge { get; }

If this propellant has a stack gauge or not.

Game Scenes: All
Boolean IsDeprived { get; }

If this propellant is deprived.

Game Scenes: All
Single Ratio { get; }

The propellant ratio.

Game Scenes: All

### Experiment¶

class Experiment

Obtained by calling Part.Experiment.

Part Part { get; }

The part object for this experiment.

Game Scenes: All
void Run ()

Run the experiment.

Game Scenes: All
void Transmit ()

Transmit all experimental data contained by this part.

Game Scenes: All
void Dump ()

Dump the experimental data contained by the experiment.

Game Scenes: All
void Reset ()

Reset the experiment.

Game Scenes: All
Boolean Deployed { get; }

Whether the experiment has been deployed.

Game Scenes: All
Boolean Rerunnable { get; }

Whether the experiment can be re-run.

Game Scenes: All
Boolean Inoperable { get; }

Whether the experiment is inoperable.

Game Scenes: All
Boolean HasData { get; }

Whether the experiment contains data.

Game Scenes: All
IList<ScienceData> Data { get; }

The data contained in this experiment.

Game Scenes: All
String Biome { get; }

The name of the biome the experiment is currently in.

Game Scenes: All
Boolean Available { get; }

Determines if the experiment is available given the current conditions.

Game Scenes: All
ScienceSubject ScienceSubject { get; }

Containing information on the corresponding specific science result for the current conditions. Returns null if the experiment is unavailable.

Game Scenes: All
class ScienceData

Obtained by calling Experiment.Data.

Single DataAmount { get; }

Data amount.

Game Scenes: All
Single ScienceValue { get; }

Science value.

Game Scenes: All
Single TransmitValue { get; }

Transmit value.

Game Scenes: All
class ScienceSubject

Obtained by calling Experiment.ScienceSubject.

String Title { get; }

Title of science subject, displayed in science archives

Game Scenes: All
Boolean IsComplete { get; }

Whether the experiment has been completed.

Game Scenes: All
Single Science { get; }

Amount of science already earned from this subject, not updated until after transmission/recovery.

Game Scenes: All
Single ScienceCap { get; }

Total science allowable for this subject.

Game Scenes: All
Single DataScale { get; }

Multiply science value by this to determine data amount in mits.

Game Scenes: All
Single SubjectValue { get; }

Multiplier for specific Celestial Body/Experiment Situation combination.

Game Scenes: All
Single ScientificValue { get; }

Diminishing value multiplier for decreasing the science value returned from repeated experiments.

Game Scenes: All

### Fairing¶

class Fairing

A fairing. Obtained by calling Part.Fairing.

Part Part { get; }

The part object for this fairing.

Game Scenes: All
void Jettison ()

Jettison the fairing. Has no effect if it has already been jettisoned.

Game Scenes: All
Boolean Jettisoned { get; }

Whether the fairing has been jettisoned.

Game Scenes: All

### Intake¶

class Intake

An air intake. Obtained by calling Part.Intake.

Part Part { get; }

The part object for this intake.

Game Scenes: All
Boolean Open { get; set; }

Whether the intake is open.

Game Scenes: All
Single Speed { get; }

Speed of the flow into the intake, in $$m/s$$.

Game Scenes: All
Single Flow { get; }

The rate of flow into the intake, in units of resource per second.

Game Scenes: All
Single Area { get; }

The area of the intake’s opening, in square meters.

Game Scenes: All

### Leg¶

class Leg

A landing leg. Obtained by calling Part.Leg.

Part Part { get; }

The part object for this landing leg.

Game Scenes: All
LegState State { get; }

The current state of the landing leg.

Game Scenes: All
Boolean Deployable { get; }

Whether the leg is deployable.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the landing leg is deployed.

Game Scenes: All

Note

Fixed landing legs are always deployed. Returns an error if you try to deploy fixed landing gear.

Boolean IsGrounded { get; }

Returns whether the leg is touching the ground.

Game Scenes: All
enum LegState

The state of a landing leg. See Leg.State.

Deployed

Landing leg is fully deployed.

Retracted

Landing leg is fully retracted.

Deploying

Landing leg is being deployed.

Retracting

Landing leg is being retracted.

Broken

Landing leg is broken.

### Launch Clamp¶

class LaunchClamp

A launch clamp. Obtained by calling Part.LaunchClamp.

Part Part { get; }

The part object for this launch clamp.

Game Scenes: All
void Release ()

Releases the docking clamp. Has no effect if the clamp has already been released.

Game Scenes: All

### Light¶

class Light

A light. Obtained by calling Part.Light.

Part Part { get; }

The part object for this light.

Game Scenes: All
Boolean Active { get; set; }

Whether the light is switched on.

Game Scenes: All
Tuple<Single, Single, Single> Color { get; set; }

The color of the light, as an RGB triple.

Game Scenes: All
Single PowerUsage { get; }

The current power usage, in units of charge per second.

Game Scenes: All

### Parachute¶

class Parachute

A parachute. Obtained by calling Part.Parachute.

Part Part { get; }

The part object for this parachute.

Game Scenes: All
void Deploy ()

Deploys the parachute. This has no effect if the parachute has already been deployed.

Game Scenes: All
Boolean Deployed { get; }

Whether the parachute has been deployed.

Game Scenes: All
void Arm ()

Deploys the parachute. This has no effect if the parachute has already been armed or deployed. Only applicable to RealChutes parachutes.

Game Scenes: All
Boolean Armed { get; }

Whether the parachute has been armed or deployed. Only applicable to RealChutes parachutes.

Game Scenes: All
ParachuteState State { get; }

The current state of the parachute.

Game Scenes: All
Single DeployAltitude { get; set; }

The altitude at which the parachute will full deploy, in meters. Only applicable to stock parachutes.

Game Scenes: All
Single DeployMinPressure { get; set; }

The minimum pressure at which the parachute will semi-deploy, in atmospheres. Only applicable to stock parachutes.

Game Scenes: All
enum ParachuteState

The state of a parachute. See Parachute.State.

Stowed

The parachute is safely tucked away inside its housing.

Armed

The parachute is armed for deployment. (RealChutes only)

Active

The parachute is still stowed, but ready to semi-deploy. (Stock parachutes only)

SemiDeployed

The parachute has been deployed and is providing some drag, but is not fully deployed yet. (Stock parachutes only)

Deployed

The parachute is fully deployed.

Cut

The parachute has been cut.

class Radiator

A radiator. Obtained by calling Part.Radiator.

Part Part { get; }

The part object for this radiator.

Game Scenes: All
Boolean Deployable { get; }

Game Scenes: All
Boolean Deployed { get; set; }

For a deployable radiator, true if the radiator is extended. If the radiator is not deployable, this is always true.

Game Scenes: All
RadiatorState State { get; }

The current state of the radiator.

Game Scenes: All

Note

A fixed radiator is always RadiatorState.Extended.

enum RadiatorState

The state of a radiator. RadiatorState

Extended

Retracted

Extending

Retracting

Broken

### Resource Converter¶

class ResourceConverter

A resource converter. Obtained by calling Part.ResourceConverter.

Part Part { get; }

The part object for this converter.

Game Scenes: All
Int32 Count { get; }

The number of converters in the part.

Game Scenes: All
String Name (Int32 index)

The name of the specified converter.

Parameters: index – Index of the converter. All
Boolean Active (Int32 index)

True if the specified converter is active.

Parameters: index – Index of the converter. All
void Start (Int32 index)

Start the specified converter.

Parameters: index – Index of the converter. All
void Stop (Int32 index)

Stop the specified converter.

Parameters: index – Index of the converter. All
ResourceConverterState State (Int32 index)

The state of the specified converter.

Parameters: index – Index of the converter. All
String StatusInfo (Int32 index)

Status information for the specified converter. This is the full status message shown in the in-game UI.

Parameters: index – Index of the converter. All
IList<String> Inputs (Int32 index)

List of the names of resources consumed by the specified converter.

Parameters: index – Index of the converter. All
IList<String> Outputs (Int32 index)

List of the names of resources produced by the specified converter.

Parameters: index – Index of the converter. All
Single OptimumCoreTemperature { get; }

The core temperature at which the converter will operate with peak efficiency, in Kelvin.

Game Scenes: All
Single CoreTemperature { get; }

The core temperature of the converter, in Kelvin.

Game Scenes: All
Single ThermalEfficiency { get; }

The thermal efficiency of the converter, as a percentage of its maximum.

Game Scenes: All
enum ResourceConverterState

The state of a resource converter. See ResourceConverter.State.

Running

Converter is running.

Idle

Converter is idle.

MissingResource

Converter is missing a required resource.

StorageFull

No available storage for output resource.

Capacity

At preset resource capacity.

Unknown

Unknown state. Possible with modified resource converters. In this case, check ResourceConverter.StatusInfo for more information.

### Resource Harvester¶

class ResourceHarvester

A resource harvester (drill). Obtained by calling Part.ResourceHarvester.

Part Part { get; }

The part object for this harvester.

Game Scenes: All
ResourceHarvesterState State { get; }

The state of the harvester.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the harvester is deployed.

Game Scenes: All
Boolean Active { get; set; }

Whether the harvester is actively drilling.

Game Scenes: All
Single ExtractionRate { get; }

The rate at which the drill is extracting ore, in units per second.

Game Scenes: All
Single ThermalEfficiency { get; }

The thermal efficiency of the drill, as a percentage of its maximum.

Game Scenes: All
Single CoreTemperature { get; }

The core temperature of the drill, in Kelvin.

Game Scenes: All
Single OptimumCoreTemperature { get; }

The core temperature at which the drill will operate with peak efficiency, in Kelvin.

Game Scenes: All
enum ResourceHarvesterState

The state of a resource harvester. See ResourceHarvester.State.

Deploying

The drill is deploying.

Deployed

The drill is deployed and ready.

Retracting

The drill is retracting.

Retracted

The drill is retracted.

Active

The drill is running.

### Reaction Wheel¶

class ReactionWheel

A reaction wheel. Obtained by calling Part.ReactionWheel.

Part Part { get; }

The part object for this reaction wheel.

Game Scenes: All
Boolean Active { get; set; }

Whether the reaction wheel is active.

Game Scenes: All
Boolean Broken { get; }

Whether the reaction wheel is broken.

Game Scenes: All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> AvailableTorque { get; }

The available torque, in Newton meters, that can be produced by this reaction wheel, in the positive and negative pitch, roll and yaw axes of the vessel. These axes correspond to the coordinate axes of the Vessel.ReferenceFrame. Returns zero if the reaction wheel is inactive or broken.

Game Scenes: All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> MaxTorque { get; }

The maximum torque, in Newton meters, that can be produced by this reaction wheel, when it is active, in the positive and negative pitch, roll and yaw axes of the vessel. These axes correspond to the coordinate axes of the Vessel.ReferenceFrame.

Game Scenes: All

### RCS¶

class RCS

An RCS block or thruster. Obtained by calling Part.RCS.

Part Part { get; }

The part object for this RCS.

Game Scenes: All
Boolean Active { get; }

Whether the RCS thrusters are active. An RCS thruster is inactive if the RCS action group is disabled (Control.RCS), the RCS thruster itself is not enabled (RCS.Enabled) or it is covered by a fairing (Part.Shielded).

Game Scenes: All
Boolean Enabled { get; set; }

Whether the RCS thrusters are enabled.

Game Scenes: All
Boolean PitchEnabled { get; set; }

Whether the RCS thruster will fire when pitch control input is given.

Game Scenes: All
Boolean YawEnabled { get; set; }

Whether the RCS thruster will fire when yaw control input is given.

Game Scenes: All
Boolean RollEnabled { get; set; }

Whether the RCS thruster will fire when roll control input is given.

Game Scenes: All
Boolean ForwardEnabled { get; set; }

Whether the RCS thruster will fire when pitch control input is given.

Game Scenes: All
Boolean UpEnabled { get; set; }

Whether the RCS thruster will fire when yaw control input is given.

Game Scenes: All
Boolean RightEnabled { get; set; }

Whether the RCS thruster will fire when roll control input is given.

Game Scenes: All
Tuple<Tuple<Double, Double, Double>, Tuple<Double, Double, Double>> AvailableTorque { get; }

The available torque, in Newton meters, that can be produced by this RCS, in the positive and negative pitch, roll and yaw axes of the vessel. These axes correspond to the coordinate axes of the Vessel.ReferenceFrame. Returns zero if RCS is disable.

Game Scenes: All
Single MaxThrust { get; }

The maximum amount of thrust that can be produced by the RCS thrusters when active, in Newtons.

Game Scenes: All
Single MaxVacuumThrust { get; }

The maximum amount of thrust that can be produced by the RCS thrusters when active in a vacuum, in Newtons.

Game Scenes: All
IList<Thruster> Thrusters { get; }

A list of thrusters, one of each nozzel in the RCS part.

Game Scenes: All
Single SpecificImpulse { get; }

The current specific impulse of the RCS, in seconds. Returns zero if the RCS is not active.

Game Scenes: All
Single VacuumSpecificImpulse { get; }

The vacuum specific impulse of the RCS, in seconds.

Game Scenes: All
Single KerbinSeaLevelSpecificImpulse { get; }

The specific impulse of the RCS at sea level on Kerbin, in seconds.

Game Scenes: All
IList<String> Propellants { get; }

The names of resources that the RCS consumes.

Game Scenes: All
IDictionary<String, Single> PropellantRatios { get; }

The ratios of resources that the RCS consumes. A dictionary mapping resource names to the ratios at which they are consumed by the RCS.

Game Scenes: All
Boolean HasFuel { get; }

Whether the RCS has fuel available.

Game Scenes: All

Note

The RCS thruster must be activated for this property to update correctly.

### Sensor¶

class Sensor

A sensor, such as a thermometer. Obtained by calling Part.Sensor.

Part Part { get; }

The part object for this sensor.

Game Scenes: All
Boolean Active { get; set; }

Whether the sensor is active.

Game Scenes: All
String Value { get; }

The current value of the sensor.

Game Scenes: All

### Solar Panel¶

class SolarPanel

A solar panel. Obtained by calling Part.SolarPanel.

Part Part { get; }

The part object for this solar panel.

Game Scenes: All
Boolean Deployable { get; }

Whether the solar panel is deployable.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the solar panel is extended.

Game Scenes: All
SolarPanelState State { get; }

The current state of the solar panel.

Game Scenes: All
Single EnergyFlow { get; }

The current amount of energy being generated by the solar panel, in units of charge per second.

Game Scenes: All
Single SunExposure { get; }

The current amount of sunlight that is incident on the solar panel, as a percentage. A value between 0 and 1.

Game Scenes: All
enum SolarPanelState

The state of a solar panel. See SolarPanel.State.

Extended

Solar panel is fully extended.

Retracted

Solar panel is fully retracted.

Extending

Solar panel is being extended.

Retracting

Solar panel is being retracted.

Broken

Solar panel is broken.

### Thruster¶

class Thruster

The component of an Engine or RCS part that generates thrust. Can obtained by calling Engine.Thrusters or RCS.Thrusters.

Note

Engines can consist of multiple thrusters. For example, the S3 KS-25x4 “Mammoth” has four rocket nozzels, and so consists of four thrusters.

Part Part { get; }

The Part that contains this thruster.

Game Scenes: All
Tuple<Double, Double, Double> ThrustPosition (ReferenceFrame referenceFrame)

The position at which the thruster generates thrust, in the given reference frame. For gimballed engines, this takes into account the current rotation of the gimbal.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All
Tuple<Double, Double, Double> ThrustDirection (ReferenceFrame referenceFrame)

The direction of the force generated by the thruster, in the given reference frame. This is opposite to the direction in which the thruster expels propellant. For gimballed engines, this takes into account the current rotation of the gimbal.

Parameters: referenceFrame – The reference frame that the returned direction is in. The direction as a unit vector. All
ReferenceFrame ThrustReferenceFrame { get; }

A reference frame that is fixed relative to the thruster and orientated with its thrust direction (Thruster.ThrustDirection). For gimballed engines, this takes into account the current rotation of the gimbal.

• The origin is at the position of thrust for this thruster (Thruster.ThrustPosition).
• The axes rotate with the thrust direction. This is the direction in which the thruster expels propellant, including any gimballing.
• The y-axis points along the thrust direction.
• The x-axis and z-axis are perpendicular to the thrust direction.
Game Scenes: All
Boolean Gimballed { get; }

Whether the thruster is gimballed.

Game Scenes: All
Tuple<Double, Double, Double> GimbalPosition (ReferenceFrame referenceFrame)

Position around which the gimbal pivots.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All
Tuple<Double, Double, Double> GimbalAngle { get; }

The current gimbal angle in the pitch, roll and yaw axes, in degrees.

Game Scenes: All
Tuple<Double, Double, Double> InitialThrustPosition (ReferenceFrame referenceFrame)

The position at which the thruster generates thrust, when the engine is in its initial position (no gimballing), in the given reference frame.

Parameters: referenceFrame – The reference frame that the returned position vector is in. The position as a vector. All

Note

This position can move when the gimbal rotates. This is because the thrust position and gimbal position are not necessarily the same.

Tuple<Double, Double, Double> InitialThrustDirection (ReferenceFrame referenceFrame)

The direction of the force generated by the thruster, when the engine is in its initial position (no gimballing), in the given reference frame. This is opposite to the direction in which the thruster expels propellant.

Parameters: referenceFrame – The reference frame that the returned direction is in. The direction as a unit vector. All

### Wheel¶

class Wheel

A wheel. Includes landing gear and rover wheels. Obtained by calling Part.Wheel. Can be used to control the motors, steering and deployment of wheels, among other things.

Part Part { get; }

The part object for this wheel.

Game Scenes: All
WheelState State { get; }

The current state of the wheel.

Game Scenes: All
Single Radius { get; }

Radius of the wheel, in meters.

Game Scenes: All
Boolean Grounded { get; }

Whether the wheel is touching the ground.

Game Scenes: All
Boolean HasBrakes { get; }

Whether the wheel has brakes.

Game Scenes: All
Single Brakes { get; set; }

The braking force, as a percentage of maximum, when the brakes are applied.

Game Scenes: All
Boolean AutoFrictionControl { get; set; }

Whether automatic friction control is enabled.

Game Scenes: All
Single ManualFrictionControl { get; set; }

Manual friction control value. Only has an effect if automatic friction control is disabled. A value between 0 and 5 inclusive.

Game Scenes: All
Boolean Deployable { get; }

Whether the wheel is deployable.

Game Scenes: All
Boolean Deployed { get; set; }

Whether the wheel is deployed.

Game Scenes: All
Boolean Powered { get; }

Game Scenes: All
Boolean MotorEnabled { get; set; }

Whether the motor is enabled.

Game Scenes: All
Boolean MotorInverted { get; set; }

Whether the direction of the motor is inverted.

Game Scenes: All
MotorState MotorState { get; }

Whether the direction of the motor is inverted.

Game Scenes: All
Single MotorOutput { get; }

The output of the motor. This is the torque currently being generated, in Newton meters.

Game Scenes: All
Boolean TractionControlEnabled { get; set; }

Whether automatic traction control is enabled. A wheel only has traction control if it is powered.

Game Scenes: All
Single TractionControl { get; set; }

Setting for the traction control. Only takes effect if the wheel has automatic traction control enabled. A value between 0 and 5 inclusive.

Game Scenes: All
Single DriveLimiter { get; set; }

Manual setting for the motor limiter. Only takes effect if the wheel has automatic traction control disabled. A value between 0 and 100 inclusive.

Game Scenes: All
Boolean Steerable { get; }

Whether the wheel has steering.

Game Scenes: All
Boolean SteeringEnabled { get; set; }

Whether the wheel steering is enabled.

Game Scenes: All
Boolean SteeringInverted { get; set; }

Whether the wheel steering is inverted.

Game Scenes: All
Boolean HasSuspension { get; }

Whether the wheel has suspension.

Game Scenes: All
Single SuspensionSpringStrength { get; }

Suspension spring strength, as set in the editor.

Game Scenes: All
Single SuspensionDamperStrength { get; }

Suspension damper strength, as set in the editor.

Game Scenes: All
Boolean Broken { get; }

Whether the wheel is broken.

Game Scenes: All
Boolean Repairable { get; }

Whether the wheel is repairable.

Game Scenes: All
Single Stress { get; }

Current stress on the wheel.

Game Scenes: All
Single StressTolerance { get; }

Stress tolerance of the wheel.

Game Scenes: All
Single StressPercentage { get; }

Current stress on the wheel as a percentage of its stress tolerance.

Game Scenes: All
Single Deflection { get; }

Current deflection of the wheel.

Game Scenes: All
Single Slip { get; }

Current slip of the wheel.

Game Scenes: All
enum WheelState

The state of a wheel. See Wheel.State.

Deployed

Wheel is fully deployed.

Retracted

Wheel is fully retracted.

Deploying

Wheel is being deployed.

Retracting

Wheel is being retracted.

Broken

Wheel is broken.

enum MotorState

The state of the motor on a powered wheel. See Wheel.MotorState.

Idle

The motor is idle.

Running

The motor is running.

Disabled

The motor is disabled.

Inoperable

The motor is inoperable.

NotEnoughResources

The motor does not have enough resources to run.

## Trees of Parts¶

Vessels in KSP are comprised of a number of parts, connected to one another in a tree structure. An example vessel is shown in Figure 1, and the corresponding tree of parts in Figure 2. The craft file for this example can also be downloaded here.

Figure 1 – Example parts making up a vessel.

Figure 2 – Tree of parts for the vessel in Figure 1. Arrows point from the parent part to the child part.

### Traversing the Tree¶

The tree of parts can be traversed using the attributes Parts.Root, Part.Parent and Part.Children.

The root of the tree is the same as the vessels root part (part number 1 in the example above) and can be obtained by calling Parts.Root. A parts children can be obtained by calling Part.Children. If the part does not have any children, Part.Children returns an empty list. A parts parent can be obtained by calling Part.Parent. If the part does not have a parent (as is the case for the root part), Part.Parent returns null.

The following C# example uses these attributes to perform a depth-first traversal over all of the parts in a vessel:

using System;
using System.Collections.Generic;
using System.Net;
using KRPC.Client;
using KRPC.Client.Services.SpaceCenter;

class AttachmentModes
{
public static void Main ()
{
using (var connection = new Connection ()) {
var vessel = connection.SpaceCenter ().ActiveVessel;
var root = vessel.Parts.Root;
var stack = new Stack<Tuple<Part,int>> ();
stack.Push (new Tuple<Part,int> (root, 0));
while (stack.Count > 0) {
var item = stack.Pop ();
Part part = item.Item1;
int depth = item.Item2;
Console.WriteLine (new String (' ', depth) + part.Title);
foreach (var child in part.Children)
stack.Push (new Tuple<Part,int> (child, depth + 1));
}
}
}
}


When this code is execute using the craft file for the example vessel pictured above, the following is printed out:

Command Pod Mk1
TR-18A Stack Decoupler
FL-T400 Fuel Tank
LV-909 Liquid Fuel Engine
TR-18A Stack Decoupler
FL-T800 Fuel Tank
LV-909 Liquid Fuel Engine
FL-T400 Fuel Tank
TT18-A Launch Stability Enhancer
FTX-2 External Fuel Duct
LV-909 Liquid Fuel Engine
Aerodynamic Nose Cone
FL-T400 Fuel Tank
TT18-A Launch Stability Enhancer
FTX-2 External Fuel Duct
LV-909 Liquid Fuel Engine
Aerodynamic Nose Cone
LT-1 Landing Struts
LT-1 Landing Struts
Mk16 Parachute


### Attachment Modes¶

Parts can be attached to other parts either radially (on the side of the parent part) or axially (on the end of the parent part, to form a stack).

For example, in the vessel pictured above, the parachute (part 2) is axially connected to its parent (the command pod – part 1), and the landing leg (part 5) is radially connected to its parent (the fuel tank – part 4).

The root part of a vessel (for example the command pod – part 1) does not have a parent part, so does not have an attachment mode. However, the part is consider to be axially attached to nothing.

The following C# example does a depth-first traversal as before, but also prints out the attachment mode used by the part:

using System;
using System.Collections.Generic;
using System.Net;
using KRPC.Client;
using KRPC.Client.Services.SpaceCenter;

class AttachmentModes
{
public static void Main ()
{
using (var connection = new Connection ()) {
var vessel = connection.SpaceCenter ().ActiveVessel;
var root = vessel.Parts.Root;
var stack = new Stack<Tuple<Part,int>> ();
stack.Push (new Tuple<Part,int> (root, 0));
while (stack.Count > 0) {
var item = stack.Pop ();
Part part = item.Item1;
int depth = item.Item2;
string attachMode = (part.AxiallyAttached ? "axial" : "radial");
Console.WriteLine (new String (' ', depth) + part.Title + " - " + attachMode);
foreach (var child in part.Children)
stack.Push (new Tuple<Part,int> (child, depth + 1));
}
}
}
}


When this code is execute using the craft file for the example vessel pictured above, the following is printed out:

Command Pod Mk1 - axial
TR-18A Stack Decoupler - axial
FL-T400 Fuel Tank - axial
LV-909 Liquid Fuel Engine - axial
TR-18A Stack Decoupler - axial
FL-T800 Fuel Tank - axial
LV-909 Liquid Fuel Engine - axial
TT18-A Launch Stability Enhancer - radial
FTX-2 External Fuel Duct - radial
LV-909 Liquid Fuel Engine - axial
Aerodynamic Nose Cone - axial
TT18-A Launch Stability Enhancer - radial
FTX-2 External Fuel Duct - radial
LV-909 Liquid Fuel Engine - axial
Aerodynamic Nose Cone - axial
Mk16 Parachute - axial


## Fuel Lines¶

Figure 5 – Fuel lines from the example in Figure 1. Fuel flows from the parts highlighted in green, into the part highlighted in blue.

Figure 4 – A subset of the parts tree from Figure 2 above.

Fuel lines are considered parts, and are included in the parts tree (for example, as pictured in Figure 4). However, the parts tree does not contain information about which parts fuel lines connect to. The parent part of a fuel line is the part from which it will take fuel (as shown in Figure 4) however the part that it will send fuel to is not represented in the parts tree.

Figure 5 shows the fuel lines from the example vessel pictured earlier. Fuel line part 15 (in red) takes fuel from a fuel tank (part 11 – in green) and feeds it into another fuel tank (part 9 – in blue). The fuel line is therefore a child of part 11, but its connection to part 9 is not represented in the tree.

The attributes Part.FuelLinesFrom and Part.FuelLinesTo can be used to discover these connections. In the example in Figure 5, when Part.FuelLinesTo is called on fuel tank part 11, it will return a list of parts containing just fuel tank part 9 (the blue part). When Part.FuelLinesFrom is called on fuel tank part 9, it will return a list containing fuel tank parts 11 and 17 (the parts colored green).

## Staging¶

Figure 6 – Example vessel from Figure 1 with a staging sequence.

Each part has two staging numbers associated with it: the stage in which the part is activated and the stage in which the part is decoupled. These values can be obtained using Part.Stage and Part.DecoupleStage respectively. For parts that are not activated by staging, Part.Stage returns -1. For parts that are never decoupled, Part.DecoupleStage returns a value of -1.

Figure 6 shows an example staging sequence for a vessel. Figure 7 shows the stages in which each part of the vessel will be activated. Figure 8 shows the stages in which each part of the vessel will be decoupled.

Figure 7 – The stage in which each part is activated.

Figure 8 – The stage in which each part is decoupled.