Lua API Reference

Globals

field `COBSCALE`

is integer
[source]

table `Encoding`

Lua Encoding API

[source]

fn `DecodeBase64 (text) -> decoded`

fn `DecodeBase64Url (text) -> decoded`

field `versionMajor`

is string
Major part of the named release version

field `versionMinor`

is string
Minor part of the named release version

field `versionPatchSet`

is string
Build number of the named release version

field `commitsNumber`

is string
Number of commits after the latest named release, non-zero indicates a “dev” build

field `buildFlags`

is string
Gets additional engine buildflags, e.g. “Debug” or “Sync-Debug”

field `featureSupport`

is FeatureSupport
Table containing various engine features as keys; use for cross-version compat

field `wordSize`

is number
Indicates the build type always 64 these days

field `gameSpeed`

is number
Number of simulation gameframes per second

field `textColorCodes`

is TextColorCode
Table containing keys that represent the color code operations during font rendering

table `Game`

field `repairEnergyCostFactor`

is number

field `resurrectEnergyCostFactor`

is number

field `captureEnergyCostFactor`

is number

field `springCategories`

is table<string,integer>

    example: {
      ["vtol"]         = 0,  ["special"]      = 1,  ["noweapon"]     = 2,
      ["notair"]       = 3,  ["notsub"]       = 4,  ["all"]          = 5,
      ["weapon"]       = 6,  ["notship"]      = 7,  ["notland"]      = 8,
      ["mobile"]       = 9,  ["kbot"]         = 10, ["antigator"]    = 11,
      ["tank"]         = 12, ["plant"]        = 13, ["ship"]         = 14,
      ["antiemg"]      = 15, ["antilaser"]    = 16, ["antiflame"]    = 17,
      ["underwater"]   = 18, ["hover"]        = 19, ["phib"]         = 20,
      ["constr"]       = 21, ["strategic"]    = 22, ["commander"]    = 23,
      ["paral"]        = 24, ["jam"]          = 25, ["mine"]         = 26,
      ["kamikaze"]     = 27, ["minelayer"]    = 28, ["notstructure"] = 29,
      ["air"]          = 30
    }

field `armorTypes`

is table<(string|integer),(integer|string)>

(bidirectional)

    example: {
      [1]  = amphibious,   [2] = anniddm,     [3] = antibomber,
      [4]  = antifighter,  [5] = antiraider,  [6] = atl,
      [7]  = blackhydra,   [8] = bombers,     [9] = commanders,
      [10] = crawlingbombs, ...

      ["amphibious"]   = 1, ["anniddm"]    = 2, ["antibomber"] = 3
      ["antifighter"]  = 4, ["antiraider"] = 5, ["atl"]        = 6
      ["blackhydra"]   = 7, ["bombers"]    = 8, ["commanders"] = 9
      ["crawlingbombs"]= 10, ...
    }

field `textColorCodes`

is TextColorCode
Table containing keys that represent the color code operations during font rendering

table `gl`

Callouts for OpenGL API

Only setters and getters for OpenGL usage in Recoil, see GL for constants.

[source]

See: GL

fn `AddFallbackFont (filePath) -> success`

Adds a fallback font for the font rendering engine.

Fonts added first will have higher priority. When a glyph isn’t found when rendering a font, the fallback fonts will be searched first, otherwise os fonts will be used.

The application should listen for the unsynced ‘FontsChanged’ callin so modules can clear any already reserved display lists or other relevant caches.

Note the callin won’t be executed at the time of calling this method, but later, on the Update cycle (before other Update and Draw callins).

This doesn’t delete the attached objects!

Params

fbo: nil
target: GL? --(Default: `GL_FRAMEBUFFER_EXT`)
rawFboId: integer? --(Default: `0`)

Returns

: nil

fn `RawBindFBO (fbo, target) -> previouslyBoundRawFboId`

[source]

success: boolean

fn `HasExtension (ext) ->`

[source]

Params

ext: string

Returns

: boolean

fn `GetNumber (pname, count) ->`

Get the value or values of a selected parameter.

[source]

Params

pname: GL
count: integer? --(Default: `1`) Number of values to return, in range [1, 64].

Returns

: number …

fn `GetString (pname)`

options: string? --concatenated string of option characters.
- horizontal alignment:
- 'c' = center
- 'r' = right
- vertical alignment:
- 'a' = ascender
- 't' = top
- 'v' = vertical center
- 'x' = baseline
- 'b' = bottom
- 'd' = descender
- decorations:
- 'o' = black outline
- 'O' = white outline
- 's' = shadow
- other:
- 'n' = don't round vertex coords to nearest integer (font may get blurry)

Returns

: nil

fn `GetTextWidth (text) -> width`

[source]

Params

text: string

Returns

width: number

fn `GetTextHeight (text) -> height, descender, lines`

[source]

Params

text: string

Returns

height: number
descender: number
lines: integer

fn `Unit (unitID, doRawDraw, useLuaMat, noLuaCall, fullModel)`

[source]

Params

enable: boolean

fn `Culling (enable)`

[source]

Params

enable: boolean

fn `Culling (mode)`

Enable culling and set culling mode.

[source]

Params

mode: GL

fn `LogicOp (enable)`

[source]

Params

enable: boolean

fn `LogicOp (opCode)`

Specify a logical pixel operation for rendering.

[source]

Params

fn `AlphaTest (func, ref)`

Specify the alpha test function.

[source]

Params

func: GL
ref: number

fn `AlphaToCoverage (enable)`

[source]

Params

enable: boolean

fn `PolygonMode (face, mode)`

Select polygon rasterization mode.

Control the front and back writing of individual bits in the stencil planes.

[source]

Params

mask: integer --Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all `1`'s.

fn `StencilFunc (func, ref, mask)`

Set front and back function and reference value for stencil testing.

[source]

Params

func: GL --Specifies the test function. Eight symbolic constants are valid: `GL.NEVER`, `GL.LESS`, `GL.EQUAL`, `GL.LEQUAL`, `GL.GREATER`, `GL.NOTEQUAL`, `GL.GEQUAL`, and `GL.ALWAYS`. The initial value is `GL.ALWAYS`.

ref: integer --Specifies the reference value for the stencil test. `ref` is clamped to the range `[0, 2^n - 1]`, where `n` is the number of bitplanes in the stencil buffer. The initial value is `0`.

mask: integer --Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all `1`'s.

fn `StencilOp (fail, zfail, zpass)`

Set front and back stencil test actions.

[source]

Params

fail: GL --Specifies the action to take when the stencil test fails. Eight symbolic constants are valid: `GL.KEEP`, `GL.ZERO`, `GL.REPLACE`, `GL.INCR`, `GL.INCR_WRAP`, `GL.DECR`, `GL.DECR_WRAP`, and `GL.INVERT`. The initial value is `GL.KEEP`.

zfail: GL --Specifies the stencil action when the stencil test passes, but the depth test fails. The initial value is `GL.KEEP`.

zpass: GL --Specifies the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. The initial value is `GL.KEEP`.

fn `StencilMaskSeparate (face, mask)`

Control the front and back writing of individual bits in the stencil planes.

[source]

Params

face: GL --Specifies whether the front and/or back stencil writemask is updated. Three symbolic constants are accepted: `GL.FRONT`, `GL.BACK`, and `GL.FRONT_AND_BACK`. The initial value is `GL.FRONT_AND_BACK`.

mask: integer --Specifies a bit mask to enable and disable writing of individual bits in the stencil planes. Initially, the mask is all `1`'s.

fn `StencilFuncSeparate (face, func, ref, mask)`

Set front and/or back function and reference value for stencil testing.

[source]

Params

face: GL --Specifies whether front and/or back stencil state is updated. Three symbolic constants are accepted: `GL.FRONT`, `GL.BACK`, and `GL.FRONT_AND_BACK`. The initial value is `GL.FRONT_AND_BACK`.

func: GL --Specifies the test function. Eight symbolic constants are valid: `GL.NEVER`, `GL.LESS`, `GL.EQUAL`, `GL.LEQUAL`, `GL.GREATER`, `GL.NOTEQUAL`, `GL.GEQUAL`, and `GL.ALWAYS`. The initial value is `GL.ALWAYS`.

ref: integer --Specifies the reference value for the stencil test. `ref` is clamped to the range `[0, 2^n - 1]`, where `n` is the number of bitplanes in the stencil buffer. The initial value is `0`.

mask: integer --Specifies a mask that is ANDed with both the reference value and the stored stencil value when the test is done. The initial value is all `1`'s.

fn `StencilOpSeparate (face, fail, zfail, zpass)`

Set front and/or back stencil test actions.

[source]

Params

face: GL --Specifies whether front and/or back stencil state is updated. Three symbolic constants are accepted: `GL.FRONT`, `GL.BACK`, and `GL.FRONT_AND_BACK`. The initial value is `GL.FRONT_AND_BACK`.

fail: GL --Specifies the action to take when the stencil test fails. Eight symbolic constants are valid: `GL.KEEP`, `GL.ZERO`, `GL.REPLACE`, `GL.INCR`, `GL.INCR_WRAP`, `GL.DECR`, `GL.DECR_WRAP`, and `GL.INVERT`. The initial value is `GL.KEEP`.

zfail: GL --Specifies the stencil action when the stencil test passes, but the depth test fails. The initial value is `GL.KEEP`.

zpass: GL --Specifies the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled. The initial value is `GL.KEEP`.

For format parameters refer to https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBindImageTexture.xhtml and https://beyond-all-reason.github.io/RecoilEngine/lua-api/types/GL#rgba32f

Example uses local my_texture_id = gl.CreateTexture(…)

– bind layer 1 of my_texture_id if it supports layered bindings to image unit 0 gl.BindImageTexture(0, my_texture_id, 0, 1, GL.READ_WRITE, GL.RGBA16F)

– bind all layers of my_texture_id if it supports layered bindings to image unit 0 gl.BindImageTexture(0, my_texture_id, 0, nil, GL.READ_WRITE, GL.RGBA16F)

– unbind any texture attached to image unit 0 gl.BindImageTexture(0, nil, nil, nil, nil, GL.RGBA16F)

Params

unit: integer
texID: string? --(nil breaks any existing binding to the image unit)
level: integer? --(Default: 0)

layer: integer? --(nil binds the entire texture(array/cube), an integer binds a specific layer, ignored by gl if the texture does not support layered bindings)

fn `GetMatrixData (type, index) -> The`

Params

Returns

: any …

fn `GetSun () -> lightDirX, lightDirY, lightDirZ`

[source]

Returns

lightDirX: number
lightDirY: number
lightDirZ: number

fn `GetSun (param, mode) -> data1, data2, data3`

[source]

Params

Returns

data1: number?
data2: number?
data3: number?

fn `GetWaterRendering (key) -> value`

[source]

Params

key: string

Returns

value: any …

fn `GetMapRendering (key) -> value`

[source]

Params

key: string

Returns

value: any …

fn `ObjectLabel (objectTypeIdentifier, objectID, label)`

Labels an object for use with debugging tools. May be unavailable and nil if the platform doesn’t support the feature.

[source]

Params

objectTypeIdentifier: GL --Specifies the type of object being labeled.
objectID: integer --Specifies the name or ID of the object to label.
label: string --A string containing the label to be assigned to the object.

fn `PushDebugGroup (id, message, sourceIsThirdParty) ->`

Pushes a debug marker for debugging tools such as nVidia nSight 2024.04, see https://registry.khronos.org/OpenGL-Refpages/gl4/html/glPushDebugGroup.xhtml .

May be unavailable and nil if the platform doesn’t support the feature.

Groups are basically named scopes similar to tracy’s, and are pushed/popped independently from GL attribute/matrix push/pop (though of course makes sense to put them together).

Tools are known to struggle to see the annotation for FBOs if they are raw bound.

[source]

Params

id: integer --A numeric identifier for the group, can be any unique number.

message: string --A human-readable string describing the debug group. Will be truncated if longer than driver-specific limit

sourceIsThirdParty: boolean --Set the source tag, true for GL_DEBUG_SOURCE_THIRD_PARTY, false for GL_DEBUG_SOURCE_APPLICATION. default false

Deletes a shader identified by shaderID

[source]

Params

shaderID: integer

fn `UseShader (shaderID) -> linked`

Binds a shader program identified by shaderID. Pass 0 to disable the shader. Returns whether the shader was successfully bound.

[source]

Params

shaderID: integer

Returns

linked: boolean

fn `ActiveShader (shaderID, func, ...)`

local myVBO = gl.GetVBO()
if myVBO == nil then Spring.Echo("Failed to get VBO") end

[source]

See: GL.OpenGL_Buffer_Types

Params

bufferType: GL? --(Default: `GL.ARRAY_BUFFER`) The buffer type to use.
Accepts the following:
- `GL.ARRAY_BUFFER` for vertex data.
- `GL.ELEMENT_ARRAY_BUFFER` for vertex indices.
- `GL.UNIFORM_BUFFER`
- `GL.SHADER_STORAGE_BUFFER`

freqUpdated: boolean? --(Default: `true`)
`true` to updated frequently, `false` to update only once.

Returns

VBO: VBO?

table `Platform`

table `RmlUi`

Global functions for Recoil’s RmlUi implementation.

[source]

field `Context`

is RmlUi.Context

field `ElementText`

is RmlUi.ElementText

field `ElementTabSet`

is RmlUi.ElementTabSet

field `ElementProgress`

is RmlUi.ElementProgress

field `EventListener`

is RmlUi.EventListener

field `Element`

is RmlUi.Element

field `ElementPtr`

is RmlUi.ElementPtr

fn `CreateContext (name) -> nil`

Create a new context.

[source]

success: boolean

fn `GetContext (name) -> nil`

Get a context by name.

[source]

Params

name: string

Returns

nil: RmlUi.Context? --if failed.

fn `RegiserEventType (event_type, interruptible, bubbles, default_phase) ->`

[source]

Params

event_type: string
interruptible: boolean?
bubbles: boolean?
default_phase: RmlUi.default_action_phase?

Returns

: RmlUi.EventID

fn `AddTranslationString (key, translation) -> success`

Add a translation string.

[source]

Params

key: string
translation: string

Returns

success: boolean

fn `ClearTranslations ()`

Clear registered translations.

[source]

fn `SetMouseCursorAlias (rml_name, recoil_name)`

Converts the css names for cursors to the Recoil Engine names for cursors like RmlUi.SetMouseCursorAlias("pointer", 'Move'). Web devs tend to want to use specific words for pointer types.

[source]

Params

rml_name: string --name used in rml script
recoil_name: string --name used in recoil

fn `SetDebugContext (context)`

Set which context the debug inspector is meant to inspect.

[source]

Params

context: (string|RmlUi.Context)

field `contexts`

is RmlUi.Context[]
[source]

field `version`

is string
[source] RmlUi version

field `key_identifier`

is RmlUi.key_identifier

field `key_modifier`

is RmlUi.key_modifier

field `font_weight`

is RmlUi.font_weight

field `default_action_phase`

is RmlUi.default_action_phase

field `RmlEventPhase`

is RmlUi.RmlEventPhase

field `EventParametersProxy`

is RmlUi.EventParametersProxy

field `Event`

is RmlUi.Event

field `RmlModalFlag`

is RmlUi.RmlModalFlag

field `RmlFocusFlag`

is RmlUi.RmlFocusFlag

field `Document`

is RmlUi.Document

field `Vector2i`

is RmlUi.Vector2i

field `Vector2f`

is RmlUi.Vector2f
See: float2

field `ElementForm`

is RmlUi.ElementForm

field `ElementFormControl`

is RmlUi.ElementFormControl

field `ElementFormControlInput`

is RmlUi.ElementFormControlInput

field `ElementFormControlSelect`

is RmlUi.ElementFormControlSelect

field `ElementFormControlTextArea`

is RmlUi.ElementFormControlTextArea

field `SolLuaDataModel`

is RmlUi.SolLuaDataModel

fn `GetWatchFeature (featureDefID) -> watched`

Query whether any callins are registered for a featureDefID.

[source]

See: Script.SetWatchFeature

Params

featureDefID: integer

Returns

watched: boolean --`true` if callins are registered, otherwise `false`.

fn `GetWatchWeapon (weaponDefID) -> watched`

Query whether any callins are registered for a weaponDefID.

[source]

Same as calling:

Script.GetWatchExplosion(weaponDefID) or Script.GetWatchProjectile(weaponDefID) or Script.GetWatchAllowTarget(weaponDefID)

[source]

See: Script.GetWatchUnit Callins:UnitFeatureCollision Callins:UnitUnitCollision Callins:UnitMoveFailed

Params

unitDefID: integer
watch: boolean --Whether to register or deregister.

fn `SetWatchFeature (featureDefID, watch)`

[source]

See: Script.GetWatchFeature Callins:UnitFeatureCollision

Params

featureDefID: integer
watch: boolean --Whether to register or deregister.

fn `SetWatchWeapon (weaponDefID, watch)`

[source]

Equivalent to calling:

Script.SetWatchExplosion(weaponDefID)
Script.SetWatchProjectile(weaponDefID)
Script.SetWatchAllowTarget(weaponDefID)

[source]

Returns

: integer

fn `GetTimerMicros () ->`

screenSizeX: number --in px
screenSizeY: number --in px
screenPosX: number --in px
screenPosY: number --in px
windowBorderTop: number --in px
windowBorderLeft: number --in px
windowBorderBottom: number --in px
windowBorderRight: number --in px
screenUsableSizeX: number? --in px
screenUsableSizeY: number? --in px
screenUsablePosX: number? --in px
screenUsablePosY: number? --in px

fn `GetMiniMapGeometry () -> minimapPosX, minimapPosY, minimapSizeX, minimapSizeY, minimized, maximized`

Get minimap geometry

[source]

Returns

minimapPosX: number --in px
minimapPosY: number --in px
minimapSizeX: number --in px
minimapSizeY: number --in px
minimized: boolean
maximized: boolean

fn `GetMiniMapRotation () -> amount`

Get minimap rotation

[source]

Returns

amount: number --in radians

fn `GetMiniMapDualScreen () -> position`

[source]

Returns

position: (“left”|“right”|false) --`"left"` or `"right"` when dual screen is enabled, otherwise `false`.

fn `GetSelectionBox () -> left, top, right, bottom`

Get vertices from currently active selection box

Check if a unit is not allowed to be added to a group by a player.

[source]

Params

unitID: integer

Returns

noGroup: boolean? --`true` if the unit is not allowed to be added to a group, `false` if it is allowed to be added to a group, or `nil` when `unitID` is not valid.

[source]

Gets a list of IDs of units that have had their draw flags changed, and the corresponding flags.

Params

sendMask: true --Whether to send objects draw flags as second return.

Returns

ids: integer[]
unitDrawFlags: DrawFlag[]

fn `GetRenderUnitsDrawFlagChanged (sendMask) -> ids`

fn `GetRenderFeaturesDrawFlagChanged (sendMask) -> ids, unitDrawFlags`

[source]

Gets a list of IDs of features that have had their draw flags changed, and the corresponding flags.

Params

sendMask: true --Whether to send objects draw flags as second return.

Returns

ids: integer[]
unitDrawFlags: DrawFlag[]

fn `GetRenderFeaturesDrawFlagChanged (sendMask) -> ids`

[source]

Params

left: number
top: number
right: number
bottom: number

allegiance: number? --(Default: `-1`) teamID when > 0, when < 0 one of AllUnits = -1, MyUnits = -2, AllyUnits = -3, EnemyUnits = -4

Returns

unitIDs: number[]?

fn `GetFeaturesInScreenRectangle (left, top, right, bottom) -> featureIDs`

Get features inside a rectangle area on the map

Returns

where: table<number,number[]> --keys are unitDefIDs and values are unitIDs
the: integer --number of unitDefIDs

fn `GetSelectedUnitsCounts () -> unitsCounts, the`

Get an aggregate count of selected units per unitDefID

[source]

Returns

unitsCounts: table<number,number> --where keys are unitDefIDs and values are counts
the: integer --number of unitDefIDs

fn `GetSelectedUnitsCount () -> selectedUnitsCount`

Returns

rotVal: number --in degrees
rotVel: number --in degrees
rotAcc: number --in degrees
rotValRng: number --in degrees
rotVelRng: number --in degrees
rotAccRng: number --in degrees

fn `GetCameraNames () -> indexByName`

fn `GetCameraRotation () -> rotX, rotY, rotZ`

Get camera rotation in radians.

Extended to allow a custom plane, parameters are (0, 1, 0, D=0) where D is the offset D can be specified in the third argument (if all the bools are false) or in the seventh (as shown).

Intersection coordinates are returned in t[4],t[5],t[6] when the ray goes offmap and includeSky is true), or when no unit or feature is hit (or onlyCoords is true).

This will only work for units & objects with the default collision sphere. Per Piece collision and custom collision objects are not supported.

The unit must be selectable, to appear to a screen trace ray.

Params

screenX: number --position on x axis in mouse coordinates (origin on left border of view)
screenY: number --position on y axis in mouse coordinates (origin on top border of view)
onlyCoords: boolean? --(Default: `false`) return only description (1st return value) and coordinates (2nd return value)

useMinimap: boolean? --(Default: `false`) if position arguments are contained by minimap, use the minimap corresponding world position

Params

sortType: number? --return unsorted if unspecified. Disabled = 0, Allies = 1, TeamID = 2, PlayerName = 3, PlayerCPU = 4, PlayerPing = 5

isMainTex: boolean? --(Default: `nil`). If `nil` - no filtering is done, if `false` - return normal/glow textures, if `true` - return main color textures.

addFilenames: boolean? --(Default: `false`). If `true` add the texture filenames in the second table

Returns

textureNames: string[] --All textures on the atlas and available for use in `SetGroundDecalTexture`.

fn `SetGroundDecalTextureParams (decalID) -> texWrapDistance, texTraveledDistance`

[source]

Params

decalID: integer

Returns

texWrapDistance: number? --If non-zero, sets the mode to repeat the texture along the left-right direction of the decal every texWrapFactor elmos.

texTraveledDistance: number --Shifts the texture repetition defined by texWrapFactor so the texture of a next line in the continuous multiline can start where the previous finished. For that it should collect all elmo lengths of the previously set multiline segments.

Send a ping request to the server

Loads a SoundDefs file, the format is the same as in gamedata/sounds.lua.

[source]

Params

x: number
y: number
z: number
transTime: number?

Returns

: nil

Params

unitID: integer?
append: boolean? --(Default: `false`) Append to current selection.

Returns

: nil

Params

lightHandle: number
unitOrProjectileID: integer
enableTracking: boolean
unitOrProjectile: boolean

Returns

success: boolean

fn `SetModelLightTrackingState (lightHandle, unitOrProjectileID, enableTracking, unitOrProjectile) -> success`

Set a model-illuminating light to start/stop tracking the position of a moving object (unit or projectile)

[source]

Params

lightHandle: number
unitOrProjectileID: integer
enableTracking: boolean
unitOrProjectile: boolean

Returns

success: boolean

fn `SetMapShader (standardShaderID, deferredShaderID) ->`

Changes/creates the cursor of a single CursorCmd.

[source]

Params

cmdName: string

iconFileName: string --not the full filename, instead it is like this:
Wanted filename: Anims/cursorattack_0.bmp
=> iconFileName: cursorattack

overwrite: boolean? --(Default: `true`)
hotSpotTopLeft: boolean? --(Default: `false`)

Returns

assigned: boolean?

fn `ReplaceMouseCursor (oldFileName, newFileName, hotSpotTopLeft) -> assigned`

useOverlay: boolean? --(Default: `false`) If `true`, the value will only be set in memory, and not be restored for the next game.

Returns

: nil

fn `SetConfigFloat (name, value, useOverlay) ->`

[source]

Params

name: string
value: number

useOverlay: boolean? --(Default: `false`) If `true`, the value will only be set in memory, and not be restored for the next game.

Returns

: nil

fn `SetConfigString (name, value, useOverlay) ->`

[source]

Params

name: string
value: string

useOverlay: boolean? --(Default: `false`) If `true`, the value will only be set in memory, and not be restored for the next game.

Returns

: nil

fn `Quit () ->`

Closes the application

Params

cmdID: (CMD|integer) --The command ID.
params: CreateCommandParams --Parameters for the given command.
options: CreateCommandOptions?

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

Returns

: boolean

fn `GiveOrderToUnit (unitID, cmdID, params, options, timeout) ->`

Give order to specific unit.

[source]

Params

unitID: integer
cmdID: (CMD|integer) --The command ID.
params: CreateCommandParams? --Parameters for the given command.
options: CreateCommandOptions?

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

Returns

: boolean

fn `GiveOrderToUnitMap (unitMap, cmdID, params, options, timeout) -> orderGiven`

Give order to multiple units, specified by table keys.

[source]

Params

unitMap: table<integer,any> --A table with unit IDs as keys.
cmdID: (CMD|integer) --The command ID.
params: CreateCommandParams? --Parameters for the given command.
options: CreateCommandOptions?

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

Returns

orderGiven: boolean

fn `GiveOrderToUnitArray (unitIDs, cmdID, params, options, timeout) -> ordersGiven`

Give order to an array of units.

[source]

Params

unitIDs: integer[] --Array of unit IDs.
cmdID: (CMD|integer) --The command ID.
params: CreateCommandParams? --Parameters for the given command.
options: CreateCommandOptions?

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

pairwise: boolean? --(Default: `false`) When `false`, assign all commands to each unit.
When `true`, assign commands according to index between units and cmds arrays.
If `len(unitArray) < len(cmdArray)` only the first `len(unitArray)` commands
will be assigned, and vice-versa.

fn `MarkerErasePosition (x, y, z, unused, localOnly, playerId, alwaysErase) ->`

[source]

Issue an erase command for markers on the map.

Params

x: number
y: number
z: number
unused: nil --This argument is ignored.
localOnly: boolean? --(Default: `false`) do not issue a network message, erase only for the current player
playerId: number? --when not specified it uses the issuer playerId

alwaysErase: boolean? --(Default: `false`) erase any marker when `localOnly` and current player is spectating. Allows spectators to erase players markers locally

Returns

: nil

fn `SetAtmosphere (params)`

fn `SetVideoCapturingMode (allowCaptureMode) ->`

This doesn’t actually record the game in any way, it just regulates the framerate and interpolations.

: nil

fn `PreloadUnitDefModel (unitDefID) ->`

Params

decalID: integer
normalX: number? --(Default: `0`)
normalY: number? --(Default: `0`)
normalZ: number? --(Default: `0`)

Returns

decalSet: boolean

fn `SetGroundDecalTint (decalID, tintColR, tintColG, tintColB, tintColA) -> decalSet`

[source]

Sets the tint of the ground decal. Color = 2 * textureColor * tintColor Respectively a color of (0.5, 0.5, 0.5, 0.5) is effectively no tint

Params

decalID: integer
tintColR: number? --(Default: curTintColR)
tintColG: number? --(Default: curTintColG)
tintColB: number? --(Default: curTintColB)
tintColA: number? --(Default: curTintColA)

Returns

decalSet: boolean

fn `SetGroundDecalMisc (decalID, dotElimExp, refHeight, minHeight, maxHeight, forceHeightMode) -> decalSet`

[source]

Sets varios secondary parameters of a decal

Params

decalID: integer

dotElimExp: number? --(Default: curValue) pow(max(dot(decalProjVector, SurfaceNormal), 0.0), dotElimExp), used to reduce decal artifacts on surfaces non-collinear with the projection vector

refHeight: number? --(Default: curValue)
minHeight: number? --(Default: curValue)
maxHeight: number? --(Default: curValue)

forceHeightMode: number? --(Default: curValue) in case forceHeightMode==1.0 ==> force relative height: midPoint.y = refHeight + clamp(midPoint.y - refHeight, minHeight); forceHeightMode==2.0 ==> force absolute height: midPoint.y = midPoint.y, clamp(midPoint.y, minHeight, maxHeight); other forceHeightMode values do not enforce the height of the center position

Returns

decalSet: boolean

fn `SetGroundDecalCreationFrame (decalID, creationFrameMin, creationFrameMax) -> decalSet`

If this call returns, something went wrong

Params

commandline_args: string --commandline arguments passed to spring executable.
startScript: string

Returns

: nil

fn `Start (commandline_args, startScript) ->`

Launches a new Spring instance without terminating the existing one.

[source]

If this call returns, something went wrong

Params

commandline_args: string --commandline arguments passed to spring executable.

startScript: string --the CONTENT of the script.txt spring should use to start (if empty, no start-script is added, you can still point spring to your custom script.txt when you add the file-path to commandline_args.

Returns

: nil

fn `SetWMIcon (iconFileName) ->`

Sets the icon for the process which is seen in the OS task-bar and other places (default: spring-logo).

[source]

Note: has to be 24bit or 32bit. Note: on windows, it has to be 32x32 pixels in size (recommended for cross-platform) Note: *.bmp images have to be in BGR format (default for m$ ones). Note: *.ico images are not supported.

Params

iconFileName: string

Returns

: nil

fn `SetWMCaption (title, titleShort) ->`

Set the window title for the process

[source]

Params

title: string --(Default: `"Spring <version>"`)

titleShort: string? --(Default: `"Spring <version>"`) displayed in the OS task-bar .
> [!NOTE]
> shortTitle is only ever possibly used under X11 (Linux & OS X), but not
> with QT (KDE) and never under Windows.

fn `GetMetalAmount (x, z) -> amount`

Returns the amount of metal on a single square.

[source]

Params

x: integer --X coordinate in worldspace / `Game.metalMapSquareSize`.
z: integer --Z coordinate in worldspace / `Game.metalMapSquareSize`.

Returns

amount: number

fn `SetMetalAmount (x, z, metalAmount) ->`

Sets the amount of metal on a single square.

[source]

Params

x: integer --X coordinate in worldspace / `Game.metalMapSquareSize`.
z: integer --Z coordinate in worldspace / `Game.metalMapSquareSize`.
metalAmount: number --must be between 0 and 255*maxMetal (with maxMetal from the .smd or mapinfo.lua).

Returns

: nil

fn `GetMetalExtraction (x, z) -> extraction`

[source]

Will declare a team to be dead (no further orders can be assigned to such teams units).

[source]

Params

teamID: integer
resource: (ResourceName|StorageName)
amount: number

Returns

: nil

fn `SetTeamShareLevel (teamID, type, amount) ->`

Changes the resource amount for a team beyond which resources aren’t stored but transferred to other allied teams if possible.

[source]

Params

teamID: integer
type: ResourceName
amount: number

Returns

: nil

fn `ShareTeamResource (teamID_src, teamID_recv, type, amount) ->`

Params

unitID: integer
selfd: boolean? --(Default: `false`) makes the unit act like it self-destructed.

reclaimed: boolean? --(Default: `false`) don't show any DeathSequences, don't leave a wreckage. This does not give back the resources to the team!

attackerID: integer?

cleanupImmediately: boolean? --(Default: `false`) stronger version of reclaimed, removes the unit unconditionally and makes its ID available for immediate reuse (otherwise it takes a few frames)

Returns

: nil

fn `TransferUnit (unitID, newTeamID, given) ->`

[source]

Params

unitID: integer
newTeamID: integer
given: boolean? --(Default: `true`) if false, the unit is captured.

Returns

: nil

fn `SetUnitCosts (unitID, where) ->`

[source]

Params

unitID: integer

where: table<number,number> --keys and values are, respectively and in this order: buildTime=amount, metalCost=amount, energyCost=amount

Returns

: nil

fn `SetUnitResourcing (unitID, res, amount) ->`

[source]

Params

unitID: integer
res: string
amount: number

Returns

: nil

fn `SetUnitResourcing (unitID, res) ->`

[source]

Params

unitID: integer

res: table<string,number> --keys are: "[u|c][u|m][m|e]" unconditional | conditional, use | make, metal | energy. Values are amounts

Note, if your game’s custom shading framework doesn’t support reverting into nanoframes then reverting into nanoframes via the “build” tag will fail to render properly.

See: SetUnitHealthAmounts

Params

unitID: integer

health: (number|SetUnitHealthAmounts) --If a number, sets the units health
to that value. Pass a table to update health, capture progress, paralyze
damage, and build progress.

See: Spring.SetUnitLosState

Params

unitID: integer
allyTeam: number

losTypes: (LosTable|LosMask|integer) --A bitmask of `LosMask` bits or a
table. True bits disable engine updates to visibility.

fn `SetUnitLosState (unitID, allyTeam, losTypes)`

Set current visibility status for a unit and team

Note this state will not be persisted if the visibility state is not masked.

Use it to change visibility state, once you set the unit to not receive engine visibility updates.

A few notes on certain bits:

contradar: True when the unit entered los at some point, remains set until radar is lost. Useful for tracking the unit type in radar, if you lost los you still know what unit type that radar dot refers to.
prevlos: True when the unit has entered los at least once, useful for tracking building locations (controls whether a ghost appears or not in the location)

[source]

See: Spring.SetUnitLosMask

Params

unitID: integer
allyTeam: number

losTypes: (LosTable|LosMask|integer) --A bitmask of `LosMask` bits or a
table

fn `SetUnitCloak (unitID, cloak, cloakArg) ->`

[source]

If the 2nd argument is a number, the value works like this: 1:=normal cloak 2:=for free cloak (cost no E) 3:=for free + no decloaking (except the unit is stunned) 4:=ultimate cloak (no ecost, no decloaking, no stunned decloak)

The decloak distance is only changed:

if the 3th argument is a number or a boolean.
if the boolean is false it takes the default decloak distance for that unitdef,
if the boolean is true it takes the absolute value of it.

[source]

Params

leavesGhost: boolean

leaveDeadGhost: boolean? --(Default: `false`) leave a dead ghost behind if disabling and the unit had a live static ghost.

[source]

: nil

fn `SetUnitFlanking (unitID, type, arg1, y, z) ->`

[source]

unitID: integer
neutral: boolean

Returns

setNeutral: boolean?

fn `SetUnitTarget (unitID, enemyUnitID, dgun, userTarget, weaponNum) -> success`

Defines a unit’s target.

[source]

Params

unitID: integer
enemyUnitID: integer? --when nil drops the units current target.
dgun: boolean? --(Default: `false`)
userTarget: boolean? --(Default: `false`)
weaponNum: number? --(Default: `-1`)

Returns

success: boolean

fn `SetUnitTarget (unitID, x, y, z, dgun, userTarget, weaponNum) -> success`

[source]

Params

unitID: integer
x: number? --when nil or not passed it will drop target and ignore other parameters
y: number?
z: number?
dgun: boolean? --(Default: `false`)
userTarget: boolean? --(Default: `false`)
weaponNum: number? --(Default: `-1`)

Returns

success: boolean

fn `SetUnitMidAndAimPos (unitID, mpX, mpY, mpZ, apX, apY, apZ, relative) -> success`

[source]

Params

unitID: integer
mpX: number --new middle positionX of unit
mpY: number --new middle positionY of unit
mpZ: number --new middle positionZ of unit
apX: number --new positionX that enemies aim at on this unit
apY: number --new positionY that enemies aim at on this unit
apZ: number --new positionZ that enemies aim at on this unit

relative: boolean? --(Default: `false`) are the new coordinates relative to world (false) or unit (true) coordinates? Also, note that apy is inverted!

Returns

success: boolean

: nil

fn `SetUnitSensorRadius (unitID, type, radius) -> New`

[source]

Params

Returns

New: number? --radius, or `nil` if unit is invalid.

fn `SetUnitPosErrorParams (unitID, posErrorVectorX, posErrorVectorY, posErrorVectorZ, posErrorDeltaX, posErrorDeltaY, posErrorDeltaZ, nextPosErrorUpdate) ->`

Params

unitID: integer
pitch: number --Rotation in X axis
yaw: number --Rotation in Y axis
roll: number --Rotation in Z axis

Returns

: nil

fn `SetUnitDirection (unitID, frontx, fronty, frontz) ->`

[source]

Set unit front direction vector. The vector is normalized in the engine.

Params

unitID: integer
frontx: number
fronty: number
frontz: number

Returns

: nil

fn `SetUnitDirection (unitID, frontx, fronty, frontz, rightx, righty, rightz) ->`

[source]

Set unit front and right direction vectors.

Both vectors will be normalized in the engine.

Params

unitID: integer
frontx: number
fronty: number
frontz: number
rightx: number
righty: number
rightz: number

Returns

: nil

fn `SetUnitHeadingAndUpDir (unitID, heading, upx, upy, upz) ->`

[source]

Apply damage to feature

[source]

Will trigger FeaturePreDamaged and FeatureDamaged callins.

[source]

Params

featureID: integer
enabled: true --Enable feature movement.
initialVelocityX: number? --Initial velocity on X axis, or `nil` for no change.
initialVelocityY: number? --Initial velocity on Y axis, or `nil` for no change.
initialVelocityZ: number? --Initial velocity on Z axis, or `nil` for no change.
accelerationX: number? --Acceleration per frame on X axis, or `nil` for no change.
accelerationY: number? --Acceleration per frame on Y axis, or `nil` for no change.
accelerationZ: number? --Acceleration per frame on Z axis, or `nil` for no change.

fn `SetFeatureMoveCtrl (featureID, enabled, velocityMaskX, velocityMaskY, velocityMaskZ, impulseMaskX, impulseMaskY, impulseMaskZ, movementMaskX, movementMaskY, movementMaskZ)`

Disable feature movement control.

Optional parameter allow physics vectors to build when not using MoveCtrl.

It is necessary to unlock feature movement on x, z axis before changing feature physics.

For example:

-- Unlock all movement before setting velocity.
Spring.SetFeatureMoveCtrl(featureID,false,1,1,1,1,1,1,1,1,1)

-- Set velocity.
Spring.SetFeatureVelocity(featureID,10,0,10)

[source]

Params

featureID: integer
enabled: false --Disable feature movement.

velocityMaskX: number? --Lock velocity change in X dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

velocityMaskY: number? --Lock velocity change in Y dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

velocityMaskZ: number? --Lock velocity change in Z dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

impulseMaskX: number? --Lock impulse in X dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

impulseMaskY: number? --Lock impulse in Y dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

impulseMaskZ: number? --Lock impulse in Z dimension when not using `MoveCtrl`. `0` to lock, non-zero to allow, or `nil` to for no change.

movementMaskX: number? --Lock move in X dimension when not using `MoveCtrl`. `0` to lock the axis, non-zero to allow, or `nil` for no change.

movementMaskY: number? --Lock move in Y dimension when not using `MoveCtrl`. `0` to lock the axis, non-zero to allow, or `nil` for no change.

movementMaskZ: number? --Lock move in Z dimension when not using `MoveCtrl`. `0` to lock the axis, non-zero to allow, or `nil` for no change.

fn `SetFeatureRotation (featureID, pitch, yaw, roll) ->`

[source]

Note: PYR order

Params

featureID: integer
pitch: number --Rotation in X axis
yaw: number --Rotation in Y axis
roll: number --Rotation in Z axis

Returns

: nil

fn `SetFeatureDirection (featureID, frontx, fronty, frontz) ->`

[source]

Set feature front direction vector. The vector is normalized in the engine.

Params

featureID: integer
frontx: number
fronty: number
frontz: number

Returns

: nil

fn `SetFeatureDirection (featureID, frontx, fronty, frontz, rightx, righty, rightz) ->`

[source]

Set feature front and right direction vectors.

Both vectors will be normalized in the engine.

Params

featureID: integer
frontx: number
fronty: number
frontz: number
rightx: number
righty: number
rightz: number

Returns

: nil

fn `SetFeatureHeadingAndUpDir (featureID, heading, upx, upy, upz) ->`

[source]

Use this call to set up feature direction in a robust way. If feature was completely upright, new {upx, upy, upz} direction will be used as new “up” vector, the rotation set by “heading” will remain preserved.

Params

featureID: integer
heading: Heading
upx: number
upy: number
upz: number

Returns

: nil

fn `SetFeatureVelocity (featureID, velX, velY, velZ)`

Set the velocity of a Feature

[source]

See: Spring.SetFeatureMoveCtrl for disabling/enabling this control

Params

featureID: integer
velX: number --in elmos/frame
velY: number --in elmos/frame
velZ: number --in elmos/frame

fn `SetFeatureBlocking (featureID, isBlocking, isSolidObjectCollidable, isProjectileCollidable, isRaySegmentCollidable, crushable, blockEnemyPushing, blockHeightChanges) -> isBlocking`

[source]

Params

featureID: integer

isBlocking: boolean? --If `true` add this feature to the `GroundBlockingMap`, but only if it collides with solid objects (or is being set to collide with the `isSolidObjectCollidable` argument). If `false`, remove this feature from the `GroundBlockingMap`. No change if `nil`.

Returns

isBlocking: boolean

fn `SetFeatureNoSelect (featureID, noSelect) ->`

[source]

Params

featureID: integer
noSelect: boolean

Returns

: nil

fn `SetFeatureMidAndAimPos (featureID, mpX, mpY, mpZ, apX, apY, apZ, relative) -> success`

[source]

Check Spring.SetUnitMidAndAimPos for further explanation of the arguments.

Params

featureID: integer
mpX: number
mpY: number
mpZ: number
apX: number
apY: number
apZ: number
relative: boolean?

Returns

success: boolean

fn `SetFeatureRadiusAndHeight (featureID, radius, height) -> success`

[source]

Params

featureID: integer
radius: number
height: number

Returns

success: boolean

fn `SetFeatureCollisionVolumeData (featureID, scaleX, scaleY, scaleZ, offsetX, offsetY, offsetZ, vType, tType, Axis) ->`

[source]

Check Spring.SetUnitCollisionVolumeData for further explanation of the arguments.

Params

Create a wreck from a unit

[source]

Params

unitID: integer
wreckLevel: integer? --(Default: `1`) Wreck index to use.
doSmoke: boolean? --(Default: `true`) Wreck emits smoke when `true`.

Returns

featureID: integer? --The wreck featureID, or nil if it couldn't be created or unit doesn't exist.

fn `CreateFeatureWreck (featureID, wreckLevel, doSmoke) -> featureID`

fn `SetProjectileMoveControl (projectileID, enable)`

Set whether engine should process position and speed for a projectile

Contrary to Spring.SetFeatureMoveCtrl, speed and position for projectiles can be set regardless of whether this method has been called or not.

Passing true merely skips engine updating velocity and position.

[source]

Params

projectileID: integer
enable: boolean

fn `SetProjectilePosition (projectileID, posX, posY, posZ)`

[source]

Params

projectileID: integer
targetID: number
targetType: ProjectileTargetType

Returns

validTarget: boolean?

fn `SetProjectileTarget (projectileID, posX, posY, posZ) -> validTarget`

Set projectile target (position)

[source]

Params

projectileID: integer
posX: number
posY: number
posZ: number

Returns

validTarget: boolean?

fn `SetProjectileTimeToLive (projectileID, ttl)`

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

Returns

unitOrdered: boolean

fn `GiveOrderToUnitMap (unitMap, cmdID, params, options, timeout) -> unitsOrdered`

Give order to multiple units, specified by table keys.

[source]

Params

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

Returns

unitsOrdered: integer --The number of units ordered.

fn `GiveOrderToUnitArray (unitIDs, cmdID, params, options, timeout) -> unitsOrdered`

[source]

Params

unitIDs: integer[] --An array of unit IDs.
cmdID: (CMD|integer) --The command ID.
params: CreateCommandParams? --Parameters for the given command.
options: CreateCommandOptions?

timeout: integer? --Absolute frame number. The command will be discarded after this frame. Only respected by mobile units.

pairwise: boolean? --(Default: `false`) When `false`, assign all commands to each unit.
When `true`, assign commands according to index between units and cmds arrays.
If `len(unitArray) < len(cmdArray)` only the first `len(unitArray)` commands
will be assigned, and vice-versa.

Returns

unitsOrdered: integer --The number of units ordered.

fn `LevelHeightMap (x, z, height)`

Set the height of a point in the world.

[source]

Params

x: number
z: number
height: number

fn `LevelHeightMap (x1, z1, x2, z2, height) ->`

Set the height of a rectangle area in the world.

[source]

Params

x1: number
z1: number
x2: number
z2: number
height: number?

Returns

: nil

fn `AdjustHeightMap (x, z, height)`

Add height to a point in the world.

[source]

Params

x: number
z: number
height: number

fn `AdjustHeightMap (x1, z1, x2, z2, height) ->`

Add height to a rectangle in the world.

[source]

: nil

fn `AddHeightMap (x, z, height) -> newHeight`

Can only be called in Spring.SetHeightMapFunc

[source]

Params

x: number
z: number
height: number

Returns

newHeight: integer?

fn `SetHeightMap (x, z, height, terraform) -> absHeightDiff`

[source]

Can only be called in Spring.SetHeightMapFunc.

Params

x: number
z: number
height: number
terraform: number? --(Default: `1`) Scaling factor.

Returns

absHeightDiff: integer? --If `0`, nothing will be changed (the terraform starts), if `1` the terraform will be finished.

fn `SetHeightMapFunc (luaFunction, arg, ...) -> absTotalHeightMapAmountChanged`

[source]

Example code:

function Spring.SetHeightMapFunc(function()
  for z=0,Game.mapSizeZ, Game.squareSize do
    for x=0,Game.mapSizeX, Game.squareSize do
      Spring.SetHeightMap( x, z, 200 + 20 * math.cos((x + z) / 90) )
    end
  end
end)

[source]

Params

x: number
z: number
height: number

Returns

height: number? --The new height, or `nil` if coordinates are invalid.

fn `SetSmoothMesh (x, z, height, terraform) -> The`

Params

passengerID: integer
transportID: integer

Returns

: nil

fn `SpawnProjectile (weaponDefID, projectileParams) -> projectileID`

[source]

Params

weaponDefID: integer
projectileParams: ProjectileParams

Returns

projectileID: integer?

fn `DeleteProjectile (projectileID) ->`

fn `SpawnSFX (unitID, sfxID, posX, posY, posZ, dirX, dirY, dirZ, radius, damage, absolute) -> success`

Equal to the UnitScript versions of EmitSFX, but takes position and direction arguments (in either unit- or piece-space) instead of a piece index.

[source]

Params

unitID: integer? --(Default: `0`)
sfxID: integer? --(Default: `0`)
posX: number? --(Default: `0`)
posY: number? --(Default: `0`)
posZ: number? --(Default: `0`)
dirX: number? --(Default: `0`)
dirY: number? --(Default: `0`)
dirZ: number? --(Default: `0`)
radius: number? --(Default: `0`)
damage: number? --(Default: `0`)
absolute: boolean?

Returns

success: boolean?

fn `SetNoPause (noPause) ->`

[source]

Params

noPause: boolean

Returns

: nil

fn `SetExperienceGrade (expGrade, ExpPowerScale, ExpHealthScale, ExpReloadScale) ->`

[source]

Params

unitID: integer
index: integer
cmdDesc: CommandDescription

fn `InsertUnitCmdDesc (unitID, cmdDesc)`

fn `GetTeamList (allyTeamID) -> teamIDs`

Get all team IDs.

[source]

Params

allyTeamID: -1? --(Default: `-1`)

Returns

teamIDs: number[] --List of team IDs.

fn `GetTeamList (allyTeamID) -> teamIDs`

Get the number of history entries.

[source]

Params

teamID: integer

Returns

historyCount: integer? --The number of history entries, or `nil` if unable to resolve team.

fn `GetTeamStatsHistory (teamID, startIndex, endIndex) -> The`

Get team stats history.

name: string
active: boolean
spectator: boolean
teamID: integer
allyTeamID: integer
pingTime: number
cpuUsage: number
country: string
rank: number
hasSkirmishAIsInTeam: boolean
playerOpts: { [string]: string } --when playerOpts is true
desynced: boolean

fn `GetPlayerControlledUnit (playerID) ->`

: number?

fn `GetUnitBuildeeRadius (unitID) ->`

[source]

front: float3?
up: float3
right: float3

fn `GetUnitRotation (unitID) -> pitch, yaw, roll`

[source]

Checks what a builder is currently doing. This is not the same as Spring.GetUnitCurrentCommand, because you can have a command at the front of the queue and not be doing it (for example because the target is still too far away), and on the other hand you can also be doing a task despite not having it in front of the queue (for example you’re Guarding another builder who does). Also, it resolves the Repair command into either actual repair, or construction assist (in which case it returns the appropriate “build” command). Only build-related commands are returned (no Move or any custom commands).

The possible commands returned are repair, reclaim, resurrect, capture, restore, and build commands (negative buildee unitDefID).

Params

unitID: integer

Returns

cmdID: integer --of the relevant command
targetID: integer --if applicable (all except RESTORE)

fn `GetUnitEffectiveBuildRange (unitID, buildeeDefID) -> effectiveBuildRange`

fn `GetUnitNanoPieces (unitID) -> pieceArray`

Get construction FX attachment points

[source]

Returns an array of pieces which represent construction points. Default engine construction FX (nano spray) will originate there.

Only works on builders and factories, returns nil (NOT empty table) for other units.

Params

unitID: integer

Returns

pieceArray: integer[]

fn `GetUnitTransporter (unitID) -> transportUnitID`

Get the transport carrying the unit

[source]

Returns the unit ID of the transport, if any. Returns nil if the unit is not being transported.

Params

unitID: integer

Returns

transportUnitID: integer?

fn `GetUnitIsTransporting (unitID) -> transporteeArray`

fn `GetUnitWeaponState (unitID, weaponNum, stateName) -> stateValue`

Check the state of a unit’s weapon

[source]

See: Spring.GetFactoryCommands for getting factory build queue commands

Params

unitID: integer --unitID when invalid this function returns nil.

cmdIndex: integer? --(Default: `0`) Command index to get. If negative will count from the end of the queue, e.g. -1 will be the last command.

Returns

cmdID: CMD?
options: (integer|CommandOptionBit)?
tag: integer?
Command: number? … --parameters.

fn `GetUnitCommands (unitID, count) -> commands`

Get the commands for a unit.

[source]

Same as Spring.GetCommandQueue

Params

unitID: integer
count: integer --Maximum amount of commands to return, `-1` returns all commands.

Returns

commands: Command[]

fn `GetUnitCommands (unitID, count) -> The`

Get the count of commands for a unit.

Params

unitID: integer

Returns

buildqueue: table<number,number>? --indexed by unitDefID with count values

fn `GetRealBuildQueue (unitID) -> buildqueue`

Note: PYR order

Params

featureID: integer

Returns

pitch: number? --Rotation in X axis
yaw: number? --Rotation in Y axis
roll: number? --Rotation in Z axis

fn `GetFeatureDirection (featureID) -> frontDirX, frontDirY, frontDirZ, rightDirX, rightDirY, rightDirZ, upDirX, upDirY, upDirZ`

[source]

Params

featureID: integer

Returns

frontDirX: number?
frontDirY: number?
frontDirZ: number?
rightDirX: number?
rightDirY: number?
rightDirZ: number?
upDirX: number?
upDirY: number?
upDirZ: number?

fn `GetFeatureVelocity (featureID) -> x, y, z, w`

Get the feature current fire timer.

[source]

Params

featureID: integer

Returns

fireTime: number? --in seconds, nil when featureID is invalid.

fn `GetFeatureSmokeTime (featureID) -> smokeTime`

fn `GetPieceProjectileParams (projectileID) -> explosionFlags, spinAngle, spinSpeed, spinVectorX, spinVectorY, spinVectorZ`

[source]

Params

projectileID: integer

Returns

explosionFlags: number? --encoded bitwise with SHATTER = 1, EXPLODE = 2, EXPLODE_ON_HIT = 2, FALL = 4, SMOKE = 8, FIRE = 16, NONE = 32, NO_CEG_TRAIL = 64, NO_HEATCLOUD = 128

spinAngle: number
spinSpeed: number
spinVectorX: number
spinVectorY: number
spinVectorZ: number

fn `GetProjectileTarget (projectileID) -> targetTypeInt, target`

[source]

Params

projectileID: integer

Returns

targetTypeInt: number? --where
string.byte('g') := GROUND
string.byte('u') := UNIT
string.byte('f') := FEATURE
string.byte('p') := PROJECTILE

Params

projectileID: integer

Returns

: number?

fn `GetProjectileDamages (projectileID, tag) ->`

[source]

Params

projectileID: integer

tag: string --one of:
"paralyzeDamageTime"
"impulseFactor"
"impulseBoost"
"craterMult"
"craterBoost"
"dynDamageExp"
"dynDamageMin"
"dynDamageRange"
"dynDamageInverted"
"craterAreaOfEffect"
"damageAreaOfEffect"
"edgeEffectiveness"
"explosionSpeed"
- or -
an armor type index to get the damage against it.

Water may at some point become shaped (rivers etc) but for now it is always a flat plane. Use this function instead of GetWaterLevel to denote you are relying on that assumption.

[source]

blocking: BuildOrderBlockedStatus
featureID: integer? --A reclaimable feature in the way.

fn `Pos2BuildPos (unitDefID, posX, posY, posZ, buildFacing) -> buildPosX, buildPosY, buildPosZ`

fn `GetUnitLosState (unitID, allyTeamID, raw) -> bitmask`

Get unit los state (bitmask)

[source]

Params

unitID: integer
allyTeamID: integer?
raw: true --Return a bitmask.

Returns

bitmask: (LosMask|integer)? --A bitmask of `LosMask` bits

fn `GetUnitLosState (unitID, allyTeamID, raw) -> los`

Get unit los state (table)

[source]

Params

unitID: integer
allyTeamID: integer?
raw: false? --Return a table.

Returns

los: table<(“los”|“radar”…),boolean>? --A table of LOS state names as keys and booleans as values, or `nil` if `unitID` is invalid.

Logs a message to the logfile/console.

[source]

Params

section: string --Sets an arbitrary section. Level filtering can be applied per-section
logLevel: (LogLevel|LOG)? --(Default: `"notice"`)
...: string --messages

fn `CallAsTeam (teamID, func, ...) -> The`

Calls a function from given team’s PoV. In particular this makes callouts obey that team’s visibility rules.

[source]

Params

teamID: integer --Team ID.
func: fun(…) --The function to call.
...: any --Arguments to pass to the function.

Returns

The: any … --return values of the function.

fn `CallAsTeam (options, func, ...) -> The`

[source]

Params

options: CallAsTeamOptions --Options.
func: fun(…) --The function to call.
...: any --Arguments to pass to the function.

Returns

The: any … --return values of the function.

field `SYNCED`

is table<string,any>

Proxy table for reading synced global state in unsynced code.

Generally not recommended. Instead, listen to the same events as synced and build the table in parallel

Unsynced code can read from the synced global table (_G) using the SYNCED proxy table. e.g. _G.foo can be access from unsynced via SYNCED.foo.

This table makes a copy of the object on the other side, and only copies numbers, strings, bools and tables (recursively but with the type restriction), in particular this does not allow access to functions.

Note that this makes a copy on each access, so is very slow and will not reflect changes. Cache it, but remember to refresh.

[source]

table `tracy`

fn `ZoneBegin (name)`

Params

name: string

fn `ZoneBeginN (name)`

Params

name: string

fn `ZoneBeginS (name)`

Params

name: string

fn `ZoneBeginNS (name)`

Params

name: string

fn `ZoneEnd ()`

fn `ZoneText (text)`

Params

text: string

fn `ZoneName (name)`

As an additional caveat, synced Lua cannot use the os and io modules, so using VFS is mandatory there to have any file access at all.

The VFS module doesn’t simply open archives though. What it does is map your game files, game dependencies and Spring content onto a virtual file tree. All archives start from the ‘roots’ of the tree and share the same virtual space, meaning that if two or more archives contain the same resource file name the resources overlap and only one of the files will be retrieved. Overlapping directories on the other hand are merged so the resulting virtual directory contains the contents of both. Here is an example of how this works:

Archive 1 (games/mygame.sd7)

textures
└── texture1.png
models
└── model1.mdl

Archive 2 (base/springcontent.sdz)

textures
├── texture1.png
├── texture2.png
└── texture3.png

VFS

textures
├── texture1.png
├── texture2.png
└── texture3.png
models
└── model1.mdl

This raises the question: If both archives have a texture1.png then which texture1.png is retreived via the VFS? The answer depends on the order the archives are loaded and the VFS mode (more on modes below). Generally however, each archive loaded overrides any archives loaded before it. The standard order of loading (from first to last) is:

The automatic dependencies springcontent.sdz and maphelper.sdz.
Dependencies listed in your modinfo.lua (or modinfo.tdf), in the order listed. Note that they are loaded fully and recursively, i.e. all the deeper dependencies of the 1st base-level dependency are loaded before the 2nd base-level dependency. This breaks the usual “loaded later overrides loaded earlier” priority if a dependency comes from multiple places, since only the first time an archive is loaded counts.
Your mod archive.

Loose files (not within any archive) in the engine dir are also visible as if under the VFS root if loading under the VFS.RAW mode, though you can also use full FS path (i.e. C:/.../Spring/foo/bar.txt is visible both as that and as just foo/bar.txt). Note that VFS.RAW is only accessible to unsynced Lua, all synced states are limited to loaded archives.

Paths

Spring’s VFS is lowercase only. Also it is strongly recommended to use linux style path separators, e.g. "foo/bar.txt" and not "foo\bar.txt".

Engine read files

The engine access a few files directly, most of them are lua files which access other files themselves. Here the list of files that must exist in the VFS (some of them don’t have to be in the game/map archive cause there are fallback solutions in springcontent.sdz & maphelper.sdz):

./
anims/
cursornormal.bmp/png
gamedata/
defs.lua
explosions.lua
explosion_alias.lua
icontypes.lua
messages.lua
modrules.lua
resources.lua
resources_map.lua
sidedata.lua
sounds.lua
luagaia/
main.lua
draw.lua
luarules/
main.lua
draw.lua
luaui/
main.lua
shaders/
?
luaai.lua
mapinfo.lua
mapoptions.lua
modinfo.lua
modoptions.lua
validmaps.lua

Loads and runs lua code from a file in the VFS.

[source]

The path is relative to the main Spring directory, e.g.

VFS.Include('LuaUI/includes/filename.lua', nil, vfsmode)

Params

filename: string

environment: table? --(Default: the current function environment)
The environment arg sets the global environment (see generic lua refs). In
almost all cases, this should be left `nil` to preserve the current env.
If the provided, any non-local variables and functions defined in
`filename.lua` are then accessable via env. Vise-versa, any variables
defined in env prior to passing to `VFS.Include` are available to code in the
included file. Code running in `filename.lua` will see the contents of env in
place of the normal global environment.

mode: string?

Returns

module: any --The return value of the included file.

fn `LoadFile (filename, mode) -> data`

[source]

Params

archiveName: string
fun: unknown

Returns

Results: any … --of the given function

fn `CompressFolder (folderPath, archiveType, compressedFilePath, includeFolder, mode)`

Compresses the specified folder.

[source]

Params

folderPath: string

archiveType: string? --(Default: `"zip"`)The compression type (can
currently be only `"zip"`).

compressedFilePath: string? --(Default: `folderPath .. ".sdz"`)

includeFolder: boolean? --(Default: `false`) Whether the archive should
have the specified folder as root.

is rgba

field `skyAxisAngle`

is xyzw
rotation axis and angle in radians of skybox orientation

alias `Attachment`

(“depth”|“stencil”|“color0”|“color1”|“color2”|“color3”|“color4”|“color5”|“color6”|“color7”|“color8”|“color9”|“color10”|“color11”|“color12”|“color13”|“color14”|“color15”)

[source]

alias `BuildOrderBlockedStatus`

is (0|1|2|3)
[source]

class `CallAsTeamOptions`

[source]

field `ctrl`

is integer
Ctrl team ID.

field `read`

is integer
Read team ID.

field `select`

is integer
Select team ID.

class `Callins`

[source]
See: Gadget Widget Menu Intro SyncedCallins UnsyncedCallins

method `Initialize ()`

Called when the addon is (re)loaded.

[source]

method `LoadCode ()`

Called when the game is (re)loaded.

teamID: integer

Called when a unit gains experience greater or equal to the minimum limit set by calling Spring.SetExperienceGrade.

Should be called more reliably with small values of experience grade.

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer
experience: number
oldExperience: number

Called when a unit is loaded by a transport.

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer
transportID: integer
transportTeam: integer

method `UnitUnloaded (unitID, unitDefID, unitTeam, transportID, transportTeam)`

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer

Called when the projectile is created.

[source]

Note that weaponDefID is missing if the projectile is spawned as part of a burst, but Spring.GetProjectileDefID and Spring.GetProjectileName still work in callin scope using proID.

See: Script.SetWatchProjectile Script.SetWatchWeapon

Params

proID: integer
proOwnerID: integer
weaponDefID: integer

method `ProjectileDestroyed (proID, ownerID, proWeaponDefID)`

Called when the projectile is destroyed.

[source]

See: Script.SetWatchProjectile Script.SetWatchWeapon

Params

proID: integer
ownerID: integer
proWeaponDefID: integer

method `Explosion (weaponDefID, px, py, pz, attackerID, projectileID) -> noGfx`

Called when an explosion occurs.

[source]

Only called for weaponDefIDs registered via Script.SetWatchExplosion or Script.SetWatchWeapon.

See: Script.SetWatchExplosion Script.SetWatchWeapon

Called whenever fonts are updated. Signals the game display lists and other caches should be discarded.

Gets called before other Update and Draw callins.

[source]

method `SunChanged ()`

[source]

method `DefaultCommand (type, id)`

Used to set the default command when a unit is selected.

[source]

Params

type: (“unit”|“feature”) --The type of the object pointed at.
id: integer --The `unitID` or `featureID`.

method `DrawGenesis ()`

Use this callin to update textures, shaders, etc.

[source]

Doesn’t render to screen! Also available to LuaMenu.

method `DrawWorld ()`

Spring draws command queues, ‘map stuff’, and map marks.

[source]

method `DrawWorldPreUnit ()`

Spring draws units, features, some water types, cloaked units, and the sun.

[source]

method `DrawPreDecals ()`

Called before decals are drawn

method `DrawGroundPostForward ()`

[source]

method `DrawGroundPreDeferred ()`

Runs at the start of the deferred pass when a custom map shader has been assigned via Spring.SetMapShader (convenient for setting uniforms).

Runs at the end of the feature deferred pass to inform Lua code it should make use of the $model_gbuffer_* textures before another pass overwrites them (and to allow proper blending with e.g. cloaked objects which are drawn between these events and DrawWorld via gl.CopyToTexture). N.B. The *PostDeferred events are only sent (and only have a real purpose) if forward drawing is disabled.

[source]

Params

keyCode: number
mods: KeyModifiers
label: boolean --the name of the key
utf32char: number --(deprecated) always 0
scanCode: number
actionList: table --the list of actions for this keyrelease

Returns

: boolean

method `TextInput (utf8char)`

Called whenever a key press results in text input.

Called every Update.

[source]

Must return true for Mouse* events and Spring.GetToolTip to be called.

Params

x: number
y: number

Returns

isAbove: boolean

method `GetTooltip (x, y) -> tooltip`

Called when Spring.IsAbove returns true.

[source]

Returning: boolean --true deletes the command and does not send it through the network.

method `AddConsoleLine (msg, priority)`

Called when text is entered into the console (e.g. Spring.Echo).

[source]

Params

msg: string
priority: integer

method `GroupChanged (groupID)`

is (0|1|2|3|4|5|6)

alias `CameraName`

is (“ta”|“spring”|“rot”|“ov”|“free”|“fps”|“dummy”)

class `CameraState`

field `rgtFrustumPlane`

is xyz

enum `CMD`

Command constants.

Table defining Command related constants.

Contains a mix of special constants like command options or move states, and the list of engine command IDs.
Also supports integer keys, and those perform reverse mapping of command IDs.

[source]

is integer

Stop the current action and clear the unit’s command queue.

For factories, this will cancel the new unit orders queue. For units, this will cancel the current command and queue.

Accepts no parameters.

It won’t do anything if used with CMD.INSERT, or the shift option.

[source]

field `INSERT`

is integer
[source]

field `REMOVE`

is integer

Remove all commands from a unit’s queue matching specific cmdIDs or tags.

Modes of operation

Filter by tag

Removes any command with a tag matching those included in params.

params {tag1, tag2 …} an array of tags to look for.

This is the default mode of operation.

Filter by id

Removes any command with a command id matching those included in params.

params {id1, id2 …} or {tag1, tag2, …} an array of ids tags to look for.

To use this mode you need to pass the alt option.

Command Options

alt Tag/Id switch
ctrl Alternative queue selection.
For factories alternative queue is the factory command queue, default queue is the rally queue.
For other units no effect.

Examples

Delete all attack orders from unit, or factory rally queue if factory:

Spring.GiveOrderToUnit(unitID, CMD.REMOVE, CMD.ATTACK)

Delete all attack and fight orders from unit, or factory rally queue if factory:

Spring.GiveOrderToUnit(unitID, CMD.REMOVE, {CMD.ATTACK, CMD.FIGHT}, CMD.OPT_ALT)

Delete commands with specific tags:

Spring.GiveOrderToUnit(unitID, CMD.REMOVE, {tag1, tag2, tag3})

Delete all commands to build units with UnitDef ids unitDefId1 and unitDefId2 from factory queue:

Spring.GiveOrderToUnit(unitID, CMD.REMOVE, {-unitDefId1, -unitDefId2}, CMD.OPT_ALT + CMD.OPT_CTRL)

[source]

field `WAIT`

is integer

Makes the unit suspend processing its command queue until wait is removed.

Accepts no parameters.

[source]

field `TIMEWAIT`

is integer

Makes the unit suspend processing its command queue for a given duration.

params {duration} Time to wait in seconds.

[source]

field `DEATHWAIT`

is integer

Makes the unit suspend processing its commmand queue until the death of a given unit or units in an area.

Modes of operation

Wait for death of specific unit

params {unitID} unitID of the unit to wait for.

Wait for death of units in an area

params {x1, y1, z1, x2, y2, z2}: Wait for death of units in square {x1, z1, x2, z2}.

[source]

field `SQUADWAIT`

is integer

Makes selected units, or units coming out of a factory wait until squadSize peers are found to go with them.

If given to non factory units and the squadSize is smaller than the selected number of units the command will have no effect.

Each unit will find squadSize other units and resume wait, those remaining without peers will wait. For example if there are 30 selected units and a squadSize of 12 is sent, 6 units will stay waiting, as 30 - 12*2 = 6.

If given at a waypoint for a factory queue for new units, units coming out of the factory will wait at the waypoint until squadSize units are available, and then they will proceed together.

Can also be given to a group of factories, and units from those factories will gather together.

params {squadSize} Squad size.

[source]

field `GATHERWAIT`

is integer

Makes the unit wait for all other selected units to reach the command.

Useful to make units wait until all other units have reached a waypoint.

Will only be given to movable (unitDef.canMove == true) non-factory units.

Accepts no parameters.

Attack single target

params {unitID}: Attack a unit

The command will end once the target is dead or not valid any more.

Area attack

Will create a number of single target actions by finding targets in a circle.

Note: this is different than CMD.AREA_ATTACK, since this initially finds the targets but then doesn’t consider the area any more.

params {x,y,z,r} when radius is greater than 0.
r: radius
x,y,z: map position

Ground attack

params {x,y,z,0} or {x,y,z}
x,y,z: map position

Command Options

alt Also target stunned targets. Without this stunned targets will be skipped.
meta Override manualFire, and noAutoTarget weapon behaviours.

Other modifiers

modInfo.targetableTransportedUnits: Controls whether transported units are targetable.

Callins

UnitCmdDone: Run when the command is finished.

Examples

Attack unit with id targetID.

Spring.GiveOrderToUnit(unitID, CMD.ATTACK, targetID)

Area attack of radius 50 at map position 1000,1000 with height 100:

Spring.GiveOrderToUnit(unitID, CMD.ATTACK, {1000,100,1000,50})

Ground attack at map position 1000,1000 with height 100:

Spring.GiveOrderToUnit(unitID, CMD.ATTACK, {1000,100,1000})

is integer

Expect 1 parameter in return (number).

[source]

enum `COB`

COB constants

class `CommandDescription`

Contains data about a configuration, only name and type are guaranteed

field `[1]`

is number
x

field `[2]`

is number
y

field `[3]`

is number
z

field `[4]`

is number
weight

class `CreateCommand`

class `FBO`

alias `GenericMoveTypeNumberKey`

is (“maxSpeed”|“maxWantedSpeed”|“maneuverLeash”|“waterline”)
[source]

enum `GL`

Constants for OpenGL API

For callouts related to OpenGL usage in Recoil, see gl.

[source]

Integer in range [-32768, 32767] that represents a 2D (xz plane) unit orientation.

                  F(N=2) = H(-32768 / 32767)

                         ^
                         |
                         |
 F(W=3) = H(-16384)  <---o--->  F(E=1) = H(16384)
                         |
                         |
                         v

                  F(S=0) = H(0)

[source]

inherits from `Callins`

[source]
See: Callins

method `DrawLoadScreen ()`

Draws custom load screens.

[source]

method `LoadProgress (message, replaceLastLine)`

[source]

Params

message: string
replaceLastLine: boolean

class `KeyBinding`

Contains data about a keybinding

[source]

field `command`

is string

field `extra`

is string

field `boundWith`

is string

class `KeyModifiers`

Key Modifier Params

[source]

field `right`

is boolean
Right mouse key pressed

field `alt`

is boolean
Alt key pressed

field `ctrl`

is boolean
Ctrl key pressed

field `shift`

is boolean
Shift key pressed

class `LightParams`

alias `LogLevel`

class `losAccess`

Parameters for los access

If one condition is fulfilled all beneath it are too (e.g. if an unit is in LOS it can read params with inradar=true even if the param has inlos=false) All GameRulesParam are public, TeamRulesParams can just be private,allied and/or public You can read RulesParams from any Lua environments! With those losAccess policies you can limit their access.

All GameRulesParam are public, TeamRulesParams can just be private,allied and/or public You can read RulesParams from any Lua environments! With those losAccess policies you can limit their access.

[source]

field `private`

is boolean?
only readable by the ally (default)

field `allied`

is boolean?
readable by ally + ingame allied

field `inlos`

is boolean?
readable if the unit is in LOS

field `inradar`

is boolean?
readable if the unit is in AirLOS

field `public`

is boolean?
readable by all

enum `LosMask`

[source]

field `INLOS`

is integer
the unit is currently in the los of the allyteam

field `INRADAR`

is integer
the unit is currently in radar from the allyteam

field `PREVLOS`

is integer
the unit has previously been in los from the allyteam

field `CONTRADAR`

is integer
the unit has continuously been in radar since it was last inlos by the allyteam

alias `LosTable`

noBillboarding: boolean? --When `false` sets 3d billboard mode. Defaults to `true`.
userDefinedBlending: boolean? --When `true` doesn't set the gl.BlendFunc automatically. Defaults to `false`.

class `MapRenderingParams`

alias `MatrixName`

(“view”|“projection”|“viewprojection”|“viewinverse”|“projectioninverse”|“viewprojectioninverse”|“billboard”|“shadow”|“camera”|“camprj”|“caminv”|“camprjinv”)

[source]

class `Menu`

inherits from `Callins`

[source]
See: Callins

method `ActivateMenu ()`

Called whenever LuaMenu is on with no game loaded.

[source]

method `ActivateGame ()`

Called whenever LuaMenu is on with a game loaded.

[source]

method `AllowDraw () -> allowDraw`

Enables Draw{Genesis,Screen,ScreenPost} callins if true is returned, otherwise they are called once every 30 seconds. Only active when a game isn’t running.

[source]

Returns

allowDraw: boolean

alias `ModType`

is (0|1|3|4)
[source]

class `MoveCtrl`

Accessed via Spring.MoveCtrl.

[source]

numAssignedValues: number

fn `SetGunshipMoveTypeData (unitID, key, value) -> numAssignedValues`

[source]

Params

unitID: integer

key: (GenericMoveTypeNumberKey|“wantedHeight”|“accRate”|“decRate”|“turnRate”|“altitudeRate”|“currentBank”|“currentPitch”…)

is integer
ASCII number for the character u

class `RBO`

field `[3]`

is number
Blue value.

field `[4]`

is number
Alpha value.

class `RmlUi.Context`

Holds documents and a data model.

The Context class has no constructor; it must be instantiated through the CreateContext() function. It has the following functions and properties:

[source]

method `AddEventListener (event, script, element_context, in_capture_phase)`

Adds the inline Lua script, script, as an event listener to the context. element_context is an optional Element; if it is not None, then the script will be executed as if it was bound to that element.

[source]

Params

event: string
script: RmlUi.Element
element_context: boolean
in_capture_phase: boolean

method `CreateDocument (tag) ->`

Creates a new document with the tag name of tag.

[source]

Params

tag: string

Returns

: RmlUi.Document

method `LoadDocument (document_path) ->`

Attempts to load a document from the RML file found at document_path. If successful, the document will be returned with a reference count of one.

Returns

: boolean

method `UnloadAllDocuments ()`

Closes all documents currently loaded with the context.

name: string
model: T
widget: table

Returns

: RmlUi.SolLuaDataModel

method `RemoveDataModel (name)`

Processes a key up event.

[source]

Params

key: RmlUi.key_identifier
key_modifier_state: integer

Returns

: boolean

method `ProcessTextInput (text) ->`

Processes a text input event.

[source]

: boolean

method `GetElementAtPoint (point, ignore) ->`

Returns the element at the point specified by point.

[source]

is integer
[source]

field `TargetAndBubble`

method `Show (modal, focus)`

Shows the document.

[source]

Params

modal: RmlUi.RmlModalFlag? --Defaults to Focus
focus: RmlUi.RmlFocusFlag?

method `Hide ()`

Hides the document.

[source]

method `Close ()`

is RmlUi.Context
[source]

field `url`

is string
[source]

field `modal`

is boolean
[source] Is it modal?

field `widget`

is table
[source] A table of data that can be accessed in onevent attributes. It doesn’t have to be a widget.

class `RmlUi.Element`

Represents an element in the RmlUi document tree. This class cannot be constructed directly; use a Document object to instantiate elements. This is the foundational piece of the DOM.

[source]

method `AddEventListener (event, listener, in_capture_phase)`

Adds an event listener to the element.

[source]

method `DispatchEvent (event, parameters, interruptible) ->`

Dispatches an event to this element.

[source]

Params

event: string
parameters: table
interruptible: string

Returns

: boolean

method `Focus ()`

method `HasAttribute (name) ->`

Returns True if the element has a value for the attribute named name, False if not.

[source]

: RmlUi.Element?

method `IsClassSet (name) ->`

Returns true if the class name is set on the element, false if not.

[source]

: boolean

method `ReplaceChild (inserted_element, replaced_element) ->`

Replaces the child element replaced_element with inserted_element in this element’s list of children. If replaced_element is not a child of this element, inserted_element will be appended onto the list instead.

[source]

Returns

value: (number|string|"") --Returns number if it has the tag "input", a string if it has the tag "textarea", else an empty string.

method `GetChild (index) ->`

[source]

Params

index: integer

Returns

: RmlUi.Element?

field `class_name`

is string
[source] Name of the class.

field `id`

is string
[source] ID of this element, in the context of <span id="foo">.

field `inner_rml`

is string
[source] Gets or sets the inner RML (markup) content of the element.

field `scroll_left`

is integer
[source] Gets or sets the number of pixels that the content of the element is scrolled from the left.

field `scroll_top`

is integer
[source] Gets or sets the number of pixels that the content of the element is scrolled from the top.

field `attributes`

is RmlUi.ElementAttributesProxy
[source] Read-only. Proxy for accessing element attributes.

field `child_nodes`

is RmlUi.ElementChildNodesProxy
[source] Read-only. Proxy for accessing child nodes of the element.

field `client_left`

is integer
[source] Read-only. The width of the left border of the element in pixels.

field `client_height`

is integer
[source] Read-only. The inner height of the element in pixels, including padding but not the horizontal scrollbar height, border, or margin.

field `client_top`

is integer
[source] Read-only. The width of the top border of the element in pixels.

field `client_width`

is integer
[source] Read-only. The inner width of the element in pixels, including padding but not the vertical scrollbar width, border, or margin.

field `first_child`

is RmlUi.Element?
[source] Read-only. The first child element, or nil if there are no children.

field `last_child`

is RmlUi.Element?
[source] Read-only. The last child element, or nil if there are no children.

field `next_sibling`

is RmlUi.Element?
[source] Read-only. The next sibling element, or nil if there is none.

field `offset_height`

is integer
[source] Read-only. The height of the element including vertical padding and borders, in pixels.

field `offset_left`

is integer
[source] Read-only. The distance from the inner left edge of the offset parent, in pixels.

field `offset_parent`

is RmlUi.Element
[source] Read-only. The closest positioned ancestor element.

field `offset_top`

is integer
[source] Read-only. The distance from the inner top edge of the offset parent, in pixels.

field `offset_width`

is integer
[source] Read-only. The width of the element including horizontal padding and borders, in pixels.

field `owner_document`

is RmlUi.Document
[source] Read-only. The document that owns this element.

field `parent_node`

is RmlUi.Element?
[source] Read-only. The parent node of this element, or nil if there is none.

field `previous_sibling`

is RmlUi.Element?
[source] Read-only. The previous sibling element, or nil if there is none.

field `scroll_height`

is integer
[source] Read-only. The total height of the element’s content, including content not visible on the screen due to overflow.

field `scroll_width`

is integer
[source] Read-only. The total width of the element’s content, including content not visible on the screen due to overflow.

field `style`

is RmlUi.ElementStyleProxy
[source] Read-only. Proxy for accessing and modifying the element’s style properties.

field `tag_name`

is string
[source] Read-only. The tag name of the element.

field `address`

is string
[source] Read-only. The address of the element in the document tree.

field `absolute_left`

is integer
[source] Read-only. The absolute left position of the element relative to the document.

field `absolute_top`

is integer
[source] Read-only. The absolute top position of the element relative to the document.

field `baseline`

is integer
[source] Read-only. The baseline position of the element.

field `line_height`

is integer
[source] Read-only. The computed line height of the element.

field `visible`

is boolean
[source] Read-only. True if the element is visible, false otherwise.

field `z_index`

is integer
[source] Read-only. The computed z-index of the element.

alias `RmlUi.ElementAttributesProxy`

is { [string]: (string|number|boolean) }

Contains all the attributes of an element: The stuff in the opening tag i.e. <span class="my-class">

[source]

alias `RmlUi.ElementChildNodesProxy`

is RmlUi.Element[]

Contains a list of all child elements.

[source]

class `RmlUi.ElementForm`

inherits from `RmlUi.Element`

[source]

method `Submit (name, value)`

[source]

Params

name: string?
value: string?

class `RmlUi.ElementFormControl`

inherits from `RmlUi.Element`

[source]

field `disabled`

is boolean
[source]

field `name`

is string
[source]

field `value`

is string
[source]

field `submitted`

is boolean
[source]

class `RmlUi.ElementFormControlInput`

inherits from `RmlUi.Element` `RmlUi.ElementFormControl`

is integer
[source]

class `RmlUi.ElementFormControlSelect`

class `RmlUi.ElementFormControlTextArea`

[source]

field `value`

is number
[source]

field `max`

is number
[source]

class `RmlUi.ElementPtr`

Represents an owned element.

This type is mainly used to modify the DOM tree by passing the object into other elements. For example RmlUi.Element:AppendChild(). A current limitation in the Lua plugin is that Element member properties and functions cannot be used directly on this type.

[source]

alias `RmlUi.ElementStyleProxy`

is { [string]: string }

Gets the rcss styles associated with an element. As far as I can tell, the values will always be a string.

[source]

Params

index: integer

field `active_tab`

is integer
[source]

field `num_tabs`

is integer
[source]

class `RmlUi.ElementText`

inherits from `RmlUi.Element`

[source]

field `text`

is string
[source]

class `RmlUi.Event`

alias `RmlUi.EventID`

is (0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|integer)
[source]

class `RmlUi.EventListener`

Event listener interface

[source]

Params

property: string

alias `RmlUi.StyleProxy`

is { [string]: string }
[source]

class `RmlUi.Vector2f`

Two-dimensional float vector

[source]

fn `new (x, y) ->`

[source]

Params

x: number
y: number

Returns

: RmlUi.Vector2f

field `x`

is number
[source]

field `y`

is number
[source]

field `magnitude`

is number
[source]

class `RmlUi.Vector2i`

Two-dimensional integral vector.

[source]

fn `new (x, y) ->`

[source]

Params

x: integer
y: integer

Returns

: RmlUi.Vector2i

field `x`

is integer
[source]

field `y`

is integer
[source]

field `magnitude`

is number
[source]

class `Roster`

Contains data about a player

[source]

field `name`

is string

field `playerID`

is integer

field `teamID`

is integer

field `allyTeamID`

is integer

field `spectator`

is boolean

field `cpuUsage`

is number
in order to find the progress, use: cpuUsage&0x1 if it’s PC or BO, cpuUsage& 0xFE to get path res, (cpuUsage»8)*1000 for the progress

field `pingTime`

is number
if -1, the player is pathfinding

class `RulesParams`

inherits from `table<string,integer>`

[source]

class `RulesSyncedCallins`

inherits from `Callins` `UnsyncedCallins` `SyncedCallins`

Callins that are sent to the synced lua file: LuaRules/main.lua

class `RulesUnsyncedCallins`

inherits from `Callins` `UnsyncedCallins`

Callins that are sent to the unsynced lua file: LuaRules/draw.lua

class `SaveImageOptions`

[source]

field `alpha`

is boolean
(Default: false)

field `yflip`

is boolean
(Default: true)

field `grayscale16bit`

is boolean
(Default: false)

field `readbuffer`

is GL
(Default: current read buffer)

class `SetUnitHealthAmounts`

[source]

field `health`

is number?
Set the unit’s health.

field `capture`

is number?
Set the unit’s capture progress.

field `paralyze`

Side spec

[source]

See: Spring.GetSideData

field `sideName`

is string

Returned when getting arrays of side specifications.

Lowercase side name.

field `caseName`

is string
Original case side name.

field `startUnit`

is string

alias `SoundChannel`

is (“general”|“battle”|“sfx”|“unitreply”|“voice”|“userinterface”|“ui”|0|1|2|3)
[source]

class `SoundDeviceSpec`

Contains data about a sound device.

[source]

field `name`

is string

alias `StorageName`

is (“metalStorage”|“energyStorage”|“ms”|“es”)

class `StrafeAirMoveType`

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer
cmdID: integer
cmdParams: number[]
cmdOptions: CommandOptions
cmdTag: number

Returns

whether: boolean --to remove the command from the queue

method `AllowCommand (unitID, unitDefID, unitTeam, cmdID, cmdParams, cmdOptions, cmdTag, synced, fromLua) -> whether`

method `AllowUnitTransportUnload (transporterID, transporterUnitDefID, transporterTeam, transporteeID, transporteeUnitDefID, transporteeTeam, x, y, z) -> whether`

[source]

unitID: integer
targetID: integer

Returns

whether: boolean --unit is allowed to selfd

method `AllowFeatureCreation (featureDefID, teamID, x, y, z) -> whether`

Called just before feature is created.

[source]

Params

featureDefID: integer
teamID: integer
x: number
y: number
z: number

Returns

whether: boolean --or not the creation is permitted

method `AllowFeatureBuildStep (builderID, builderTeam, featureID, featureDefID, part) -> whether`

method `AllowStartPosition (playerID, teamID, readyState, clampedX, clampedY, clampedZ, rawX, rawY, rawZ) -> allow`

Whether a start position should be allowed

[source]

clamped{X,Y,Z} are the coordinates clamped into start-boxes, raw is where player tried to place their marker.

The readyState can be any one of:

0 - player picked a position, 1 - player clicked ready, 2 - player pressed ready OR the game was force-started (player did not click ready, but is now forcibly readied) or 3 - the player failed to load. The default ‘failed to choose’ start-position is the north-west point of their startbox, or (0,0,0) if they do not have a startbox.

Params

playerID: integer
teamID: integer
readyState: number
clampedX: number
clampedY: number
clampedZ: number
rawX: number
rawY: number
rawZ: number

Returns

allow: boolean

method `MoveCtrlNotify (unitID, unitDefID, unitTeam, data) -> whether`

Enable both Spring.MoveCtrl.SetCollideStop and Spring.MoveCtrl.SetTrackGround to enable this call-in.

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer

data: number --was supposed to indicate the type of notification but currently never has a value other than 1 ("unit hit the ground").

Returns

whether: boolean --or not the unit should remain script-controlled (false) or return to engine controlled movement (true).

method `TerraformComplete (unitID, unitDefID, unitTeam, buildUnitID, buildUnitDefID, buildUnitTeam) -> if`

Called when pre-building terrain levelling terraforms are completed (c.f. levelGround)

[source]

Params

unitID: integer
unitDefID: integer
unitTeam: integer
buildUnitID: integer
buildUnitDefID: integer
buildUnitTeam: integer

Returns

if: boolean --true the current build order is terminated

method `UnitPreDamaged (unitID, unitDefID, unitTeam, damage, paralyzer, weaponDefID, projectileID, attackerID, attackerDefID, attackerTeam) -> newDamage, impulseMult`

method `AllowWeaponTargetCheck (attackerID, attackerWeaponNum, attackerWeaponDefID) -> allowCheck, ignoreCheck`

Determines if this weapon can automatically generate targets itself. See also commandFire weaponDef tag.

[source]

Only called for weaponDefIDs registered via Script.SetWatchAllowTarget or Script.SetWatchWeapon.

See: Script.SetWatchAllowTarget Script.SetWatchWeapon

Params

attackerID: integer
attackerWeaponNum: integer
attackerWeaponDefID: integer

Returns

allowCheck: boolean
ignoreCheck: boolean

method `AllowWeaponTarget (attackerID, targetID, attackerWeaponNum, attackerWeaponDefID, defPriority) -> allowed, the`

Controls blocking of a specific target from being considered during a weapon’s periodic auto-targeting sweep.

[source]

Only called for weaponDefIDs registered via Script.SetWatchAllowTarget or Script.SetWatchWeapon.

See: Script.SetWatchAllowTarget Script.SetWatchWeapon

Params

attackerID: integer
targetID: integer
attackerWeaponNum: integer
attackerWeaponDefID: integer
defPriority: number

Returns

allowed: boolean

the: number --new priority for this target (if you don't want to change it, return defPriority). Lower priority targets are targeted first.

method `AllowWeaponInterceptTarget (interceptorUnitID, interceptorWeaponID, targetProjectileID) -> allowed`

Controls blocking of a specific intercept target from being considered during an interceptor weapon’s periodic auto-targeting sweep.

[source]

Only called for weaponDefIDs registered via Script.SetWatchAllowTarget or Script.SetWatchWeapon.

See: Script.SetWatchAllowTarget Script.SetWatchWeapon

Params

interceptorUnitID: integer
interceptorWeaponID: integer
targetProjectileID: integer

Returns

allowed: boolean

fn `SendToUnsynced (...)`

Invoke UnsyncedCallins:RecvFromSynced callin with the given arguments.

[source]

See: UnsyncedCallins:RecvFromSynced

Params

...: (boolean|number|string|table)? --Arguments. Typically the first argument is the name of a function to call.
Argument tables will be recursively copied and stripped of unsupported types and metatables.

field `target`

is GL

class `UI`

inherits from `Callins`

[source]
See: Callins

method `ConfigureLayout ()`

[source]

alias `UniformArrayType`

is (1|2|3)
[source]

class `UniformParam`

inherits from `{ [string]: (T|T[]) }`

A table of uniform name to value.

The Uniforms are the values you send along with the shader-program. To use them in the shader-program declare them like this: uniform float frame;

Specify a Lua array to initialize GLSL arrays.

The engine will automatically fill in an appropriately named uniform for team colour if it is declared;

uniform vec4 teamColor;

Specify the kind of VBO you will be using.

terrainVertexVBO:Define(numPoints, {{ id = 0, name = "pos", size = 2 }})

It is usually an array of vertex/color/uv data, but can also be an array of instance uniforms.

If you want to specify multiple instances of something to render, you will need to create another VBO, which also specifies the number of instances you wish to render, and the size of the data passed to each instance.

If you want say 5 elements, and each element is defined in the layout:

{id = 0, name = "first", size = 1},{id = 1, name = "second", size = 2}}

Then the total size of your VBO will be 5 * (1 + 2).

They will be laid out consecutively: [1,2],[1,2],[1,2],[1,2],[1,2].

attributeIndex: integer? --(Default: `-1`) when supplied with non-default value: only data
from specified attribute will be downloaded - otherwise all attributes are
downloaded

elementOffset: integer? --(Default: `0`) download data starting from this element
elementCount: number? --number of elements to download

forceGPURead: boolean? --(Default: `false`) force downloading the data from GPU buffer as opposed
to using shadow RAM buffer

Returns

: unknown

method `ModelsVBO () -> buffer`

Binds engine side vertex or index VBO containing models (units, features) data.

[source]

Also fills in VBO definition data as they’re set for engine models (no need to do VBO:Define()).

Returns

buffer: number? --size in bytes

method `InstanceDataFromUnitDefIDs (unitDefIDs, attrID, teamIdOpt, elementOffset) -> instanceData, elementOffset, attrID`

Fills in attribute data for each specified unitDefID

[source]

The instance data in that attribute will contain the offset to bind position matrix in global matrices SSBO and offset to uniform buffer structure in global per unit/feature uniform SSBO (unused for Unit/FeatureDefs), as well as some auxiliary data ushc as draw flags and team index.

Data Layout:

SInstanceData:
   , traOffset{ matOffset_ }            // updated during the following draw frames
   , uniOffset{ uniOffset_ }            // updated during the following draw frames
   , info{ teamIndex, drawFlags, 0, 0 } // not updated during the following draw frames
   , aux1 { 0u }

Params

unitDefIDs: (number|number[])
attrID: integer
teamIdOpt: integer?
elementOffset: integer?

Returns

instanceData: (number,number,number,number)
elementOffset: integer
attrID: integer

method `InstanceDataFromFeatureDefIDs (featureDefIDs, attrID, teamIdOpt, elementOffset) -> instanceData, elementOffset, attrID`

Fills in attribute data for each specified featureDefID

[source]

Data Layout

SInstanceData:
   , traOffset{ matOffset_ }            // updated during the following draw frames
   , uniOffset{ uniOffset_ }            // updated during the following draw frames
   , info{ teamIndex, drawFlags, 0, 0 } // not updated during the following draw frames
   , aux1 { 0u }

Params

featureDefIDs: (number|number[])
attrID: integer
teamIdOpt: integer?
elementOffset: integer?

Returns

instanceData: (number,number,number,number)
elementOffset: integer
attrID: integer

method `InstanceDataFromUnitIDs (unitIDs, attrID, teamIdOpt, elementOffset) -> instanceData, elementOffset, attrID`

Fills in attribute data for each specified unitID

[source]

Data Layout

SInstanceData:
   , traOffset{ matOffset_ }            // updated during the following draw frames
   , uniOffset{ uniOffset_ }            // updated during the following draw frames
   , info{ teamIndex, drawFlags, 0, 0 } // not updated during the following draw frames
   , aux1 { 0u }

Params

unitIDs: (number|number[])
attrID: integer
teamIdOpt: integer?
elementOffset: integer?

Returns

instanceData: (number,number,number,number)
elementOffset: integer
attrID: integer

method `InstanceDataFromFeatureIDs (featureIDs, attrID, teamIdOpt, elementOffset) -> instanceData, elementOffset, attrID`

Fills in attribute data for each specified featureID

[source]

Params

featureIDs: (number|number[])
attrID: integer
teamIdOpt: integer?
elementOffset: integer?

Returns

instanceData: (number,number,number,number)
elementOffset: integer
attrID: integer

method `MatrixDataFromProjectileIDs (projectileIDs, attrID, teamIdOpt, elementOffset) -> matDataVec, elemOffset, attrID`

[source]

Params

projectileIDs: (integer|integer[])
attrID: integer
teamIdOpt: integer?
elementOffset: integer?

Returns

matDataVec: number[] --4x4 matrix
elemOffset: integer
attrID: (integer|(integer,integer…))

method `BindBufferRange (index, elementOffset, elementCount, target) -> bindingIndex`

Bind a range within a buffer object to an indexed buffer target

[source]

Generally mimics https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBindBufferRange.xhtml except offset and size are specified in number of elements / element indices.

Params

index: integer --should be in the range between
`5 < index < GL_MAX_UNIFORM_BUFFER_BINDINGS` value (usually 31)

elementOffset: integer?
elementCount: number?
target: number? --glEnum

Returns

bindingIndex: integer --when successful, -1 otherwise

method `UnbindBufferRange (index, elementOffset, elementCount, target) -> bindingIndex`

[source]

Params

index: integer
elementOffset: integer?
elementCount: number?
target: number? --glEnum

Returns

bindingIndex: number --when successful, -1 otherwise

method `DumpDefinition () ->`

Logs the definition of the VBO to the console

[source]

Returns

: nil

method `CopyTo (destVBO, copySizeInBytes) -> success`

Accepts the following:

GL.BYTE
GL.UNSIGNED_BYTE
GL.SHORT
GL.UNSIGNED_SHORT
GL.INT
GL.UNSIGNED_INT
GL.FLOAT

field `normalized`

is boolean?

(Defaults: false)

It’s possible to submit normals without normalizing them first, normalized will make sure data is normalized.

class `VertexData`

[source]

field `vert`

is xyz?

field `v`

is xyz?
Short for vert.

field `norm`

is float3?

field `n`

is float3?
Short for norm.

field `texcoord`

is float2?

field `t`

is float2?
Short for texcoord.

field `color`

is float4?

field `c`

is float4?
Short for color.

class `WaterParams`

field `[4]`

is number
w

class `xz`

[source]

field `x`

is number

field `y`

is number

Lua API Reference

Globals

field COBSCALE

table Encoding

fn DecodeBase64 (text) -> decoded

Params

Returns

fn EncodeBase64 (text, stripPadding) -> encoded

Params

Returns

fn IsValidBase64 (text) -> valid

Params

Returns

fn DecodeBase64Url (text) -> decoded

Params

Returns

fn EncodeBase64Url (text) -> encoded

Params

Returns

fn IsValidBase64Url (text) -> valid

Params

Returns

table Engine

field version

field versionFull

field versionMajor

field versionMinor

field versionPatchSet

field commitsNumber

field buildFlags

field featureSupport

field wordSize

field gameSpeed

field textColorCodes

table Game

field maxUnits

field maxTeams

field maxPlayers

field squareSize

field metalMapSquareSize

field gameSpeed

field startPosType

field ghostedBuildings

field mapChecksum

field modChecksum

field mapDamage

field mapName

field mapDescription

field mapHardness

field mapX

field mapY

field mapSizeX

field mapSizeZ

field gravity

field tidal

field windMin

field windMax

field extractorRadius

field waterDamage

field envDamageTypes

field gameName

field gameShortName

field gameVersion

field gameMutator

field gameDesc

field requireSonarUnderWater

field transportAir

field transportShip

field transportHover

field transportGround

field fireAtKilled

field fireAtCrashing

field constructionDecay

field reclaimAllowEnemies

field reclaimAllowAllies

field constructionDecayTime

field constructionDecaySpeed

field multiReclaim

field reclaimMethod

field reclaimUnitMethod

field `COBSCALE`

table `Encoding`

fn `DecodeBase64 (text) -> decoded`

fn `EncodeBase64 (text, stripPadding) -> encoded`

fn `IsValidBase64 (text) -> valid`

fn `DecodeBase64Url (text) -> decoded`

fn `EncodeBase64Url (text) -> encoded`

fn `IsValidBase64Url (text) -> valid`

table `Engine`

field `version`

field `versionFull`

field `versionMajor`

field `versionMinor`

field `versionPatchSet`

field `commitsNumber`

field `buildFlags`

field `featureSupport`

field `wordSize`

field `gameSpeed`

field `textColorCodes`

table `Game`

field `maxUnits`

field `maxTeams`

field `maxPlayers`

field `squareSize`

field `metalMapSquareSize`

field `gameSpeed`

field `startPosType`

field `ghostedBuildings`

field `mapChecksum`

field `modChecksum`

field `mapDamage`

field `mapName`

field `mapDescription`

field `mapHardness`

field `mapX`

field `mapY`

field `mapSizeX`

field `mapSizeZ`

field `gravity`

field `tidal`

field `windMin`

field `windMax`

field `extractorRadius`

field `waterDamage`

field `envDamageTypes`

field `gameName`

field `gameShortName`

field `gameVersion`

field `gameMutator`

field `gameDesc`

field `requireSonarUnderWater`

field `transportAir`

field `transportShip`

field `transportHover`

field `transportGround`

field `fireAtKilled`

field `fireAtCrashing`

field `constructionDecay`

field `reclaimAllowEnemies`

field `reclaimAllowAllies`

field `constructionDecayTime`

field `constructionDecaySpeed`

field `multiReclaim`

field `reclaimMethod`

field `reclaimUnitMethod`

field `reclaimUnitEnergyCostFactor`

field `reclaimUnitEfficiency`

field `reclaimFeatureEnergyCostFactor`

field `repairEnergyCostFactor`

field `resurrectEnergyCostFactor`

field `captureEnergyCostFactor`

field `springCategories`

field `armorTypes`

field `textColorCodes`

table `gl`

fn `AddFallbackFont (filePath) -> success`

fn `ClearFallbackFonts () ->`

fn `GetVAO () -> vao`

fn `CreateFBO (fboDesc) -> fbo`