Kerbal Operating System

https://ksp-kos.github.io/KOS
Admin
Kerbal Operating System is a Kerbal Space Program mod that provides a scriptable autopilot system...
Tokens:503,885
Snippets:5,492
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### PopupMenu Example

Source: https://ksp-kos.github.io/KOS/structures/gui_widgets/popupmenu.html

An example demonstrating how to create and configure a PopupMenu.

```APIDOC
## PopupMenu Example

```kos
local popup is gui:addpopupmenu().

// Make the popup display the Body:NAME's instead of the Body:TOSTRING's:
set popup:OPTIONSUFFIX to "NAME".

list bodies in bodies.
for planet in bodies {
        if planet:hasbody and planet:body = Sun {
                popup:addoption(planet).
        }
}
set popup:value to body.
```

### Description of Example
This example creates a `PopupMenu`, sets its `OPTIONSUFFIX` to `"NAME"` to display the names of celestial bodies, populates it with celestial bodies orbiting the Sun, and then sets the initial selected value to the current `body`.
```

--------------------------------

### Example Usage

Source: https://ksp-kos.github.io/KOS/_sources/addons/IR.rst.txt

Example KOS script demonstrating how to interact with the IR Servo module.

```APIDOC
## Example Usage

### Description
This example script shows how to check for IR availability, iterate through control groups and servos, and command a servo to move.

### Code Example
```kos
print "IR Iavailable: " + ADDONS:IR:AVAILABLE.

Print "Groups:".

for g in ADDONS:IR:GROUPS
{
    Print g:NAME + " contains " + g:SERVOS:LENGTH + " servos:".
    for s in g:servos
    {
        print "    " + s:NAME + ", position: " + s:POSITION.
        if (g:NAME = "Hinges" and s:POSITION = 0)
        {
            s:MOVETO(30, 2).
        }
    }
}
```
```

--------------------------------

### Basic Kerboscript: Hello World

Source: https://ksp-kos.github.io/KOS/_sources/index.rst.txt

A simple kerboscript example to print messages. This is often the first script a user will write when starting with kOS.

```kerboscript
PRINT "Hello World.".
PRINT "These are the documents for Kerbal Operating System.".
```

--------------------------------

### Observe Science Experiment

Source: https://ksp-kos.github.io/KOS/_sources/structures/vessels/scienceexperiment.rst.txt

This example shows how to get a module that contains a science experiment and then trigger its 'observe' event. Note that this method may result in a user dialog.

```kOS
SET P TO SHIP:PARTSNAMED("GooExperiment")[1].
SET M TO P:GETMODULE("ModuleScienceExperiment").
M:DOEVENT("observe mystery goo").
```

--------------------------------

### Example Output

Source: https://ksp-kos.github.io/KOS/_sources/language/variables.rst.txt

The console output resulting from the variable scoping example.

```none
Inside calcAverage, sum is 30
average is 10
but out here where it's global, sum is still -1
```

--------------------------------

### Message Forwarding Example

Source: https://ksp-kos.github.io/KOS/_sources/structures/communication/message.rst.txt

An example demonstrating how to forward a message from one CPU to another using kOS scripting.

```APIDOC
## Message Forwarding Example

This example shows how to retrieve a message from the ship's message queue and forward it to a different CPU.

### Script Example

```ksc
// if there is a message in the ship's message queue
// we can forward it to a different CPU

// cpu1
SET CPU2 TO PROCESSOR("cpu2").
CPU2:CONNECTION:SENDMESSAGE(SHIP:MESSAGES:POP).

// cpu2
SET RECEIVED TO CORE:MESSAGES:POP.
PRINT "Original message sent at: " + RECEIVED:CONTENT:SENTAT.
```

### Explanation

On `cpu1`, a connection is established to `cpu2`. The oldest message from `SHIP:MESSAGES` is then popped and sent to `cpu2`. On `cpu2`, the received message is popped from its own message queue, and its original sending timestamp is printed.
```

--------------------------------

### Basic PIDLoop Hover Example

Source: https://ksp-kos.github.io/KOS/_sources/structures/misc/pidloop.rst.txt

A complete script example for hovering a rocket at a specific altitude using a PIDLoop.

```kOS
// Example PIDLoop usage to hover a rocket at 100 meters off the ground:
    // Please use it with a rocket that has lots of fuel to test it,
    // and a TWR between about 1.75 and 2.0.

    lock steering to up.

    print "Setting up PID structure:".
    set hoverPID to PIDLoop(0.02, 0.0015, 0.02, 0, 1).
    set hoverPID:SETPOINT to 100.

    set wanted_throttle to 0. // for now.
    lock throttle to wanted_throttle.

    print "Now starting loop:".
    print "Make sure you stage until the engine is active.".
    print "You will have to kill it with CTRL-C".
    until false {
      set wanted_throttle to hoverPID:UPDATE(time:seconds, alt:radar).
      print "Radar Alt " + round(alt:radar,1) + "m, PID wants throttle=" + round(wanted_throttle,3).
      wait 0.
    }
```

--------------------------------

### kOSProcessor Module Configuration Example

Source: https://ksp-kos.github.io/KOS/general/kospartmodule.html

An example of how to configure the kOSProcessor module within a part's .cfg file, including common and optional fields.

```APIDOC
## MODULE kOSProcessor Configuration Example

### Description
This is an example of the kOS processor module configuration, typically found in `GameData/kOS/Parts/` name_of_part_here `/part.cfg` files.

### Method
Not Applicable (Configuration File)

### Endpoint
Not Applicable (Configuration File)

### Parameters
#### Configuration Fields
- **name** (string) - Required - Must be `kOSProcessor`.
- **diskSpace** (integer) - Optional - Default: 1024. The default disk space for the part.
- **ECPerBytePerSecond** (float) - Optional - Default: 0.0. ElectricCharge consumed per byte of available disk space per second.
- **ECPerInstruction** (float) - Optional - Default: 0.000004. ElectricCharge consumed per instruction executed.
- **baseDiskSpace** (integer) - Optional - Default: Copied from `diskSpace`. The minimum disk space selectable via the VAB slider.
- **diskSpaceCostFactor** (float) - Optional - Default: 0.0244140625. Additional cost per byte of disk space added via the editor tweakable.
- **baseModuleCost** (float) - Optional - Default: 0.0. Additional cost added to the part by including this module.
- **diskSpaceMassFactor** (float) - Optional - Default: 0.0000048829. Mass added per byte of disk space.
- **baseModuleMass** (float) - Optional - Default: 0.0. Base mass added to the part by this module.

### Request Example
```
MODULE
{
    name = kOSProcessor
    diskSpace = 5000
    ECPerBytePerSecond = 0
    ECPerInstruction = 0.000004
    # Optional fields shown below with default value
    # baseDiskSpace = 0
    # diskSpaceCostFactor = 0.0244140625
    # baseModuleCost = 0
    # diskSpaceMassFactor = 0.0000048829
    # baseModuleMass = 0
}
```

### Response
Not Applicable (Configuration File)
```

--------------------------------

### Until Loop Output Example

Source: https://ksp-kos.github.io/KOS/tutorials/basictutorial.html

The expected output of the combined `until`, `lock`, and `wait` example, showing the calculated `Multiplier` values printed over time.

```kos
0
2
4
6
8
10
```

--------------------------------

### Basic Rocket Hover PIDLoop Example

Source: https://ksp-kos.github.io/KOS/structures/misc/pidloop.html

A complete script example for hovering a rocket at a specific radar altitude.

```kOS
// Example PIDLoop usage to hover a rocket at 100 meters off the ground:
// Please use it with a rocket that has lots of fuel to test it,
// and a TWR between about 1.75 and 2.0.

lock steering to up.

print "Setting up PID structure:".
set hoverPID to PIDLoop(0.02, 0.0015, 0.02, 0, 1).
set hoverPID:SETPOINT to 100.

set wanted_throttle to 0. // for now.
lock throttle to wanted_throttle.

print "Now starting loop:".
print "Make sure you stage until the engine is active.".
print "You will have to kill it with CTRL-C".
until false {
  set wanted_throttle to hoverPID:UPDATE(time:seconds, alt:radar).
  print "Radar Alt " + round(alt:radar,1) + "m, PID wants throttle=" + round(wanted_throttle,3).
  wait 0.
}
```

--------------------------------

### Script Parameter Handling Example

Source: https://ksp-kos.github.io/KOS/commands/runprogram.html

This example shows how arguments passed to a script are received as parameters within the script itself. The parameters are assigned values based on the order they are passed.

```kos
// AutoLaunch.ks program file:
parameter final_alt, do_countdown, message.
//
// rest of program not shown...
//
```

--------------------------------

### Quick Start 1: Radar Altitude

Source: https://ksp-kos.github.io/KOS/structures/vessels/bounds.html

Example demonstrating how to get the radar altitude of the bottom corner of a vessel's or part's bounding box, useful for landing.

```APIDOC
## Quick Start 1 - Radar Altitude

### Description
This example shows how to retrieve the radar altitude of the lowest point of a vessel's or part's bounding box. This is particularly useful for determining the distance to the ground for landing gear.

### Method
GET (conceptually, accessing properties of the Bounds object)

### Endpoint
N/A

### Parameters
None

### Request Example
```kerboscript
// For the whole vessel:
local bounds_box is ship:bounds.
until terminal:input:haschar {
  clearscreen.
  print "PRESS ANY KEY TO QUIT".
  print "ALT:RADAR of ship bounding box's bottom corner is:".
  print round(bounds_box:BOTTOMALTRADAR, 1).
  wait 0.
}
terminal:input:getchar().

// For a specific landing leg part (assuming it's tagged "sensing leg"):
set leg_part to ship:partstagged("sensing leg")[0].
local bounds_box is leg_part:bounds.
// ... rest of the script is the same ...
```

### Response
- **BOTTOMALTRADAR** (Scalar) - The radar altitude of the bottom-most corner of the bounding box.
```

--------------------------------

### PIDLoop Initialization Examples

Source: https://ksp-kos.github.io/KOS/structures/misc/pidloop.html

Demonstrates various ways to instantiate a PIDLoop using default or custom parameters.

```kOS
// With zero parameters, the PIDLoop has default parameters:
// kp = 1, ki = 0, kd = 0
// maxoutput = maximum number value
// minoutput = minimum number value
SET PID TO PIDLOOP().

// Create a PIDLoop with a few stated paremeters:
SET PID TO PIDLOOP(2.5).
SET PID TO PIDLOOP(2.0, 0.05, 0.1).
SET PID TO PIDLOOP(2.0, 0.05, 0.1, -1, 1).
```

--------------------------------

### GUI Hello World with Callbacks

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui.rst.txt

Demonstrates creating a GUI window with a label and a button using the callback technique. The script waits for the button click event by setting an ONCLICK delegate.

```kOS
// "Hello World" program for kOS GUI.
//
// Create a GUI window
LOCAL my_gui IS GUI(200).
// Add widgets to the GUI
LOCAL label IS my_gui:ADDLABEL("Hello world!").
SET label:STYLE:ALIGN TO "CENTER".
SET label:STYLE:HSTRETCH TO True. // Fill horizontally
LOCAL ok TO my_gui:ADDBUTTON("OK").
// Show the GUI.
my_gui:SHOW().
// Handle GUI widget interactions.
//
// This is the technique known as "callbacks" - instead
// of actively looking again and again to see if a button was
// pressed, the script just tells kOS that it should call a
// delegate function when it notices the button has done
// something, and then the program passively waits for that
// to happen:
LOCAL isDone IS FALSE.
function myClickChecker {
  SET isDone TO TRUE.
}
SET ok:ONCLICK TO myClickChecker@. // This could also be an anonymous function instead.
wait until isDone.

print "OK pressed.  Now closing demo.".
// Hide when done (will also hide if power lost).
my_gui:HIDE().
```

--------------------------------

### GET /addons/trajectories/available

Source: https://ksp-kos.github.io/KOS/addons.html

Check if the Trajectories mod is installed and compatible.

```APIDOC
## ADDONS:TR:AVAILABLE

### Description
Returns a boolean indicating if a compatible version of the Trajectories mod is installed.

### Response
#### Success Response (200)
- **result** (boolean) - True if Trajectories is installed and compatible.
```

--------------------------------

### GET /addons/available

Source: https://ksp-kos.github.io/KOS/addons.html

Check if a specific mod is installed and available to the kOS environment.

```APIDOC
## ADDONS:AVAILABLE(modName)

### Description
Returns a boolean indicating if the specified mod is installed and available to kOS.

### Parameters
#### Path Parameters
- **modName** (string) - Required - The identifier for the mod (e.g., "AGX", "RT", "KAC", "IR").

### Response
#### Success Response (200)
- **result** (boolean) - True if the mod is available, False otherwise.
```

--------------------------------

### Create and Configure a Popup Menu

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/box.rst.txt

Demonstrates how to initialize a GUI, add a popup menu, and populate its selection options.

```kOS
set mygui to GUI(100).
// Make a popup menu that lets you choose one of 4 color names:
set mypopup mygui:addpopupmenu().
set mypopup:options to LIST("red", "green", "yellow", "white").

mygui:show().
wait 15. // let you play with it for 15 seconds.
mygui:dispose(). // ditch the gui before leaving this example.
```

--------------------------------

### Get GeoCoordinates from Ship Position

Source: https://ksp-kos.github.io/KOS/_sources/math/geocoordinates.rst.txt

Obtain a GeoCoordinates object representing the ship's current position on its body. This is a common way to get a starting GeoCoordinates object.

```kos
SET spot to SHIP:GEOPOSITION.
```

--------------------------------

### Create a Popup Menu

Source: https://ksp-kos.github.io/KOS/structures/gui_widgets/box.html

Example of initializing a GUI and adding a popup menu for user selection.

```kOS
set mygui to GUI(100).
// Make a popup menu that lets you choose one of 4 color names:
```

--------------------------------

### Initialize and Use a Queue

Source: https://ksp-kos.github.io/KOS/_sources/structures/collections/queue.rst.txt

Demonstrates initializing a new queue and adding/removing elements using PUSH and POP. Ensure the queue is initialized before use.

```kOS
SET Q TO QUEUE().
Q:PUSH("alice").
Q:PUSH("bob").

PRINT Q:POP. // will print 'alice'
PRINT Q:POP. // will print 'bob'
```

--------------------------------

### Orbit ETA Periapsis Example

Source: https://ksp-kos.github.io/KOS/structures/orbits/eta.html

This example shows how to get the time until periapsis. For hyperbolic orbits past periapsis, it returns a negative number indicating time since periapsis.

```kOS
print ETA:PERIAPSIS.

```

--------------------------------

### Get a Specific Voice

Source: https://ksp-kos.github.io/KOS/structures/misc/voice.html

Use GetVoice(num) to access a specific hardware voice from the SKID chip. Voice numbering starts at 0.

```kOS
GETVOICE(num)
```

--------------------------------

### Initialize the GUI and TabWidget

Source: https://ksp-kos.github.io/KOS/_sources/tutorials/gui.rst.txt

Create a top-level GUI and attach the TabWidget component.

```kOS
LOCAL my_gui IS GUI(500).
LOCAL tabwidget IS AddTabWidget(my_gui).
```

--------------------------------

### Initialize and Use a Stack

Source: https://ksp-kos.github.io/KOS/_sources/structures/collections/stack.rst.txt

Demonstrates initializing a stack, adding elements using PUSH, and removing elements using POP. Ensure the stack is initialized before use.

```kOS
SET S TO STACK().
S:PUSH("alice").
S:PUSH("bob").

PRINT S:POP. // will print 'bob'
PRINT S:POP. // will print 'alice'
```

--------------------------------

### Relative Path Examples

Source: https://ksp-kos.github.io/KOS/_sources/commands/files.rst.txt

Illustrates using simple, relative paths with kOS commands like RUN and CD.

```kOS
RUN script.
```

```kOS
CD(dir.ext)
```

--------------------------------

### Quick Start 2: Furthest Corner

Source: https://ksp-kos.github.io/KOS/structures/vessels/bounds.html

Example demonstrating the use of the `FURTHESTCORNER` suffix to find a specific corner of the bounding box relative to a given direction.

```APIDOC
## Quick Start 2 - Finding the Corner You Care About

### Description
Demonstrates the `FURTHESTCORNER(ray)` suffix, which returns a position vector representing the corner of the bounding box that is furthest in the direction specified by the `ray` vector.

### Method
GET (conceptually, accessing properties of the Bounds object)

### Endpoint
N/A

### Parameters
- **ray** (Vector) - Required - The direction vector to determine the furthest corner.

### Request Example
```kerboscript
set B to ship:BOUNDS.

// Get the bottom-most vertex of the ship's bounding box:
set bottom to B:FURTHESTCORNER( - up:vector ).

// Example: Find the corner furthest in the direction of the ship's forward vector:
set forward_corner to B:FURTHESTCORNER( ship:facing:vector ).
```

### Response
- **FURTHESTCORNER** (Vector) - The position of the furthest corner in the specified direction.
```

--------------------------------

### Initialize and Apply Directions

Source: https://ksp-kos.github.io/KOS/_sources/math/direction.rst.txt

Examples of creating directions using prograde, heading, and rotation constructors.

```kOS
// Initializes a direction to prograde
// plus a relative pitch of 90
SET X TO SHIP:PROGRADE + R(90,0,0).

// Steer the vessel in the direction
// suggested by direction X.
LOCK STEERING TO X.

// Create a rotation facing northeast,
// 10 degrees above horizon
SET Y TO HEADING(45, 10).

// Steer the vessel in the direction
// suggested by direction X.
LOCK STEERING TO Y.

// Set by a rotation in degrees
SET Direction TO R(0,90,0).
```

--------------------------------

### Show GUI Example

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/gui.rst.txt

Call this suffix to make the GUI appear. The GUI will not show up if this method is not called.

```kos
set g to gui(200).
// .. call G:addbutton, G:addslider, etc etc here
g:show().
```

--------------------------------

### Orbit ETA Transition Example

Source: https://ksp-kos.github.io/KOS/structures/orbits/eta.html

Get the time until the next orbit patch transition, ignoring intervening maneuver nodes. Returns a very large number if no future transition exists.

```kOS
print ETA:TRANSITION.

```

--------------------------------

### Vector Operations with Velocity and Position

Source: https://ksp-kos.github.io/KOS/_sources/math/vector.rst.txt

Provides examples of using vector operations to get a retro-surface velocity vector and to find the normal to the orbit plane using the cross product.

```KOS
// get vector pointing opposite to surface velocity.
SET retroSurf to (-1)*velocity:surface.

// use cross product to find normal to the orbit plane.
SET norm to VCRS(velocity:orbit, ship:body:position).
```

--------------------------------

### Basic Boot Script Example

Source: https://ksp-kos.github.io/KOS/_sources/general/boot.rst.txt

A simple script to be placed in the archive's boot directory. It waits for the ship to unpack before executing commands.

```kerboscript
// Place this file in your archive and call it "boot/myboot.ks".
wait until ship:unpacked.
clearscreen.
print "Hello. I am the boot file.".
print "If you see this, that proves the boot file ran."
```

--------------------------------

### List:SUBLIST(index,length) - Get Sublist

Source: https://ksp-kos.github.io/KOS/structures/collections/list.html

Returns a new list containing a specified range of elements from the original list. The range is defined by a starting index and a length.

```kOS
List:SUBLIST(index,length)
```

--------------------------------

### Create and Initialize Lists

Source: https://ksp-kos.github.io/KOS/_sources/structures/collections/list.rst.txt

Demonstrates creating new lists, both with initial elements and as empty lists. Elements can be numbers or variables.

```kos
SET BAR TO LIST(5,3,6).  // Creates a new list with 3 integers in it.
SET FOO TO LIST().       // Creates a new empty list in FOO variable
```

--------------------------------

### Calculate Signal Delay to a Vessel

Source: https://ksp-kos.github.io/KOS/_sources/addons/RemoteTech.rst.txt

This example demonstrates how to check the signal delay from Kerbal Space Center (KSC) to the current ship using the RemoteTech addon. It requires RemoteTech to be installed and the addon object to be accessed first.

```kOS Script
if addons:available("RT") {
  local myRT is addons:RT.
  print "The delay from KSC to Myself is:".
  print myRT:KSCDELAY(ship) + " seconds.".
}
```

--------------------------------

### Displaying a GUI Panel

Source: https://ksp-kos.github.io/KOS/structures/gui_widgets/widget.html

Demonstrates the standard pattern for initializing a GUI panel and making it visible to the user.

```kOS
set panel to GUI(200).

// <--- Add widgets to panel by calling things like panel:addbutton,
//      panel:addhslider, panel:addvslider, panel:addlabel, etc...

panel:show(). // or 'set panel:visible to true.' does the same thing.
```

--------------------------------

### Convert Scalar Universal Time to TimeStamp

Source: https://ksp-kos.github.io/KOS/_sources/structures/misc/time.rst.txt

Use the TIMESTAMP function to convert a scalar universal time (seconds since game start) into a TimeStamp structure. For example, TIME(3600) creates a TimeStamp for exactly 1 hour after the game began.

```kOS
SET my_timestamp TO TIMESTAMP(3600).
```

--------------------------------

### Set VecDraw startupdater to bounce arrow

Source: https://ksp-kos.github.io/KOS/_sources/structures/misc/vecdraw.rst.txt

This example demonstrates how to use the startupdater attribute to dynamically update the start position of a vector drawing. It uses a sine wave to create a bouncing effect over time. To stop the updates, set startupdater to DONOTHING.

```kOS
set vd to vecdraw(v(0,0,0), ship:north:vector*5, green, "bouncing arrow", 1.0, true, 0.2).
print "Moving the arrow up and down for a few seconds.".
set vd:startupdater to { return ship:up:vector*3*sin(time:seconds*180). }.
wait 5.
print "Stopping the arrow movement.".
set vd:startupdater to DONOTHING.
wait 3.
print "Removing the arrow.".
set vd to 0.
```

--------------------------------

### Creating a Window

Source: https://ksp-kos.github.io/KOS/structures/gui.html

Demonstrates how to create a new GUI window, add a button, show the window, wait for user interaction, and then hide it.

```APIDOC
## Creating a Window

### Description
This section explains how to create a new GUI window using the `GUI` function and add interactive elements to it.

### Method
`GUI(width [, height])`

### Parameters
- **width** (Integer) - The desired width of the GUI window. Set to 0 for automatic width resizing.
- **height** (Integer, Optional) - The desired height of the GUI window. If omitted, it resizes automatically to fit its contents.

### Request Example
```
SET my_gui TO GUI(200).
SET button TO my_gui:ADDBUTTON("OK").
my_gui:SHOW().
UNTIL button:TAKEPRESS WAIT(0.1).
my_gui:HIDE().
```

### Notes
- Automatic resizing for both width and height (setting both to 0) may lead to undesirable layouts. It's often better to specify one dimension and allow the other to resize automatically.
- Refer to the `BOX` structure for available widgets to add to the GUI.
```

--------------------------------

### Example: Adding Spaced Widgets in KOS GUI

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/box.rst.txt

Demonstrates creating a GUI with labels and buttons, using horizontal layout boxes and spacing to indent elements. The GUI is shown for 15 seconds before being disposed.

```KOS
set mygui to GUI(400).
set mytitle to mygui:addlabel("This is my Panel").
set box1 to mygui:ADDHLAYOUT().
box1:addspacing(50). // 50 pixels indent inside horizontal box 1
set button1 to box1:addbutton("indented").
set box2 to mygui:ADDHLAYOUT().
box2:addspacing(100). // 100 pixels indent inside horizontal box 2
set button2 to box2:addbutton("indented more").
myGui:show().
print "Play with buttons for 15 seconds.".
wait 15. 
myGui:dispose(). // get rid of the GUI before quitting the program.
```

--------------------------------

### Create and Use TipDisplay in kOS GUI

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/tipdisplay.rst.txt

This example demonstrates how to create a GUI window with buttons that have tooltips. The tooltips appear in the TipDisplay widget at the bottom of the window when hovering over the buttons. Ensure the GUI is shown and disposed properly.

```kOS Script
local done is false.
local g is gui(200).
local tiptext is g:addtipdisplay().

local buttonsBox is g:addhbox().

local b1 is buttonsBox:addbutton("low").
set b1:tooltip to "Makes low pitch note.".
set b1:onclick to {getvoice(0):play(note(200,0.5)).}.

local b2 is buttonsBox:addbutton("medium").
set b2:tooltip to "Makes medium pitch note.".
set b2:onclick to {getvoice(0):play(note(300,0.5)).}.

local b3 is buttonsBox:addbutton("high").
set b3:tooltip to "Makes high pitch note.".
set b3:onclick to {getvoice(0):play(note(400,0.5)).}.

local bClose is g:addbutton("Close").
set bClose:tooltip to "Ends program.".
set bClose:onclick to {set done to true.}.

g:show().
wait until done.
g:dispose().
```

--------------------------------

### Iterator Output Example

Source: https://ksp-kos.github.io/KOS/_sources/structures/collections/iterator.rst.txt

This is the expected output when running the iterator loop example.

```text
before the first NEXT, position = -1.
Item at position 0 is [Hello].
Item at position 1 is [Aloha].
Item at position 2 is [Bonjour].
```

--------------------------------

### Compile and deploy KSM files

Source: https://ksp-kos.github.io/KOS/_sources/general/compiling.rst.txt

Example of compiling scripts into KSM format and copying them to a local volume for execution.

```KerboScript
SWITCH TO ARCHIVE.

COMPILE "myprog1.ks" to "myprog1.ksm".
COPYPATH( "0:/myprog1.ksm", "1:/" ).

COMPILE "myprog2". // If you leave the arguments off, it assumes you are going from .ks to .ksm
COPYPATH( "0:/myprog2.ksm", "1:/" ).
```

--------------------------------

### Telnet Welcome Menu Display

Source: https://ksp-kos.github.io/KOS/general/telnet.html

Example output of the telnet welcome menu when CPUs are available for connection.

```text
Terminal: type = XTERM, size = 80x24
________________________________________________________________________________
              Menu GUI   Other
              Pick Open Telnets  Vessel Name (CPU tagname)
              ---- ---- -------  --------------------------------
               [1]   no    0     Randy Viewer (CX-4181())
               [2]   no    0     Randy Viewer (CX-4181())
               [3]   no    0     Randy Viewer (CX-4181())
               [4]   no    0     Randy Viewer (CX-4181())
               [5]   no    0     Randy Viewer (CX-4181())
               [6]   no    0     Randy Viewer (CX-4181())
--------------------------------------------------------------------------------
Choose a CPU to attach to by typing a selection number and pressing
return/enter. Or enter [Q] to quit terminal server.

(After attaching, you can (D)etach and return to this menu by pressing Control-D
as the first character on a new command line.)
--------------------------------------------------------------------------------
>_
```

--------------------------------

### kOS Path Examples

Source: https://ksp-kos.github.io/KOS/_sources/commands/files.rst.txt

Demonstrates various ways to specify file paths in kOS, including bareword and expression-based paths.

```kOS
COPYPATH(myfilename, "1:").
```

```kOS
COPYPATH("myfilename", "1:").
```

```kOS
COPYPATH(myfilename.ks, "1:").
```

```kOS
COPYPATH(myfilename.txt, "1:").
```

```kOS
COPYPATH("myfilename.ks", "1:").
```

```kOS
SET str TO "myfile" + "name" + ".ks".
COPYPATH(str, "1:").
```

```kOS
COPYPATH("myfile" + "name" + ".ks", "1:").
```

--------------------------------

### GUI Hello World with Polling

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui.rst.txt

Demonstrates creating a GUI window with a label and a button using the polling technique. The script continuously checks the button's state within a loop until it is pressed.

```kOS
// "Hello World" program for kOS GUI.
//
// Create a GUI window
LOCAL my_gui IS GUI(200).
// Add widgets to the GUI
LOCAL label IS my_gui:ADDLABEL("Hello world!").
SET label:STYLE:ALIGN TO "CENTER".
SET label:STYLE:HSTRETCH TO True. // Fill horizontally
LOCAL ok TO my_gui:ADDBUTTON("OK").
// Show the GUI.
my_gui:SHOW().
// Handle GUI widget interactions.
//
// This is the technique known as "polling" - In a loop you
// continually check to see if something has happened:
LOCAL isDone IS FALSE.
UNTIL isDone
{
  if (ok:TAKEPRESS)
    SET isDone TO TRUE.
  WAIT 0.1. // No need to waste CPU time checking too often.
}
print "OK pressed.  Now closing demo.".
// Hide when done (will also hide if power lost).
my_gui:HIDE().
```

--------------------------------

### Define and Call a Basic Function

Source: https://ksp-kos.github.io/KOS/language/user_functions.html

Demonstrates how to define a simple function and then call it. Ensure functions are called with parentheses.

```kOS
function example_function {
  print "hello, this is my example.".
}

example_function().

```

--------------------------------

### Checking Infernal Robotics Installation

Source: https://ksp-kos.github.io/KOS/_sources/addons/IR.rst.txt

This snippet shows how to check if the Infernal Robotics mod is installed and available for use with kOS.

```APIDOC
## Checking Infernal Robotics Installation

### Description
Checks if the Infernal Robotics mod is installed and available for use with kOS.

### Method
Attribute Access

### Endpoint
N/A

### Parameters
None

### Request Example
```kos
if ADDONS:AVAILABLE("IR") {
    Print "Infernal Robotics is installed."
}
```

### Response
#### Success Response (Boolean)
- **True**: If Infernal Robotics is installed and available.
- **False**: If Infernal Robotics is not installed or not available.

#### Response Example
```kos
if ADDONS:IR:AVAILABLE
{
    //some IR dependent code
}
```
```

--------------------------------

### GUI Creation and Manipulation

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui.rst.txt

Demonstrates how to create a new GUI object, add a button, show the GUI, wait for a button press, and then hide it.

```APIDOC
## GUI Creation and Manipulation

### Description
Creates a new GUI object that can be manipulated to build a user interface. The GUI can automatically resize to fit its contents or have its dimensions set.

### Method
N/A (This is a function call, not an HTTP request)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```
SET my_gui TO GUI(200).
SET button TO my_gui:ADDBUTTON("OK").
my_gui:SHOW().
UNTIL button:TAKEPRESS WAIT(0.1).
my_gui:HIDE().
```

### Response
#### Success Response (200)
N/A (This is a function call, not an HTTP request)

#### Response Example
N/A
```

--------------------------------

### Extended @LAZYGLOBAL Usage Example

Source: https://ksp-kos.github.io/KOS/_sources/language/variables.rst.txt

A comprehensive example showing how @LAZYGLOBAL OFF prevents typos from creating new implicit global variables.

```kerboscript
@LAZYGLOBAL off.
global num TO 1.
IF TRUE {
  LOCAL Y IS 2.
  SET num TO num + Y. // This is fine.  num exists already as a global and
                      // you're adding the local Y to it.
  SET nim TO 20. // This typo generates an error.  There is
                 // no such variable "nim" and @LAZYGLOBAL OFF
```

--------------------------------

### Create and display a popup menu

Source: https://ksp-kos.github.io/KOS/structures/gui_widgets/box.html

Initializes a popup menu with options, displays the GUI, and disposes of it after a delay.

```kOS
set mypopup mygui:addpopupmenu().
set mypopup:options to LIST("red", "green", "yellow", "white").

mygui:show().
wait 15. // let you play with it for 15 seconds.
mygui:dispose(). // ditch the gui before leaving this example.
```

--------------------------------

### Example of a Clobbering Error

Source: https://ksp-kos.github.io/KOS/_sources/language/variables.rst.txt

This is an example of the error message generated when a script attempts to define a variable that conflicts with a built-in kOS name.

```text
set altitude to 10.
                ^
Not allowed to SET a name that will clobber or hide the variable called 'ALTITUDE'.
See kOS documentation for CLOBBERBUILTINS for more information.
```

--------------------------------

### Implementing GUI button callbacks

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/button.rst.txt

A comprehensive example demonstrating both named and anonymous callback functions for standard and toggle buttons.

```kOS
LOCAL doneYet is FALSE.
LOCAL g IS GUI(200).

// b1 is a normal button that auto-releases itself:
// Note that the callback hook, myButtonDetector, is
// a named function found elsewhere in this same program:
LOCAL b1 IS g:ADDBUTTON("button 1").
SET b1:ONCLICK TO myButtonDetector@.

// b2 is also a normal button that auto-releases itself,
// but this time we'll use an anonymous callback hook for it:
LOCAL b2 IS g:ADDBUTTON("button 2").
SET b2:ONCLICK TO { print "Button Two got pressed". }

// b3 is a toggle button.
// We'll use it to demonstrate how ONTOGGLE callback hooks look:
LOCAL b3 IS g:ADDBUTTON("button 3 (toggles)").
set b3:style to g:skin:button.
SET b3:TOGGLE TO TRUE.
SET b3:ONTOGGLE TO myToggleDetector@.

// b4 is the exit button.  For this we'll use another
// anonymous function that just sets a boolean variable
// to signal the end of the program:
LOCAL b4 IS g:ADDBUTTON("EXIT DEMO").
SET b4:ONCLICK TO { set doneYet to true. }

g:show(). // Start showing the window.

wait until doneYet. // program will stay here until exit clicked.

g:hide(). // Finish the demo and close the window.

//END.

function myButtonDetector {
  print "Button One got clicked.".
}
function myToggleDetector {
  parameter newState.
  print "Button Three has just become " + newState.
}
```

--------------------------------

### Example kOS Boot Script

Source: https://ksp-kos.github.io/KOS/general/boot.html

Place this script in the archive's 'boot/' directory. It will execute upon vessel launch after being selected as a boot file.

```kerboscript
// Place this file in your archive and call it "boot/myboot.ks".
wait until ship:unpacked.
clearscreen.
print "Hello. I am the boot file.".
print "If you see this, that proves the boot file ran.".

```

--------------------------------

### Get Current Timestamp

Source: https://ksp-kos.github.io/KOS/_sources/structures/misc/time.rst.txt

Call TIMESTAMP() without arguments to get the current game time. This is equivalent to the global TIME variable.

```kerboscript
TIMESTAMP()
```

--------------------------------

### Set and Get Terminal Height

Source: https://ksp-kos.github.io/KOS/_sources/commands/terminalgui.rst.txt

Gets or sets the terminal's height in characters. Refer to the terminal struct documentation for more details.

```kOS
SET TERMINAL:HEIGHT TO 25.
```

```kOS
PRINT TERMINAL:HEIGHT.
```

--------------------------------

### List Creation and Basic Operations

Source: https://ksp-kos.github.io/KOS/_sources/structures/collections/list.rst.txt

Demonstrates how to create lists, add elements, and retrieve basic information like length.

```APIDOC
## List Creation and Basic Operations

### Description
This section covers the creation of new lists, adding elements to them, and retrieving the current number of elements.

### Examples

```kos
SET BAR TO LIST(5,3,6).
SET FOO TO LIST().
FOO:ADD(5).
FOO:ADD( ALTITUDE ).
FOO:ADD(ETA:APOAPSIS).
PRINT FOO:LENGTH.
PRINT FOO:LENGTH().
```

### Response

- **BAR**: A list containing integers [5, 3, 6].
- **FOO**: A list containing [5, current_altitude, eta_to_apoapsis].
- **Output of PRINT FOO:LENGTH / FOO:LENGTH()**: The number of elements in FOO (e.g., 3).
```

--------------------------------

### Set and Get Terminal Width

Source: https://ksp-kos.github.io/KOS/_sources/commands/terminalgui.rst.txt

Gets or sets the terminal's width in characters. Refer to the terminal struct documentation for more details.

```kOS
SET TERMINAL:WIDTH TO 80.
```

```kOS
PRINT TERMINAL:WIDTH.
```

--------------------------------

### Declare Global Variable Examples

Source: https://ksp-kos.github.io/KOS/language/variables.html

Use these examples to declare variables that are accessible from anywhere in the program. The 'DECLARE' keyword is optional when 'GLOBAL' is used.

```kerboscript
DECLARE GLOBAL X TO 1.
GLOBAL X TO 1. // 'declare' is implied and optional when scoping words are used
GLOBAL X IS 1. // 'declare' is implied and optional when scoping words are used
```

--------------------------------

### Declare Local Variable Examples

Source: https://ksp-kos.github.io/KOS/language/variables.html

Use these examples to declare variables that are local to the current scope. The 'DECLARE' keyword is optional when 'LOCAL' is used.

```kerboscript
DECLARE X IS 1.
DECLARE X TO 1.
DECLARE LOCAL X IS 1.
DECLARE LOCAL X TO 1.
LOCAL X IS 1. // 'declare' is implied and optional when scoping words are used
LOCAL X TO 1. // 'declare' is implied and optional when scoping words are used
```

--------------------------------

### GUI Object and Initialization

Source: https://ksp-kos.github.io/KOS/_sources/structures/gui_widgets/gui.rst.txt

Information on creating and managing GUI objects.

```APIDOC
## GUI Object

### Description
A GUI object is the outermost window that holds all other widgets. All widgets must be placed inside a GUI object or a Box within a GUI object.

### Initialization

```
GUI(width, height)
```

### Built-in Functions

- **CLEARGUIS**
  - Description: Removes all created GUIs. It's a shorthand for calling `HIDE` and `DISPOSE` on each GUI widget.

### Widget Management

Widgets can be added to the GUI using the suffixes available for the `BOX` struct. See the `BOX` suffixes for details.
```

--------------------------------

### Copy a File using FileContent

Source: https://ksp-kos.github.io/KOS/structures/volumes_and_files/filecontent.html

Demonstrates how to copy a file by reading its entire content into a FileContent object and then writing it to a new file. Requires opening the source file and creating the destination file.

```kos
SET CONTENTS TO OPEN("filename"):READALL.
SET NEWFILE TO CREATE("newfile").
NEWFILE:WRITE(CONTENTS).

```

--------------------------------

### VecDraw:START Attribute

Source: https://ksp-kos.github.io/KOS/_sources/structures/misc/vecdraw.rst.txt

Defines the starting position of the vector. Defaults to V(0,0,0) in SHIP-RAW coordinates, representing the ship's Center of Mass.

```APIDOC
## VecDraw:START

*   **Access**: Get/Set
*   **Type**: :struct:`Vector`

Optional, defaults to V(0,0,0) - position of the tail of the vector to draw in SHIP-RAW coords. V(0,0,0) means the ship Center of Mass.
```

--------------------------------

### Query and store system information

Source: https://ksp-kos.github.io/KOS/_sources/commands/list.rst.txt

Examples of listing files and volumes, including storing results into variables.

```kOS
LIST.  // Prints the list of files (and subdirectories) on current volume.
LIST FILES.  // Does the same exact thing, but more explicitly.
LIST VOLUMES. // which volumes can be seen by this CPU?
LIST FILES IN fileList. // fileList is now a LIST() containing :struct:`VolumeItem` structures.
```

--------------------------------

### Check if Trajectories mod is installed

Source: https://ksp-kos.github.io/KOS/_sources/addons.rst.txt

Returns True if a compatible version of the Trajectories mod is installed. Use this to enable or disable features that rely on trajectory prediction.

```kOS
ADDONS:TR:AVAILABLE
```

--------------------------------

### Get Body by Name in kOS

Source: https://ksp-kos.github.io/KOS/_sources/structures/celestial_bodies/body.rst.txt

Use the BODY() function to get a variable referring to a celestial body by its name. This is useful for accessing a body's properties.

```kOS
SET MY_VAR TO BODY("name").
```

--------------------------------

### RUN Keyword Syntax and Usage

Source: https://ksp-kos.github.io/KOS/commands/runprogram.html

Explains the basic syntax of the RUN keyword, its optional ONCE parameter, and how to specify the script path and arguments. It also provides examples of valid and invalid usage.

```APIDOC
## RUN Keyword

### Description
Executes a script file. This is an older command and RUNPATH is generally preferred.

### Method
RUN [ONCE] path [(commaSeperatedArgs...)]

### Endpoint
N/A (This is a keyword within the kOS scripting language)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **once** (`keyword`) - Optional. If present, the script will only run if it hasn't been run before in the current program context.
* **path** (`String` or bare word literal) - The path to the script file. Can be an absolute or relative path. Must be a literal string or bare word.
* **commaSeperatedArgs...** (`Optional`) - A comma-separated list of arguments to pass to the script, enclosed in parentheses.

### Request Example
```kosh
RUN "myfile.ks".
RUN myfile.ks.
RUN myfile(1,2,3).
RUN "myfile.ks"(1,2,3).
RUN ONCE "init.ksm".
```

### Response
#### Success Response (200)
N/A (Execution is within the kOS environment)

#### Response Example
N/A
```

--------------------------------

### Wait for Burn Start

Source: https://ksp-kos.github.io/KOS/_sources/tutorials/exenode.rst.txt

Waits until the vessel is within half of the calculated burn duration of the maneuver node's ETA, indicating readiness to start the burn.

```kOS
wait until nd:eta <= (burn_duration/2).
```
Tokens:
Raw