aego/tests/integration/testdata/bindings.aetext

manifest version=6 {
  abi="5a92183858aa1a9364dd32952195e01356d16a6480c58ff6fb53252869e2abea"
  module "aego/action" {
    func "Parallel" {
      params=[]
      result="Handle<aego/action.Action>"
      doc="Parallel makes an action that runs all its steps at once and ends after the last one."
    }
    func "Sequence" {
      params=[]
      result="Handle<aego/action.Action>"
      doc="Sequence makes an action that runs its steps one after another, starting at the next tween update."
      example="yield action.Sequence().Then(tween.Position(node, Vec2{4, 0}, 0.5, curve.OutCubic)).Wait(0.2).Then(tween.ToFloat(node, \"SpriteRenderer.Tint.a\", 0, 0.3, curve.Linear))"
    }
  }
  module "aego/anim" {
    func "EventID" {
      params=["string"]
      result="int"
      names=["name"]
      doc="EventID returns the id of an event declared in Project Settings → Animation, or -1."
      example="hit := anim.EventID(\"Hit\")"
    }
    func "EventName" {
      params=["int"]
      result="string"
      names=["id"]
      doc="EventName returns the name of an animation event, or an empty string for an unknown id."
      example="func OnAnimEvent(id int, payload float) {\n\tif anim.EventName(id) == \"Hit\" {"
    }
    func "ParamIndex" {
      params=["AssetRef<animctrl>", "string"]
      result="int"
      names=["controller", "name"]
      doc="ParamIndex returns the index of a parameter of a controller, or -1."
    }
    func "StateName" {
      params=["AssetRef<animctrl>", "int"]
      result="string"
      names=["controller", "index"]
      doc="StateName returns the name of a state of a controller, or an empty string."
    }
  }
  module "aego/audio" {
    func "Builtin" {
      params=["string"]
      result="AssetRef<audio>"
      names=["name"]
      doc="Builtin returns a clip that ships with the engine: Beep, Click, Hum (loopable) or Melody (loopable)."
      example="audio.Play(audio.Builtin(\"Beep\"))"
    }
    func "BusVolume" {
      params=["enum:aego/audio.Bus"]
      result="float"
      names=["bus"]
      doc="BusVolume returns the session volume of a bus set by SetBusVolume; the player's settings are separate."
    }
    func "Music" {
      params=["AssetRef<audio>", "float"]
      result="Handle<aego/audio.Sound>"
      names=["clip", "seconds"]
      doc="Music loops a clip on the music bus, crossfading from the music that played over seconds."
      example="audio.Music(Theme, 1.5)"
    }
    func "Mute" {
      params=["enum:aego/audio.Bus", "bool"]
      result="void"
      names=["bus", "on"]
      doc="Mute silences a bus for this session."
    }
    func "Pause" {
      params=["bool"]
      result="void"
      names=["on"]
      doc="Pause pauses or resumes every sound of this world."
    }
    func "Play" {
      params=["AssetRef<audio>"]
      result="Handle<aego/audio.Sound>"
      names=["clip"]
      doc="Play plays a clip on its bus. The sound stops when the node of the script is destroyed."
      example="audio.Play(Coin)"
    }
    func "PlayAt" {
      params=["AssetRef<audio>", "Vec2"]
      result="Handle<aego/audio.Sound>"
      names=["clip", "position"]
      doc="PlayAt plays a clip at a world position, fading and panning with the distance to the listener."
    }
    func "PlayEvent" {
      params=["AssetRef<data:AudioEvent>"]
      result="Handle<aego/audio.Sound>"
      names=["event"]
      doc="PlayEvent plays an audio event; a spatial event follows the node of the script."
      example="audio.PlayEvent(Jump)"
    }
    func "PlayEventAt" {
      params=["AssetRef<data:AudioEvent>", "Vec2"]
      result="Handle<aego/audio.Sound>"
      names=["event", "position"]
      doc="PlayEventAt plays an audio event at a world position."
    }
    func "PlayWith" {
      params=["AssetRef<audio>", "struct:aego/audio.PlayOptions"]
      result="Handle<aego/audio.Sound>"
      names=["clip", "options"]
      doc="PlayWith plays a clip with options."
      example="audio.PlayWith(Step, audio.PlayOptions{Volume: 0.5, Pitch: 1.1})"
    }
    func "SetBusVolume" {
      params=["enum:aego/audio.Bus", "float"]
      result="void"
      names=["bus", "volume"]
      doc="SetBusVolume sets the session volume of a bus, on top of the player's settings; it is not saved."
    }
    func "StopMusic" {
      params=["float"]
      result="void"
      names=["seconds"]
      doc="StopMusic fades the music out over seconds."
    }
  }
  module "aego/camera" {
    func "Active" {
      params=[]
      result="NodeRef"
      doc="Active returns the virtual camera that drives the main output, or nil."
    }
    func "ActiveOn" {
      params=["string"]
      result="NodeRef"
      names=["output"]
      doc="ActiveOn returns the virtual camera that drives the named output."
    }
    func "BlendTo" {
      params=["NodeRef", "float"]
      result="Handle<aego/camera.Blend>"
      names=["camera", "seconds"]
      doc="BlendTo makes vc active over priorities and blends to it; seconds 0 uses its Blend Time. Release hands control back to priorities."
      example="yield camera.BlendTo(BossCam, 1.5)"
    }
    func "Cut" {
      params=["NodeRef"]
      result="void"
      names=["camera"]
      doc="Cut makes vc active at once, without a blend."
    }
    func "LogicalPose" {
      params=[]
      result="struct:aego/camera.Pose"
      doc="LogicalPose returns the pose of the main output without shake and pixel snapping."
    }
    func "Release" {
      params=["float"]
      result="Handle<aego/camera.Blend>"
      names=["seconds"]
      doc="Release ends BlendTo or Cut on the main output; priorities decide again, blending over seconds or the camera's Blend Time."
    }
    func "RenderPose" {
      params=[]
      result="struct:aego/camera.Pose"
      doc="RenderPose returns the pose the main output was drawn with in the last frame."
    }
    func "ScreenToWorld" {
      params=["Vec2"]
      result="Vec2"
      names=["point"]
      doc="ScreenToWorld converts output pixels to world units with the last drawn view of the main output."
    }
    func "Shake" {
      params=["float"]
      result="void"
      names=["trauma"]
      doc="Shake adds trauma to the main output; shake grows with trauma, which is capped at 1 and fades over time."
      example="camera.Shake(0.4)"
    }
    func "ShakeOn" {
      params=["string", "float"]
      result="void"
      names=["output", "trauma"]
      doc="ShakeOn adds trauma to the named output."
    }
    func "Trauma" {
      params=[]
      result="float"
      doc="Trauma returns the current trauma of the main output, 0 to 1."
    }
    func "WorldToScreen" {
      params=["Vec2"]
      result="Vec2"
      names=["point"]
      doc="WorldToScreen converts world units to output pixels with the last drawn view of the main output."
    }
  }
  module "aego/curve" {
    func "Duration" {
      params=["Curve"]
      result="float"
      names=["curve"]
      doc="Duration returns the time between the first and the last key, 1 for a preset."
      example="t := age / curve.Duration(fade)"
    }
    func "Ease" {
      params=["enum:aego/curve.Easing", "float"]
      result="float"
      names=["easing", "t"]
      doc="Ease returns a preset easing at t, clamped to 0..1."
      example="x := math.Lerp(a, b, curve.Ease(curve.OutCubic, k))"
    }
    func "Eval" {
      params=["Curve", "float"]
      result="float"
      names=["curve", "t"]
      doc="Eval returns the value of a curve at time t; outside its keys the curve repeats as its Before and After settings say."
      example="speed := Speed * curve.Eval(node.Get<Mover>().Accel, elapsed)"
    }
    func "EvalClamped" {
      params=["Curve", "float"]
      result="float"
      names=["curve", "t"]
      doc="EvalClamped returns the value at t clamped to the first and last key."
      example="k := curve.EvalClamped(fade, age)"
    }
    const "InBack" {
      type="enum:aego/curve.Easing"
      int=14
      float=0
      bool=false
      str=""
      doc="InBack pulls back past the start before it moves, like a wind-up."
    }
    const "InBounce" {
      type="enum:aego/curve.Easing"
      int=20
      float=0
      bool=false
      str=""
      doc="InBounce bounces off the start with growing hops before it goes."
    }
    const "InCubic" {
      type="enum:aego/curve.Easing"
      int=5
      float=0
      bool=false
      str=""
      doc="InCubic starts slowly and speeds up, more strongly than InQuad."
    }
    const "InElastic" {
      type="enum:aego/curve.Easing"
      int=17
      float=0
      bool=false
      str=""
      doc="InElastic wobbles around the start with growing swings, then springs to the end."
    }
    const "InExpo" {
      type="enum:aego/curve.Easing"
      int=11
      float=0
      bool=false
      str=""
      doc="InExpo barely moves at first, then covers nearly all the way at the end."
    }
    const "InOutBack" {
      type="enum:aego/curve.Easing"
      int=16
      float=0
      bool=false
      str=""
      doc="InOutBack pulls back past the start and goes past the end before it settles."
    }
    const "InOutBounce" {
      type="enum:aego/curve.Easing"
      int=22
      float=0
      bool=false
      str=""
      doc="InOutBounce bounces off the start and bounces on the end."
    }
    const "InOutCubic" {
      type="enum:aego/curve.Easing"
      int=7
      float=0
      bool=false
      str=""
      doc="InOutCubic is slow at both ends and fast in the middle, more strongly than InOutQuad."
    }
    const "InOutElastic" {
      type="enum:aego/curve.Easing"
      int=19
      float=0
      bool=false
      str=""
      doc="InOutElastic wobbles around both the start and the end."
    }
    const "InOutExpo" {
      type="enum:aego/curve.Easing"
      int=13
      float=0
      bool=false
      str=""
      doc="InOutExpo waits at the start, rushes through the middle and creeps to the end."
    }
    const "InOutQuad" {
      type="enum:aego/curve.Easing"
      int=4
      float=0
      bool=false
      str=""
      doc="InOutQuad is slow at both ends and fastest in the middle, gently: for moves between two rest positions."
    }
    const "InOutSine" {
      type="enum:aego/curve.Easing"
      int=10
      float=0
      bool=false
      str=""
      doc="InOutSine is slow at both ends, the softest of the curves: for breathing, bobbing and fades."
    }
    const "InQuad" {
      type="enum:aego/curve.Easing"
      int=2
      float=0
      bool=false
      str=""
      doc="InQuad starts slowly and speeds up, gently: for things that set off, such as a door starting to open."
    }
    const "InSine" {
      type="enum:aego/curve.Easing"
      int=8
      float=0
      bool=false
      str=""
      doc="InSine starts slowly and speeds up, the softest of the curves."
    }
    const "Linear" {
      type="enum:aego/curve.Easing"
      int=1
      float=0
      bool=false
      str=""
      doc="Linear moves at a constant speed from start to end."
    }
    const "OutBack" {
      type="enum:aego/curve.Easing"
      int=15
      float=0
      bool=false
      str=""
      doc="OutBack goes past the end and settles back: for a pop or a bounce-in."
    }
    const "OutBounce" {
      type="enum:aego/curve.Easing"
      int=21
      float=0
      bool=false
      str=""
      doc="OutBounce reaches the end and bounces on it like a dropped ball."
    }
    const "OutCubic" {
      type="enum:aego/curve.Easing"
      int=6
      float=0
      bool=false
      str=""
      doc="OutCubic starts fast and slows down to the end, more strongly than OutQuad."
    }
    const "OutElastic" {
      type="enum:aego/curve.Easing"
      int=18
      float=0
      bool=false
      str=""
      doc="OutElastic springs past the end and wobbles around it as it settles, like a spring."
    }
    const "OutExpo" {
      type="enum:aego/curve.Easing"
      int=12
      float=0
      bool=false
      str=""
      doc="OutExpo covers nearly all the way at once, then creeps to the end: for snappy UI."
    }
    const "OutQuad" {
      type="enum:aego/curve.Easing"
      int=3
      float=0
      bool=false
      str=""
      doc="OutQuad starts fast and slows down gently to the end: the usual choice for UI that slides in."
    }
    const "OutSine" {
      type="enum:aego/curve.Easing"
      int=9
      float=0
      bool=false
      str=""
      doc="OutSine starts fast and slows down to the end, the softest of the curves."
    }
  }
  module "aego/data" {}
  module "aego/debug" {
    func "Arrow" {
      params=["Vec2", "Vec2", "Color"]
      result="void"
      names=["from", "to", "color"]
      doc="Arrow draws an arrow from one point to another."
      example="debug.Arrow(p, p + body.Velocity * 0.2, Color{0, 1, 0, 1})"
    }
    func "Circle" {
      params=["Vec2", "float", "Color"]
      result="void"
      names=["center", "radius", "color"]
      doc="Circle draws a circle outline with radius r in world units."
      example="debug.Circle(node.WorldPosition(), SightRange, Color{0, 0.6, 1, 1})"
    }
    func "Clear" {
      params=["string"]
      result="void"
      names=["channel"]
      doc="Clear removes every primitive whose channel starts with prefix."
      example="debug.Clear(\"ai\")"
    }
    func "Cross" {
      params=["Vec2", "float", "Color"]
      result="void"
      names=["p", "size", "color"]
      doc="Cross draws a cross of the given size in world units."
      example="debug.Cross(goal, 0.5, Color{1, 0, 1, 1})"
    }
    func "Line" {
      params=["Vec2", "Vec2", "Color"]
      result="void"
      names=["a", "b", "color"]
      doc="Line draws a line in world units. It lasts one frame unless Pen sets a lifetime."
      example="debug.Line(node.WorldPosition(), Target.WorldPosition(), Color{1, 0, 0, 1})"
    }
    func "Pen" {
      params=["string", "float"]
      result="void"
      names=["channel", "ttl"]
      doc="Pen sets the channel and the lifetime of the next primitives this script draws. A ttl of 0 lasts one frame, a positive ttl that many game seconds, a negative ttl until Clear."
      example="debug.Pen(\"ai.path\", 2)"
    }
    func "PenUnscaled" {
      params=["string", "float"]
      result="void"
      names=["channel", "ttl"]
      doc="PenUnscaled is Pen with a lifetime in real seconds; such primitives fade out while the game is paused."
      example="debug.PenUnscaled(\"ui\", 1)"
    }
    func "Point" {
      params=["Vec2", "Color"]
      result="void"
      names=["p", "color"]
      doc="Point marks a point with a small cross of constant screen size."
      example="debug.Point(hit.Point, Color{1, 0, 0, 1})"
    }
    func "Ray" {
      params=["Vec2", "Vec2", "Color"]
      result="void"
      names=["origin", "dir", "color"]
      doc="Ray draws an arrow from origin along dir; the length of dir is the length of the arrow."
      example="debug.Ray(node.WorldPosition(), Vec2{0, 2}, Color{1, 1, 0, 1})"
    }
    func "Rect" {
      params=["Rect", "Color"]
      result="void"
      names=["rect", "color"]
      doc="Rect draws a rectangle outline."
      example="debug.Rect(Rect{0, 0, 4, 2}, Color{1, 1, 1, 1})"
    }
    func "Text" {
      params=["Vec2", "string", "Color"]
      result="void"
      names=["p", "text", "color"]
      doc="Text draws a label at a world position; it keeps its screen size at any zoom."
      example="debug.Text(node.WorldPosition(), string(state), Color{1, 1, 1, 1})"
    }
  }
  module "aego/input" {
    func "ActiveDevice" {
      params=[]
      result="int"
      doc="ActiveDevice returns the device player 0 used last: -1 none, 0 keyboard and mouse, 1 to 4 a gamepad."
      example="onPad := input.ActiveDevice() > 0"
    }
    func "Axis" {
      params=["string"]
      result="float"
      names=["action"]
      doc="Axis returns the value of an axis action from -1 to 1, or the press strength of a button action."
      example="x := input.Axis(\"Move\")"
    }
    func "Axis2" {
      params=["string"]
      result="Vec2"
      names=["action"]
      doc="Axis2 returns a 2D action as a vector no longer than 1; Y grows downward like the 2D world."
      example="v := input.Axis2(\"Move\") * Speed"
    }
    func "Axis2P" {
      params=["int", "string"]
      result="Vec2"
      names=["player", "action"]
      doc="Axis2P is Axis2 for one player."
      example="v := input.Axis2P(1, \"Move\")"
    }
    func "AxisP" {
      params=["int", "string"]
      result="float"
      names=["player", "action"]
      doc="AxisP is Axis for one player."
      example="x := input.AxisP(1, \"Move\")"
    }
    func "BeginRebind" {
      params=["string", "int"]
      result="bool"
      names=["action", "slot"]
      doc="BeginRebind waits for the next key, button or stick and binds it to the slot of the action. Escape cancels."
      example="input.BeginRebind(\"Jump\", 0)"
    }
    func "Buffered" {
      params=["string", "float"]
      result="bool"
      names=["action", "window"]
      doc="Buffered reports whether the action was pressed in the last window game seconds and not consumed. A window of 0 uses the action's buffer setting."
      example="if grounded && input.Buffered(\"Jump\", 0) {\n\tinput.Consume(\"Jump\")\n}"
    }
    func "Consume" {
      params=["string"]
      result="void"
      names=["action"]
      doc="Consume clears the press and the buffer of the action, so later readers this frame do not see it."
      example="input.Consume(\"Jump\")"
    }
    func "DeviceChanged" {
      params=[]
      result="bool"
      doc="DeviceChanged is true for the frame a gamepad was connected or removed."
      example="if input.DeviceChanged() {"
    }
    func "Down" {
      params=["enum:aego/input.Key"]
      result="bool"
      names=["key"]
      doc="Down reports whether a raw key is held. For prototypes; release builds use actions."
      example="if input.Down(input.KeyShift) {"
    }
    func "Glyph" {
      params=["string"]
      result="string"
      names=["action"]
      doc="Glyph returns the binding of the action for the active device as text, like [Space] or [A]."
      example="hint.Text = \"Jump \" + input.Glyph(\"Jump\")"
    }
    func "Held" {
      params=["string"]
      result="bool"
      names=["action"]
      doc="Held reports whether the action is active."
      example="if input.Held(\"Run\") {"
    }
    func "HeldP" {
      params=["int", "string"]
      result="bool"
      names=["player", "action"]
      doc="HeldP is Held for one player."
      example="if input.HeldP(1, \"Run\") {"
    }
    func "KeyPressed" {
      params=["enum:aego/input.Key"]
      result="bool"
      names=["key"]
      doc="KeyPressed reports whether a raw key went down this frame. For prototypes."
      example="if input.KeyPressed(input.KeyF5) {"
    }
    func "KeyReleased" {
      params=["enum:aego/input.Key"]
      result="bool"
      names=["key"]
      doc="KeyReleased reports whether a raw key went up this frame. For prototypes."
      example="if input.KeyReleased(input.KeySpace) {"
    }
    func "MouseDown" {
      params=["enum:aego/input.Button"]
      result="bool"
      names=["button"]
      doc="MouseDown reports whether a mouse button is held."
      example="if input.MouseDown(input.MouseLeft) {"
    }
    func "MousePos" {
      params=[]
      result="Vec2"
      doc="MousePos returns the cursor in logical pixels of the game area."
      example="p := input.MousePos()"
    }
    func "MousePressed" {
      params=["enum:aego/input.Button"]
      result="bool"
      names=["button"]
      doc="MousePressed reports whether a mouse button went down this frame."
      example="if input.MousePressed(input.MouseRight) {"
    }
    func "MouseWorld" {
      params=[]
      result="Vec2"
      doc="MouseWorld returns the cursor in world units through the camera under it."
      example="target := input.MouseWorld()"
    }
    func "Pointer" {
      params=[]
      result="Vec2"
      doc="Pointer returns the cursor in logical pixels."
      example="p := input.Pointer()"
    }
    func "PointerDelta" {
      params=[]
      result="Vec2"
      doc="PointerDelta returns how far the cursor moved this frame."
      example="look += input.PointerDelta()"
    }
    func "PopContext" {
      params=[]
      result="void"
      doc="PopContext removes the top input context."
      example="input.PopContext()"
    }
    func "Pressed" {
      params=["string"]
      result="bool"
      names=["action"]
      doc="Pressed reports whether the action started. In Update it is true for one frame; in FixedUpdate for the first fixed step after the press."
      example="if input.Pressed(\"Attack\") {"
    }
    func "PressedP" {
      params=["int", "string"]
      result="bool"
      names=["player", "action"]
      doc="PressedP is Pressed for one player."
      example="if input.PressedP(1, \"Jump\") {"
    }
    func "PushContext" {
      params=["string"]
      result="void"
      names=["context"]
      doc="PushContext puts an input context on top of the stack."
      example="input.PushContext(\"Menu\")"
    }
    func "RebindConflict" {
      params=[]
      result="string"
      doc="RebindConflict names the action that already used the new control, or explains why it was refused."
      example="if input.RebindConflict() != \"\" {"
    }
    func "Rebinding" {
      params=[]
      result="bool"
      doc="Rebinding reports whether a rebind waits for input."
      example="if input.Rebinding() {"
    }
    func "Released" {
      params=["string"]
      result="bool"
      names=["action"]
      doc="Released reports whether the action ended this frame or fixed step."
      example="if input.Released(\"Jump\") {"
    }
    func "ReleasedP" {
      params=["int", "string"]
      result="bool"
      names=["player", "action"]
      doc="ReleasedP is Released for one player."
      example="if input.ReleasedP(1, \"Jump\") {"
    }
    func "ResetBinding" {
      params=["string"]
      result="void"
      names=["action"]
      doc="ResetBinding restores the project bindings of the action."
      example="input.ResetBinding(\"Jump\")"
    }
    func "ResetBindings" {
      params=[]
      result="void"
      doc="ResetBindings restores every project binding."
      example="input.ResetBindings()"
    }
    func "SaveBindings" {
      params=[]
      result="void"
      doc="SaveBindings writes the player's settings profile now; changes are also saved on their own."
      example="input.SaveBindings()"
    }
    func "SetContext" {
      params=["string"]
      result="void"
      names=["context"]
      doc="SetContext replaces the whole stack with one context."
      example="input.SetContext(\"Gameplay\")"
    }
    const "KeyA" {
      type="enum:aego/input.Key"
      int=4
      float=0
      bool=false
      str=""
      doc="The A key."
    }
    const "KeyB" {
      type="enum:aego/input.Key"
      int=5
      float=0
      bool=false
      str=""
      doc="The B key."
    }
    const "KeyBackspace" {
      type="enum:aego/input.Key"
      int=42
      float=0
      bool=false
      str=""
      doc="The Backspace key."
    }
    const "KeyC" {
      type="enum:aego/input.Key"
      int=6
      float=0
      bool=false
      str=""
      doc="The C key."
    }
    const "KeyCapsLock" {
      type="enum:aego/input.Key"
      int=57
      float=0
      bool=false
      str=""
      doc="The CapsLock key."
    }
    const "KeyD" {
      type="enum:aego/input.Key"
      int=7
      float=0
      bool=false
      str=""
      doc="The D key."
    }
    const "KeyDelete" {
      type="enum:aego/input.Key"
      int=76
      float=0
      bool=false
      str=""
      doc="The Delete key."
    }
    const "KeyDigit0" {
      type="enum:aego/input.Key"
      int=39
      float=0
      bool=false
      str=""
      doc="The Digit0 key."
    }
    const "KeyDigit1" {
      type="enum:aego/input.Key"
      int=30
      float=0
      bool=false
      str=""
      doc="The Digit1 key."
    }
    const "KeyDigit2" {
      type="enum:aego/input.Key"
      int=31
      float=0
      bool=false
      str=""
      doc="The Digit2 key."
    }
    const "KeyDigit3" {
      type="enum:aego/input.Key"
      int=32
      float=0
      bool=false
      str=""
      doc="The Digit3 key."
    }
    const "KeyDigit4" {
      type="enum:aego/input.Key"
      int=33
      float=0
      bool=false
      str=""
      doc="The Digit4 key."
    }
    const "KeyDigit5" {
      type="enum:aego/input.Key"
      int=34
      float=0
      bool=false
      str=""
      doc="The Digit5 key."
    }
    const "KeyDigit6" {
      type="enum:aego/input.Key"
      int=35
      float=0
      bool=false
      str=""
      doc="The Digit6 key."
    }
    const "KeyDigit7" {
      type="enum:aego/input.Key"
      int=36
      float=0
      bool=false
      str=""
      doc="The Digit7 key."
    }
    const "KeyDigit8" {
      type="enum:aego/input.Key"
      int=37
      float=0
      bool=false
      str=""
      doc="The Digit8 key."
    }
    const "KeyDigit9" {
      type="enum:aego/input.Key"
      int=38
      float=0
      bool=false
      str=""
      doc="The Digit9 key."
    }
    const "KeyDown" {
      type="enum:aego/input.Key"
      int=81
      float=0
      bool=false
      str=""
      doc="The Down key."
    }
    const "KeyE" {
      type="enum:aego/input.Key"
      int=8
      float=0
      bool=false
      str=""
      doc="The E key."
    }
    const "KeyEnd" {
      type="enum:aego/input.Key"
      int=77
      float=0
      bool=false
      str=""
      doc="The End key."
    }
    const "KeyEnter" {
      type="enum:aego/input.Key"
      int=40
      float=0
      bool=false
      str=""
      doc="The Enter key."
    }
    const "KeyEscape" {
      type="enum:aego/input.Key"
      int=41
      float=0
      bool=false
      str=""
      doc="The Escape key."
    }
    const "KeyF" {
      type="enum:aego/input.Key"
      int=9
      float=0
      bool=false
      str=""
      doc="The F key."
    }
    const "KeyF1" {
      type="enum:aego/input.Key"
      int=58
      float=0
      bool=false
      str=""
      doc="The F1 key."
    }
    const "KeyF10" {
      type="enum:aego/input.Key"
      int=67
      float=0
      bool=false
      str=""
      doc="The F10 key."
    }
    const "KeyF11" {
      type="enum:aego/input.Key"
      int=68
      float=0
      bool=false
      str=""
      doc="The F11 key."
    }
    const "KeyF12" {
      type="enum:aego/input.Key"
      int=69
      float=0
      bool=false
      str=""
      doc="The F12 key."
    }
    const "KeyF2" {
      type="enum:aego/input.Key"
      int=59
      float=0
      bool=false
      str=""
      doc="The F2 key."
    }
    const "KeyF3" {
      type="enum:aego/input.Key"
      int=60
      float=0
      bool=false
      str=""
      doc="The F3 key."
    }
    const "KeyF4" {
      type="enum:aego/input.Key"
      int=61
      float=0
      bool=false
      str=""
      doc="The F4 key."
    }
    const "KeyF5" {
      type="enum:aego/input.Key"
      int=62
      float=0
      bool=false
      str=""
      doc="The F5 key."
    }
    const "KeyF6" {
      type="enum:aego/input.Key"
      int=63
      float=0
      bool=false
      str=""
      doc="The F6 key."
    }
    const "KeyF7" {
      type="enum:aego/input.Key"
      int=64
      float=0
      bool=false
      str=""
      doc="The F7 key."
    }
    const "KeyF8" {
      type="enum:aego/input.Key"
      int=65
      float=0
      bool=false
      str=""
      doc="The F8 key."
    }
    const "KeyF9" {
      type="enum:aego/input.Key"
      int=66
      float=0
      bool=false
      str=""
      doc="The F9 key."
    }
    const "KeyG" {
      type="enum:aego/input.Key"
      int=10
      float=0
      bool=false
      str=""
      doc="The G key."
    }
    const "KeyH" {
      type="enum:aego/input.Key"
      int=11
      float=0
      bool=false
      str=""
      doc="The H key."
    }
    const "KeyHome" {
      type="enum:aego/input.Key"
      int=74
      float=0
      bool=false
      str=""
      doc="The Home key."
    }
    const "KeyI" {
      type="enum:aego/input.Key"
      int=12
      float=0
      bool=false
      str=""
      doc="The I key."
    }
    const "KeyInsert" {
      type="enum:aego/input.Key"
      int=73
      float=0
      bool=false
      str=""
      doc="The Insert key."
    }
    const "KeyJ" {
      type="enum:aego/input.Key"
      int=13
      float=0
      bool=false
      str=""
      doc="The J key."
    }
    const "KeyK" {
      type="enum:aego/input.Key"
      int=14
      float=0
      bool=false
      str=""
      doc="The K key."
    }
    const "KeyKP0" {
      type="enum:aego/input.Key"
      int=98
      float=0
      bool=false
      str=""
      doc="The KP0 key."
    }
    const "KeyKP1" {
      type="enum:aego/input.Key"
      int=89
      float=0
      bool=false
      str=""
      doc="The KP1 key."
    }
    const "KeyKP2" {
      type="enum:aego/input.Key"
      int=90
      float=0
      bool=false
      str=""
      doc="The KP2 key."
    }
    const "KeyKP3" {
      type="enum:aego/input.Key"
      int=91
      float=0
      bool=false
      str=""
      doc="The KP3 key."
    }
    const "KeyKP4" {
      type="enum:aego/input.Key"
      int=92
      float=0
      bool=false
      str=""
      doc="The KP4 key."
    }
    const "KeyKP5" {
      type="enum:aego/input.Key"
      int=93
      float=0
      bool=false
      str=""
      doc="The KP5 key."
    }
    const "KeyKP6" {
      type="enum:aego/input.Key"
      int=94
      float=0
      bool=false
      str=""
      doc="The KP6 key."
    }
    const "KeyKP7" {
      type="enum:aego/input.Key"
      int=95
      float=0
      bool=false
      str=""
      doc="The KP7 key."
    }
    const "KeyKP8" {
      type="enum:aego/input.Key"
      int=96
      float=0
      bool=false
      str=""
      doc="The KP8 key."
    }
    const "KeyKP9" {
      type="enum:aego/input.Key"
      int=97
      float=0
      bool=false
      str=""
      doc="The KP9 key."
    }
    const "KeyKPEnter" {
      type="enum:aego/input.Key"
      int=88
      float=0
      bool=false
      str=""
      doc="The KPEnter key."
    }
    const "KeyL" {
      type="enum:aego/input.Key"
      int=15
      float=0
      bool=false
      str=""
      doc="The L key."
    }
    const "KeyLAlt" {
      type="enum:aego/input.Key"
      int=226
      float=0
      bool=false
      str=""
      doc="The LAlt key."
    }
    const "KeyLCtrl" {
      type="enum:aego/input.Key"
      int=224
      float=0
      bool=false
      str=""
      doc="The LCtrl key."
    }
    const "KeyLGUI" {
      type="enum:aego/input.Key"
      int=227
      float=0
      bool=false
      str=""
      doc="The LGUI key."
    }
    const "KeyLShift" {
      type="enum:aego/input.Key"
      int=225
      float=0
      bool=false
      str=""
      doc="The LShift key."
    }
    const "KeyLeft" {
      type="enum:aego/input.Key"
      int=80
      float=0
      bool=false
      str=""
      doc="The Left key."
    }
    const "KeyM" {
      type="enum:aego/input.Key"
      int=16
      float=0
      bool=false
      str=""
      doc="The M key."
    }
    const "KeyN" {
      type="enum:aego/input.Key"
      int=17
      float=0
      bool=false
      str=""
      doc="The N key."
    }
    const "KeyNumLock" {
      type="enum:aego/input.Key"
      int=83
      float=0
      bool=false
      str=""
      doc="The NumLock key."
    }
    const "KeyO" {
      type="enum:aego/input.Key"
      int=18
      float=0
      bool=false
      str=""
      doc="The O key."
    }
    const "KeyP" {
      type="enum:aego/input.Key"
      int=19
      float=0
      bool=false
      str=""
      doc="The P key."
    }
    const "KeyPageDown" {
      type="enum:aego/input.Key"
      int=78
      float=0
      bool=false
      str=""
      doc="The PageDown key."
    }
    const "KeyPageUp" {
      type="enum:aego/input.Key"
      int=75
      float=0
      bool=false
      str=""
      doc="The PageUp key."
    }
    const "KeyPause" {
      type="enum:aego/input.Key"
      int=72
      float=0
      bool=false
      str=""
      doc="The Pause key."
    }
    const "KeyPrintScreen" {
      type="enum:aego/input.Key"
      int=70
      float=0
      bool=false
      str=""
      doc="The PrintScreen key."
    }
    const "KeyQ" {
      type="enum:aego/input.Key"
      int=20
      float=0
      bool=false
      str=""
      doc="The Q key."
    }
    const "KeyR" {
      type="enum:aego/input.Key"
      int=21
      float=0
      bool=false
      str=""
      doc="The R key."
    }
    const "KeyRAlt" {
      type="enum:aego/input.Key"
      int=230
      float=0
      bool=false
      str=""
      doc="The RAlt key."
    }
    const "KeyRCtrl" {
      type="enum:aego/input.Key"
      int=228
      float=0
      bool=false
      str=""
      doc="The RCtrl key."
    }
    const "KeyRGUI" {
      type="enum:aego/input.Key"
      int=231
      float=0
      bool=false
      str=""
      doc="The RGUI key."
    }
    const "KeyRShift" {
      type="enum:aego/input.Key"
      int=229
      float=0
      bool=false
      str=""
      doc="The RShift key."
    }
    const "KeyRight" {
      type="enum:aego/input.Key"
      int=79
      float=0
      bool=false
      str=""
      doc="The Right key."
    }
    const "KeyS" {
      type="enum:aego/input.Key"
      int=22
      float=0
      bool=false
      str=""
      doc="The S key."
    }
    const "KeyScrollLock" {
      type="enum:aego/input.Key"
      int=71
      float=0
      bool=false
      str=""
      doc="The ScrollLock key."
    }
    const "KeySpace" {
      type="enum:aego/input.Key"
      int=44
      float=0
      bool=false
      str=""
      doc="The Space key."
    }
    const "KeyT" {
      type="enum:aego/input.Key"
      int=23
      float=0
      bool=false
      str=""
      doc="The T key."
    }
    const "KeyTab" {
      type="enum:aego/input.Key"
      int=43
      float=0
      bool=false
      str=""
      doc="The Tab key."
    }
    const "KeyU" {
      type="enum:aego/input.Key"
      int=24
      float=0
      bool=false
      str=""
      doc="The U key."
    }
    const "KeyUp" {
      type="enum:aego/input.Key"
      int=82
      float=0
      bool=false
      str=""
      doc="The Up key."
    }
    const "KeyV" {
      type="enum:aego/input.Key"
      int=25
      float=0
      bool=false
      str=""
      doc="The V key."
    }
    const "KeyW" {
      type="enum:aego/input.Key"
      int=26
      float=0
      bool=false
      str=""
      doc="The W key."
    }
    const "KeyX" {
      type="enum:aego/input.Key"
      int=27
      float=0
      bool=false
      str=""
      doc="The X key."
    }
    const "KeyY" {
      type="enum:aego/input.Key"
      int=28
      float=0
      bool=false
      str=""
      doc="The Y key."
    }
    const "KeyZ" {
      type="enum:aego/input.Key"
      int=29
      float=0
      bool=false
      str=""
      doc="The Z key."
    }
    const "MouseLeft" {
      type="enum:aego/input.Button"
      int=0
      float=0
      bool=false
      str=""
      doc="The Left mouse button."
    }
    const "MouseMiddle" {
      type="enum:aego/input.Button"
      int=2
      float=0
      bool=false
      str=""
      doc="The Middle mouse button."
    }
    const "MouseRight" {
      type="enum:aego/input.Button"
      int=1
      float=0
      bool=false
      str=""
      doc="The Right mouse button."
    }
    const "MouseX1" {
      type="enum:aego/input.Button"
      int=3
      float=0
      bool=false
      str=""
      doc="The X1 mouse button."
    }
    const "MouseX2" {
      type="enum:aego/input.Button"
      int=4
      float=0
      bool=false
      str=""
      doc="The X2 mouse button."
    }
  }
  module "aego/lighting" {
    func "Debug" {
      params=[]
      result="string"
      doc="Returns this world's view debug display: lighting, normals or shadows."
    }
    func "Enabled" {
      params=[]
      result="bool"
      doc="Returns whether this world's current view applies lighting."
    }
    func "SetDebug" {
      params=["string"]
      result="void"
      names=["mode"]
      doc="Selects the view debug display: lighting, normals or shadows. This does not mutate the scene."
    }
    func "SetEnabled" {
      params=["bool"]
      result="void"
      names=["enabled"]
      doc="Enables or bypasses lighting in this world's current view without changing scene materials or simulation."
    }
  }
  module "aego/log" {
    func "Debug" {
      params=["string"]
      result="void"
      names=["msg"]
      doc="Debug writes a message to the Console. Debug messages are hidden unless the editor runs with -debug."
      example="log.Debug(\"state \" + string(int(state)))"
    }
    func "Error" {
      params=["string"]
      result="void"
      names=["msg"]
      doc="Error writes an error to the Console. It does not stop the script; use it for problems you can recover from."
      example="log.Error(\"spawn point missing\")"
    }
    func "Info" {
      params=["string"]
      result="void"
      names=["msg"]
      doc="Info writes a message to the Console."
      example="log.Info(\"ready \" + node.Name())"
    }
    func "Warn" {
      params=["string"]
      result="void"
      names=["msg"]
      doc="Warn writes a warning to the Console."
      example="log.Warn(\"Target is not set\")"
    }
  }
  module "aego/material" {
    func "Assign" {
      params=["NodeRef", "AssetRef<material>"]
      result="void"
      names=["node", "material"]
      doc="Assign changes the SpriteRenderer or Mesh2D material reference in this world."
      example="material.Assign(node, material.Builtin(\"Flash\"))"
    }
    func "Builtin" {
      params=["string"]
      result="AssetRef<material>"
      names=["name"]
      doc="Builtin returns Unlit (Default), Additive, Flash, Dissolve, Outline or PixelSnap. Lit belongs to the lighting module."
    }
    func "Shader" {
      params=["string"]
      result="AssetRef<shader>"
      names=["name"]
      doc="Shader returns the prepared shader reference for a named built-in material."
    }
  }
  module "aego/math" {
    func "Abs" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Abs returns the absolute value of x."
      example="dist := math.Abs(target - x)"
    }
    func "AbsInt" {
      params=["int"]
      result="int"
      names=["x"]
      doc="AbsInt returns the absolute value of an int."
      example="steps := math.AbsInt(to - from)"
    }
    func "Acos" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Acos returns the angle in radians whose cosine is x, in [0, Pi]."
      example="a := math.Acos(math.Dot(u, v))"
    }
    func "Angle" {
      params=["Vec2"]
      result="float"
      names=["v"]
      doc="Angle returns the direction of v in radians."
      example="node.SetRotation(math.Angle(velocity))"
    }
    func "Asin" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Asin returns the angle in radians whose sine is x, in [-Pi/2, Pi/2]."
      example="a := math.Asin(0.5)"
    }
    func "Atan2" {
      params=["float", "float"]
      result="float"
      names=["y", "x"]
      doc="Atan2 returns the angle in radians of the vector (x, y), in (-Pi, Pi]."
      example="angle := math.Atan2(d.Y, d.X)"
    }
    func "Ceil" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Ceil returns the least whole number greater than or equal to x."
      example="pages := math.Ceil(float(count) / 10)"
    }
    func "Clamp" {
      params=["float", "float", "float"]
      result="float"
      names=["v", "lo", "hi"]
      doc="Clamp limits v to the range [lo, hi]."
      example="x = math.Clamp(x, -10, 10)"
    }
    func "ClampInt" {
      params=["int", "int", "int"]
      result="int"
      names=["v", "lo", "hi"]
      doc="ClampInt limits an int to the range [lo, hi]."
      example="level = math.ClampInt(level, 1, 10)"
    }
    func "Cos" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Cos returns the cosine of an angle in radians."
      example="x := math.Cos(angle) * Radius"
    }
    func "Cross" {
      params=["Vec2", "Vec2"]
      result="float"
      names=["a", "b"]
      doc="Cross returns the z component of the 3D cross product; its sign tells on which side b lies."
      example="left := math.Cross(forward, toTarget) < 0"
    }
    func "Cross3" {
      params=["Vec3", "Vec3"]
      result="Vec3"
      names=["a", "b"]
      doc="Cross3 returns a vector perpendicular to a and b."
      example="right := math.Cross3(forward, Vec3{0, 1, 0})"
    }
    func "Deg2Rad" {
      params=["float"]
      result="float"
      names=["degrees"]
      doc="Deg2Rad converts degrees to radians."
      example="node.SetRotation(math.Deg2Rad(45))"
    }
    func "Dist" {
      params=["Vec2", "Vec2"]
      result="float"
      names=["a", "b"]
      doc="Dist returns the distance between two points."
      example="if math.Dist(pos, goal) < 0.1 {"
    }
    func "Dist3" {
      params=["Vec3", "Vec3"]
      result="float"
      names=["a", "b"]
      doc="Dist3 returns the distance between two 3D points."
      example="near := math.Dist3(a, b) < 2"
    }
    func "Dot" {
      params=["Vec2", "Vec2"]
      result="float"
      names=["a", "b"]
      doc="Dot returns the dot product of two Vec2."
      example="facing := math.Dot(forward, toPlayer) > 0"
    }
    func "Dot3" {
      params=["Vec3", "Vec3"]
      result="float"
      names=["a", "b"]
      doc="Dot3 returns the dot product of two Vec3."
      example="lit := math.Dot3(normal, light) > 0"
    }
    func "Exp" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Exp returns e raised to the power x."
      example="decay := math.Exp(-dt * Damping)"
    }
    func "Floor" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Floor returns the greatest whole number less than or equal to x."
      example="cell := math.Floor(pos.X / 32)"
    }
    func "Length" {
      params=["Vec2"]
      result="float"
      names=["v"]
      doc="Length returns the length of a Vec2."
      example="speed := math.Length(velocity)"
    }
    func "Length3" {
      params=["Vec3"]
      result="float"
      names=["v"]
      doc="Length3 returns the length of a Vec3."
      example="d := math.Length3(velocity)"
    }
    func "Lerp" {
      params=["float", "float", "float"]
      result="float"
      names=["a", "b", "t"]
      doc="Lerp blends from a to b. t = 0 gives a, t = 1 gives b; t is not clamped."
      example="zoom = math.Lerp(zoom, target, 5 * dt)"
    }
    func "LerpVec2" {
      params=["Vec2", "Vec2", "float"]
      result="Vec2"
      names=["a", "b", "t"]
      doc="LerpVec2 blends two Vec2 component-wise."
      example="cam = math.LerpVec2(cam, target, 4 * dt)"
    }
    func "LerpVec3" {
      params=["Vec3", "Vec3", "float"]
      result="Vec3"
      names=["a", "b", "t"]
      doc="LerpVec3 blends two Vec3 component-wise."
      example="p := math.LerpVec3(from, to, t)"
    }
    func "Log" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Log returns the natural logarithm of x."
      example="octave := math.Log(freq) / math.Log(2)"
    }
    func "Max" {
      params=["float", "float"]
      result="float"
      names=["a", "b"]
      doc="Max returns the larger of a and b."
      example="hp := math.Max(hp - damage, 0)"
    }
    func "MaxInt" {
      params=["int", "int"]
      result="int"
      names=["a", "b"]
      doc="MaxInt returns the larger of two ints."
      example="lives = math.MaxInt(lives - 1, 0)"
    }
    func "Min" {
      params=["float", "float"]
      result="float"
      names=["a", "b"]
      doc="Min returns the smaller of a and b."
      example="speed := math.Min(speed, MaxSpeed)"
    }
    func "MinInt" {
      params=["int", "int"]
      result="int"
      names=["a", "b"]
      doc="MinInt returns the smaller of two ints."
      example="ammo = math.MinInt(ammo + 10, MaxAmmo)"
    }
    func "Normalize" {
      params=["Vec2"]
      result="Vec2"
      names=["v"]
      doc="Normalize returns v scaled to length 1. A zero vector stays zero."
      example="dir := math.Normalize(target - pos)"
    }
    func "Normalize3" {
      params=["Vec3"]
      result="Vec3"
      names=["v"]
      doc="Normalize3 returns v scaled to length 1."
      example="dir := math.Normalize3(target - pos)"
    }
    func "Pow" {
      params=["float", "float"]
      result="float"
      names=["x", "y"]
      doc="Pow returns x raised to the power y."
      example="ease := math.Pow(t, 3)"
    }
    func "QuatAxisAngle" {
      params=["Vec3", "float"]
      result="Quat"
      names=["axis", "radians"]
      doc="QuatAxisAngle builds a rotation of an angle in radians around an axis."
      example="spin := math.QuatAxisAngle(Vec3{0, 1, 0}, Speed * dt)"
    }
    func "QuatEuler" {
      params=["float", "float", "float"]
      result="Quat"
      names=["x", "y", "z"]
      doc="QuatEuler builds a rotation from Euler angles in radians, applied as Z·Y·X."
      example="node.SetRotation3(math.QuatEuler(0, math.Pi, 0))"
    }
    func "QuatLookDir" {
      params=["Vec3"]
      result="Quat"
      names=["dir"]
      doc="QuatLookDir returns the rotation that points -Z along d."
      example="node.SetRotation3(math.QuatLookDir(target - pos))"
    }
    func "QuatMul" {
      params=["Quat", "Quat"]
      result="Quat"
      names=["a", "b"]
      doc="QuatMul combines two rotations: b is applied first, then a."
      example="node.SetRotation3(math.QuatMul(spin, node.Rotation3()))"
    }
    func "QuatRotate" {
      params=["Quat", "Vec3"]
      result="Vec3"
      names=["q", "v"]
      doc="QuatRotate rotates a vector by q."
      example="forward := math.QuatRotate(node.Rotation3(), Vec3{0, 0, -1})"
    }
    func "QuatSlerp" {
      params=["Quat", "Quat", "float"]
      result="Quat"
      names=["a", "b", "t"]
      doc="QuatSlerp blends two rotations along the shortest arc."
      example="r := math.QuatSlerp(from, to, 0.5)"
    }
    func "Rad2Deg" {
      params=["float"]
      result="float"
      names=["radians"]
      doc="Rad2Deg converts radians to degrees."
      example="log.Info(string(math.Rad2Deg(node.Rotation())))"
    }
    func "Rotate" {
      params=["Vec2", "float"]
      result="Vec2"
      names=["v", "radians"]
      doc="Rotate turns v clockwise by an angle in radians."
      example="offset := math.Rotate(Vec2{1, 0}, node.Rotation())"
    }
    func "Round" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Round returns x rounded to the nearest whole number; halves round away from zero."
      example="snapped := math.Round(x)"
    }
    func "Sign" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Sign returns -1, 0 or 1 depending on the sign of x."
      example="dir := math.Sign(input.Axis(\"horizontal\"))"
    }
    func "Sin" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Sin returns the sine of an angle in radians."
      example="y := math.Sin(time.Elapsed() * 2) * Amplitude"
    }
    func "Sqrt" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Sqrt returns the square root of x. Negative x gives NaN."
      example="d := math.Sqrt(dx*dx + dy*dy)"
    }
    func "Tan" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Tan returns the tangent of an angle in radians."
      example="slope := math.Tan(math.Deg2Rad(30))"
    }
    func "Trunc" {
      params=["float"]
      result="float"
      names=["x"]
      doc="Trunc drops the fractional part of x."
      example="whole := math.Trunc(-2.7)"
    }
    const "Pi" {
      type="float"
      int=0
      float=3.1415927410125732
      bool=false
      str=""
      doc="Pi is the ratio of a circle's circumference to its diameter, about 3.14159."
    }
    const "Tau" {
      type="float"
      int=0
      float=6.2831854820251465
      bool=false
      str=""
      doc="Tau is a full turn in radians, 2·Pi."
    }
  }
  module "aego/particles" {
    func "Enabled" {
      params=[]
      result="bool"
      doc="Reports whether this world presents particle effects."
      example="visible := particles.Enabled()"
    }
    func "SetEnabled" {
      params=["bool"]
      result="void"
      names=["enabled"]
      doc="Turns particles on or off in this Play world. Turning them off clears current effects."
      example="particles.SetEnabled(false)"
    }
  }
  module "aego/physics" {
    func "Gravity" {
      params=[]
      result="Vec2"
      doc="Gravity returns the world gravity in units per second squared. +Y points down."
    }
    func "Layer" {
      params=["string"]
      result="int"
      names=["name"]
      doc="Layer returns the index of a named physics layer."
    }
    func "LayerMask" {
      params=["string"]
      result="int"
      names=["name"]
      doc="LayerMask returns the mask bit of a named layer. Add masks of different layers to combine them."
      example="mask := physics.LayerMask(\"World\") + physics.LayerMask(\"Enemies\")"
    }
    func "Linecast" {
      params=["Vec2", "Vec2", "int"]
      result="struct:aego/physics.RayHit"
      names=["from", "to", "mask"]
      doc="Linecast returns the first hit between from and to on the layers in mask; -1 means every layer."
      example="hit := physics.Linecast(eye, target, physics.LayerMask(\"World\"))"
    }
    func "OverlapBox" {
      params=["Vec2", "Vec2", "[]NodeRef"]
      result="int"
      names=["center", "size", "out"]
      doc="OverlapBox writes the bodies touching the axis-aligned box into out and returns the count."
    }
    func "OverlapCircle" {
      params=["Vec2", "float", "[]NodeRef"]
      result="int"
      names=["center", "radius", "out"]
      doc="OverlapCircle writes the bodies touching the circle into out and returns the count."
    }
    func "OverlapPoint" {
      params=["Vec2", "[]NodeRef"]
      result="int"
      names=["point", "out"]
      doc="OverlapPoint writes the bodies whose colliders contain p into out and returns the count."
    }
    func "Raycast" {
      params=["Vec2", "Vec2", "float"]
      result="struct:aego/physics.RayHit"
      names=["origin", "dir", "maxDist"]
      doc="Raycast returns the closest hit along dir within maxDist. The caller's own body is ignored, triggers are skipped."
      example="hit := physics.Raycast(pos, Vec2{Y: 1}, 0.6)\nif hit.Hit {\n\tgrounded = true\n}"
    }
    func "RaycastAll" {
      params=["Vec2", "Vec2", "[]struct:aego/physics.RayHit"]
      result="int"
      names=["from", "to", "out"]
      doc="RaycastAll fills out with hits between from and to, nearest first, and returns how many it wrote. It writes at most len(out)."
    }
    func "SetGravity" {
      params=["Vec2"]
      result="void"
      names=["gravity"]
      doc="SetGravity changes the world gravity for the rest of the Play session."
    }
  }
  module "aego/rand" {
    func "Bool" {
      params=[]
      result="bool"
      doc="Bool returns true or false with equal chance."
      example="flip := rand.Bool()"
    }
    func "Float" {
      params=[]
      result="float"
      doc="Float returns a random number in [0, 1)."
      example="if rand.Float() < 0.25 {\n\tdropLoot()\n}"
    }
    func "Int" {
      params=["int", "int"]
      result="int"
      names=["min", "max"]
      doc="Int returns a random int in [min, max). It returns min when max <= min."
      example="roll := rand.Int(1, 7)"
    }
    func "Range" {
      params=["float", "float"]
      result="float"
      names=["min", "max"]
      doc="Range returns a random float in [min, max)."
      example="delay := rand.Range(0.5, 1.5)"
    }
    func "Seed" {
      params=[]
      result="int"
      doc="Seed returns the seed of the world's generator. Replays with the same seed produce the same numbers."
      example="log.Info(\"seed \" + string(rand.Seed()))"
    }
  }
  module "aego/save" {
    func "Autosave" {
      params=["float"]
      result="void"
      names=["seconds"]
      doc="Autosave saves to the slot named autosave every given number of real seconds; 0 turns it off."
    }
    func "Checkpoint" {
      params=[]
      result="void"
      doc="Checkpoint saves the game to the slot named checkpoint."
      example="save.Checkpoint()"
    }
    func "Delete" {
      params=["string"]
      result="void"
      names=["slot"]
      doc="Delete removes a save and its preview."
    }
    func "Exists" {
      params=["string"]
      result="bool"
      names=["slot"]
      doc="Exists reports whether a slot holds a save."
    }
    func "GetBool" {
      params=["string", "bool"]
      result="bool"
      names=["key", "def"]
      doc="GetBool reads a value this node stored, or def; it works in OnLoad."
    }
    func "GetFloat" {
      params=["string", "float"]
      result="float"
      names=["key", "def"]
      doc="GetFloat reads a value this node stored, or def; it works in OnLoad."
    }
    func "GetInt" {
      params=["string", "int"]
      result="int"
      names=["key", "def"]
      doc="GetInt reads a value this node stored, or def; it works in OnLoad."
    }
    func "GetString" {
      params=["string", "string"]
      result="string"
      names=["key", "def"]
      doc="GetString reads a value this node stored, or def; it works in OnLoad."
    }
    func "GetVec2" {
      params=["string", "Vec2"]
      result="Vec2"
      names=["key", "def"]
      doc="GetVec2 reads a value this node stored, or def; it works in OnLoad."
    }
    func "GlobalBool" {
      params=["string", "bool"]
      result="bool"
      names=["key", "def"]
      doc="GlobalBool reads game-wide progress, or def."
    }
    func "GlobalFloat" {
      params=["string", "float"]
      result="float"
      names=["key", "def"]
      doc="GlobalFloat reads game-wide progress, or def."
    }
    func "GlobalInt" {
      params=["string", "int"]
      result="int"
      names=["key", "def"]
      doc="GlobalInt reads game-wide progress, or def."
      example="kills := save.GlobalInt(\"kills\", 0)"
    }
    func "GlobalString" {
      params=["string", "string"]
      result="string"
      names=["key", "def"]
      doc="GlobalString reads game-wide progress, or def."
    }
    func "Load" {
      params=["string"]
      result="void"
      names=["slot"]
      doc="Load reloads the saved scene and restores the slot at the end of the frame."
      example="if save.Exists(\"slot1\") {\n  save.Load(\"slot1\")\n}"
    }
    func "PutBool" {
      params=["string", "bool"]
      result="void"
      names=["key", "value"]
      doc="PutBool stores a value for this node; call it in OnSave."
    }
    func "PutFloat" {
      params=["string", "float"]
      result="void"
      names=["key", "value"]
      doc="PutFloat stores a value for this node; call it in OnSave."
    }
    func "PutInt" {
      params=["string", "int"]
      result="void"
      names=["key", "value"]
      doc="PutInt stores a value for this node; call it in OnSave."
    }
    func "PutString" {
      params=["string", "string"]
      result="void"
      names=["key", "value"]
      doc="PutString stores a value for this node; call it in OnSave."
    }
    func "PutVec2" {
      params=["string", "Vec2"]
      result="void"
      names=["key", "value"]
      doc="PutVec2 stores a value for this node; call it in OnSave."
    }
    func "Save" {
      params=["string"]
      result="void"
      names=["slot"]
      doc="Save writes the game to a slot at the end of the frame."
      example="save.Save(\"slot1\")"
    }
    func "SetGlobalBool" {
      params=["string", "bool"]
      result="void"
      names=["key", "value"]
      doc="SetGlobalBool stores game-wide progress that every save carries."
    }
    func "SetGlobalFloat" {
      params=["string", "float"]
      result="void"
      names=["key", "value"]
      doc="SetGlobalFloat stores game-wide progress that every save carries."
    }
    func "SetGlobalInt" {
      params=["string", "int"]
      result="void"
      names=["key", "value"]
      doc="SetGlobalInt stores game-wide progress that every save carries."
    }
    func "SetGlobalString" {
      params=["string", "string"]
      result="void"
      names=["key", "value"]
      doc="SetGlobalString stores game-wide progress that every save carries."
    }
  }
  module "aego/scene" {
    func "ByID" {
      params=["string"]
      result="NodeRef"
      names=["id"]
      doc="ByID returns the node with this id, as written in the scene file, or nil."
    }
    func "Despawn" {
      params=["NodeRef"]
      result="void"
      names=["node"]
      doc="Despawn returns a spawned copy to its pool; it destroys a node that did not come from a pool."
      example="scene.Despawn(node)"
    }
    func "Destroy" {
      params=["NodeRef"]
      result="void"
      names=["node"]
      doc="Destroy removes a node and its children at the end of the phase."
      example="scene.Destroy(Target)"
    }
    func "Find" {
      params=["string"]
      result="NodeRef"
      names=["path"]
      doc="Find returns the node at a path from the scene root, or nil."
      example="spawn := scene.Find(\"Level/Spawn\")"
    }
    func "InArea" {
      params=["Rect", "int", "[]NodeRef"]
      result="int"
      names=["rect", "mask", "out"]
      doc="InArea writes the bodies touching the rectangle on the layers in mask into out. Without physics it writes every enabled 2D node whose position lies in the rectangle, ignoring mask."
      example="n := scene.InArea(Rect{x - 2, y - 2, 4, 4}, -1, near)"
    }
    func "Instantiate" {
      params=["AssetRef<prefab>", "NodeRef"]
      result="NodeRef"
      names=["prefab", "parent"]
      doc="Instantiate creates a copy of a prefab under parent, or under the root when parent is nil.\nThe new nodes appear at the end of the phase; their scripts get Ready before the next Update."
      example="b := scene.Instantiate(Bullet, nil)\nb.SetPosition(node.WorldPosition())"
    }
    func "Pool" {
      params=["AssetRef<prefab>", "int"]
      result="void"
      names=["prefab", "count"]
      doc="Pool makes n copies of a prefab ahead of time; their Ready runs now and Spawn takes them later."
      example="scene.Pool(Bullet, 32)"
    }
    func "Spawn" {
      params=["AssetRef<prefab>", "Vec2"]
      result="NodeRef"
      names=["prefab", "position"]
      doc="Spawn places a copy of a prefab at a position under the scene root, taken from its pool when one is free."
      example="b := scene.Spawn(Bullet, node.WorldPosition())"
    }
    func "SpawnAt" {
      params=["AssetRef<prefab>", "NodeRef", "Vec2", "float"]
      result="NodeRef"
      names=["prefab", "parent", "position", "rotation"]
      doc="SpawnAt places a copy of a prefab under parent with a local position and rotation."
      example="fx := scene.SpawnAt(Spark, node, Vec2{}, 0)"
    }
    func "WithComponent" {
      params=["string", "[]NodeRef"]
      result="int"
      names=["component", "out"]
      doc="WithComponent writes enabled nodes that have the component into out and returns the count."
      example="n := scene.WithComponent(\"Body2D\", bodies)"
    }
    func "WithTag" {
      params=["string", "[]NodeRef"]
      result="int"
      names=["tag", "out"]
      doc="WithTag writes enabled nodes with the tag into out and returns the count; Enemy also finds Enemy.Flying. Nodes come in the order they got the tag."
      example="n := scene.WithTag(\"Enemy\", enemies)"
    }
  }
  module "aego/settings" {
    func "Apply" {
      params=[]
      result="bool"
      doc="Apply applies every staged value at once; if one fails, none change."
      example="if !settings.Apply() {"
    }
    func "ClearOverride" {
      params=["string"]
      result="void"
      names=["id"]
      doc="ClearOverride removes a session override."
      example="settings.ClearOverride(\"audio.bus.music.volume\")"
    }
    func "ClearOverrides" {
      params=[]
      result="void"
      doc="ClearOverrides removes every session override."
      example="settings.ClearOverrides()"
    }
    func "CloseView" {
      params=[]
      result="void"
      doc="CloseView hides the settings screen."
      example="settings.CloseView()"
    }
    func "GetBool" {
      params=["string"]
      result="bool"
      names=["id"]
      doc="GetBool returns the effective value of an on/off setting."
      example="if settings.GetBool(\"accessibility.reducedMotion\") {"
    }
    func "GetFloat" {
      params=["string"]
      result="float"
      names=["id"]
      doc="GetFloat returns the effective value of a number setting."
      example="shake *= settings.GetFloat(\"accessibility.screenShake\")"
    }
    func "GetInt" {
      params=["string"]
      result="int"
      names=["id"]
      doc="GetInt returns the effective value of an integer or choice setting."
      example="fps := settings.GetInt(\"display.frameLimit\")"
    }
    func "GetString" {
      params=["string"]
      result="string"
      names=["id"]
      doc="GetString returns a text setting, or the name of the current choice."
      example="mode := settings.GetString(\"display.window.mode\")"
    }
    func "NeedsRestart" {
      params=[]
      result="bool"
      doc="NeedsRestart reports whether an applied setting takes effect only after a restart."
      example="if settings.NeedsRestart() {"
    }
    func "OpenView" {
      params=[]
      result="void"
      doc="OpenView shows the settings screen and pauses the game until it closes."
      example="settings.OpenView()"
    }
    func "OverrideBool" {
      params=["string", "bool"]
      result="void"
      names=["id", "value"]
      doc="OverrideBool sets an on/off value for this session only."
      example="settings.OverrideBool(\"audio.bus.sfx.mute\", true)"
    }
    func "OverrideFloat" {
      params=["string", "float"]
      result="void"
      names=["id", "value"]
      doc="OverrideFloat sets a value for this session only; it is never saved."
      example="settings.OverrideFloat(\"audio.bus.music.volume\", 0.2)"
    }
    func "OverrideInt" {
      params=["string", "int"]
      result="void"
      names=["id", "value"]
      doc="OverrideInt sets an integer for this session only."
      example="settings.OverrideInt(\"display.frameLimit\", 30)"
    }
    func "OverrideString" {
      params=["string", "string"]
      result="void"
      names=["id", "value"]
      doc="OverrideString sets a text value for this session only."
      example="settings.OverrideString(\"display.window.resolution\", \"1280x720\")"
    }
    func "Reset" {
      params=["string"]
      result="void"
      names=["id"]
      doc="Reset stages a return to the project default."
      example="settings.Reset(\"input.sensitivity\")"
    }
    func "Revert" {
      params=[]
      result="void"
      doc="Revert drops the staged values."
      example="settings.Revert()"
    }
    func "Save" {
      params=[]
      result="void"
      doc="Save writes the player profile now; it is also saved on its own shortly after a change."
      example="settings.Save()"
    }
    func "SetBool" {
      params=["string", "bool"]
      result="void"
      names=["id", "value"]
      doc="SetBool stages a value; Apply makes it take effect."
      example="settings.SetBool(\"accessibility.subtitles\", true)"
    }
    func "SetFloat" {
      params=["string", "float"]
      result="void"
      names=["id", "value"]
      doc="SetFloat stages a number."
      example="settings.SetFloat(\"audio.bus.music.volume\", 0.5)"
    }
    func "SetInt" {
      params=["string", "int"]
      result="void"
      names=["id", "value"]
      doc="SetInt stages an integer or choice index."
      example="settings.SetInt(\"display.frameLimit\", 60)"
    }
    func "SetString" {
      params=["string", "string"]
      result="void"
      names=["id", "value"]
      doc="SetString stages a text value."
      example="settings.SetString(\"display.window.resolution\", \"1920x1080\")"
    }
    func "ViewOpen" {
      params=[]
      result="bool"
      doc="ViewOpen reports whether the settings screen is shown."
      example="if settings.ViewOpen() {"
    }
  }
  module "aego/testing" {
    func "Equal" {
      params=["int", "int"]
      result="void"
      names=["got", "want"]
      doc="Equal fails the test when two ints differ."
      example="testing.Equal(score(), 100)"
    }
    func "EqualFloat" {
      params=["float", "float", "float"]
      result="void"
      names=["got", "want", "eps"]
      doc="EqualFloat fails the test when got is further than eps from want, or is NaN."
      example="testing.EqualFloat(math.Sqrt(2), 1.4142, 0.001)"
    }
    func "EqualString" {
      params=["string", "string"]
      result="void"
      names=["got", "want"]
      doc="EqualString fails the test when two strings differ."
      example="testing.EqualString(name(), \"Player\")"
    }
    func "Fail" {
      params=["string"]
      result="void"
      names=["msg"]
      doc="Fail stops the test and reports msg."
      example="testing.Fail(\"unreachable\")"
    }
    func "False" {
      params=["bool", "string"]
      result="void"
      names=["v", "msg"]
      doc="False fails the test with msg when v is true."
      example="testing.False(dead, \"player should be alive\")"
    }
    func "True" {
      params=["bool", "string"]
      result="void"
      names=["v", "msg"]
      doc="True fails the test with msg when v is false."
      example="testing.True(hp > 0, \"player should be alive\")"
    }
  }
  module "aego/time" {
    func "Delta" {
      params=[]
      result="float"
      doc="Delta returns the game seconds since the previous frame: real time × Scale, 0 while paused. Inside FixedUpdate it is the fixed step."
      example="x += Speed * time.Delta()"
    }
    func "Elapsed" {
      params=[]
      result="float"
      doc="Elapsed returns the game seconds since Play started. It stops while paused and follows Scale."
      example="y := math.Sin(time.Elapsed() * 3)"
    }
    func "Fixed" {
      params=[]
      result="float"
      doc="Fixed returns the fixed step length in seconds, 1/60 by default. Scale does not change it; it changes how many steps run."
      example="steps := int(1 / time.Fixed())"
    }
    func "Frame" {
      params=[]
      result="int"
      doc="Frame returns the number of frames this world has run, paused frames included."
      example="if time.Frame() % 60 == 0 {\n\tlog.Info(\"tick\")\n}"
    }
    func "IsPaused" {
      params=[]
      result="bool"
      doc="IsPaused reports whether game time is paused."
      example="if time.IsPaused() {"
    }
    func "Scale" {
      params=[]
      result="float"
      doc="Scale returns the time scale: 1 is normal speed, 0.5 is half speed, 0 freezes game time without pausing."
      example="if time.Scale() < 1 {"
    }
    func "SetPaused" {
      params=["bool"]
      result="void"
      names=["paused"]
      doc="SetPaused pauses or resumes game time. While paused, Update, FixedUpdate and game-time coroutines of ordinary scripts do not run."
      example="time.SetPaused(true)"
    }
    func "SetScale" {
      params=["float"]
      result="void"
      names=["scale"]
      doc="SetScale sets the time scale from 0 to 8. The fixed step stays the same, so the simulation stays stable; only the number of steps changes."
      example="time.SetScale(0.25)"
    }
    func "Tick" {
      params=[]
      result="int"
      doc="Tick returns the number of the current or last fixed step. It is the same number the profiler and the Event Monitor show."
      example="log.Info(\"landed on tick \" + string(time.Tick()))"
    }
    func "Unscaled" {
      params=[]
      result="float"
      doc="Unscaled returns the real seconds since the previous frame, ignoring Scale and pause."
      example="menuFade += time.Unscaled()"
    }
    func "UnscaledElapsed" {
      params=[]
      result="float"
      doc="UnscaledElapsed returns the real seconds since Play started, pauses included."
      example="blink := math.Sin(time.UnscaledElapsed() * 6)"
    }
  }
  module "aego/timer" {
    func "Cooldown" {
      params=["float"]
      result="Handle<aego/timer.Timer>"
      names=["seconds"]
      doc="Cooldown makes a timer that starts ready; Use takes it and starts the wait."
      example="if attack.Use() {\n\tfire()\n}"
    }
    func "New" {
      params=["float"]
      result="Handle<aego/timer.Timer>"
      names=["seconds"]
      doc="New makes a timer that stays after it ends, so Restart can run it again."
      example="spawn = timer.New(3).Repeat(-1)"
    }
    func "Start" {
      params=["float"]
      result="Handle<aego/timer.Timer>"
      names=["seconds"]
      doc="Start makes a one-shot timer that frees itself when it fires."
      example="yield timer.Start(0.5)"
    }
  }
  module "aego/tween" {
    func "Position" {
      params=["NodeRef", "Vec2", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "to", "duration", "ease"]
      doc="Position moves a 2D node to a local position."
      example="yield tween.Position(node, Vec2{4, 0}, 0.5, curve.OutCubic)"
    }
    func "ToColor" {
      params=["NodeRef", "string", "Color", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "path", "to", "duration", "ease"]
      doc="ToColor animates a Color property."
      example="tween.ToColor(node, \"SpriteRenderer.Tint\", HitTint, 0.2, curve.Linear)"
    }
    func "ToFloat" {
      params=["NodeRef", "string", "float", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "path", "to", "duration", "ease"]
      doc="ToFloat animates a float or int property, or one lane of a vector or color.\nPaths: Component.Field, Component.Field.a, transform.rotation, script/Name.Field."
      example="tween.ToFloat(node, \"SpriteRenderer.Tint.a\", 0, 0.3, curve.OutQuad)"
    }
    func "ToQuat" {
      params=["NodeRef", "string", "Quat", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "path", "to", "duration", "ease"]
      doc="ToQuat turns a rotation along the short arc."
      example="tween.ToQuat(node, \"transform.rotation\", math.QuatEuler(0, 1.57, 0), 0.5, curve.InOutCubic)"
    }
    func "ToVec2" {
      params=["NodeRef", "string", "Vec2", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "path", "to", "duration", "ease"]
      doc="ToVec2 animates a Vec2 property."
      example="tween.ToVec2(node, \"transform.scale\", Vec2{1.2, 1.2}, 0.1, curve.OutBack)"
    }
    func "ToVec3" {
      params=["NodeRef", "string", "Vec3", "float", "enum:aego/curve.Easing"]
      result="Handle<aego/tween.Tween>"
      names=["node", "path", "to", "duration", "ease"]
      doc="ToVec3 animates a Vec3 property, such as the position of a 3D node."
      example="tween.ToVec3(node, \"transform.position\", Vec3{0, 2, 0}, 1, curve.InOutSine)"
    }
  }
  module "aego/update" {
    func "Apply" {
      params=[]
      result="void"
      doc="Apply installs the downloaded version and restarts the game on it; save the player's progress first."
      example="if update.State() == \"ready\" { update.Apply() }"
    }
    func "Check" {
      params=[]
      result="void"
      doc="Check looks for a newer version on the game's update server in the background; State says what it found."
      example="update.Check()"
    }
    func "Download" {
      params=[]
      result="void"
      doc="Download fetches the newer version in the background; Auto mode does it on its own."
      example="update.Download()"
    }
    func "Error" {
      params=[]
      result="string"
      doc="Error says why the last check or download failed."
      example="log.Warn(update.Error())"
    }
    func "Notes" {
      params=[]
      result="string"
      doc="Notes are the release notes of the newer version."
      example="notes.Text = update.Notes()"
    }
    func "State" {
      params=[]
      result="string"
      doc="State is idle, checking, upToDate, available, downloading, ready or failed."
      example="if update.State() == \"ready\" {"
    }
    func "Version" {
      params=[]
      result="string"
      doc="Version is the newer version the last check found, empty when there is none."
      example="label.Text = \"Version \" + update.Version() + \" is ready\""
    }
  }
  enum "Bus" module="aego/audio" {
    doc="Bus is a mixer bus: Master, Music, Sfx, UI, Ambience or Voice."
    member "Master" value=0 {}
    member "Music" value=1 {}
    member "Sfx" value=2 {}
    member "UI" value=3 {}
    member "Ambience" value=4 {}
    member "Voice" value=5 {}
  }
  enum "PauseWith" module="aego/audio" {
    doc="PauseWith decides whether a sound pauses with the game or keeps playing."
    member "Game" value=0 {}
    member "Never" value=1 {}
  }
  enum "Steal" module="aego/audio" {
    doc="Steal is what an audio event does at Max Voices: stop the oldest voice, stop the quietest, or skip the new play."
    member "Oldest" value=0 {}
    member "Quietest" value=1 {}
    member "None" value=2 {}
  }
  enum "Easing" module="aego/curve" {
    doc="Easing names a preset curve from 0 to 1. None and Linear move at a constant speed."
    member "None" value=0 {}
    member "Linear" value=1 {}
    member "InQuad" value=2 {}
    member "OutQuad" value=3 {}
    member "InOutQuad" value=4 {}
    member "InCubic" value=5 {}
    member "OutCubic" value=6 {}
    member "InOutCubic" value=7 {}
    member "InSine" value=8 {}
    member "OutSine" value=9 {}
    member "InOutSine" value=10 {}
    member "InExpo" value=11 {}
    member "OutExpo" value=12 {}
    member "InOutExpo" value=13 {}
    member "InBack" value=14 {}
    member "OutBack" value=15 {}
    member "InOutBack" value=16 {}
    member "InElastic" value=17 {}
    member "OutElastic" value=18 {}
    member "InOutElastic" value=19 {}
    member "InBounce" value=20 {}
    member "OutBounce" value=21 {}
    member "InOutBounce" value=22 {}
  }
  enum "Button" module="aego/input" {
    doc="Button is a mouse button."
    member "Left" value=0 {}
    member "Right" value=1 {}
    member "Middle" value=2 {}
    member "X1" value=3 {}
    member "X2" value=4 {}
  }
  enum "Key" module="aego/input" {
    doc="Key is a physical key, independent of the keyboard layout. Prefer actions; raw keys are for prototypes."
    member "A" value=4 {}
    member "B" value=5 {}
    member "C" value=6 {}
    member "D" value=7 {}
    member "E" value=8 {}
    member "F" value=9 {}
    member "G" value=10 {}
    member "H" value=11 {}
    member "I" value=12 {}
    member "J" value=13 {}
    member "K" value=14 {}
    member "L" value=15 {}
    member "M" value=16 {}
    member "N" value=17 {}
    member "O" value=18 {}
    member "P" value=19 {}
    member "Q" value=20 {}
    member "R" value=21 {}
    member "S" value=22 {}
    member "T" value=23 {}
    member "U" value=24 {}
    member "V" value=25 {}
    member "W" value=26 {}
    member "X" value=27 {}
    member "Y" value=28 {}
    member "Z" value=29 {}
    member "Digit1" value=30 {}
    member "Digit2" value=31 {}
    member "Digit3" value=32 {}
    member "Digit4" value=33 {}
    member "Digit5" value=34 {}
    member "Digit6" value=35 {}
    member "Digit7" value=36 {}
    member "Digit8" value=37 {}
    member "Digit9" value=38 {}
    member "Digit0" value=39 {}
    member "Enter" value=40 {}
    member "Escape" value=41 {}
    member "Backspace" value=42 {}
    member "Tab" value=43 {}
    member "Space" value=44 {}
    member "CapsLock" value=57 {}
    member "F1" value=58 {}
    member "F2" value=59 {}
    member "F3" value=60 {}
    member "F4" value=61 {}
    member "F5" value=62 {}
    member "F6" value=63 {}
    member "F7" value=64 {}
    member "F8" value=65 {}
    member "F9" value=66 {}
    member "F10" value=67 {}
    member "F11" value=68 {}
    member "F12" value=69 {}
    member "PrintScreen" value=70 {}
    member "ScrollLock" value=71 {}
    member "Pause" value=72 {}
    member "Insert" value=73 {}
    member "Home" value=74 {}
    member "PageUp" value=75 {}
    member "Delete" value=76 {}
    member "End" value=77 {}
    member "PageDown" value=78 {}
    member "Right" value=79 {}
    member "Left" value=80 {}
    member "Down" value=81 {}
    member "Up" value=82 {}
    member "NumLock" value=83 {}
    member "KPEnter" value=88 {}
    member "KP1" value=89 {}
    member "KP2" value=90 {}
    member "KP3" value=91 {}
    member "KP4" value=92 {}
    member "KP5" value=93 {}
    member "KP6" value=94 {}
    member "KP7" value=95 {}
    member "KP8" value=96 {}
    member "KP9" value=97 {}
    member "KP0" value=98 {}
    member "LCtrl" value=224 {}
    member "LShift" value=225 {}
    member "LAlt" value=226 {}
    member "LGUI" value=227 {}
    member "RCtrl" value=228 {}
    member "RShift" value=229 {}
    member "RAlt" value=230 {}
    member "RGUI" value=231 {}
  }
  struct "PlayOptions" module="aego/audio" slots=8 {
    doc="PlayOptions tune one play. Volume and Pitch 0 mean 1; Bus Master plays on the bus of the clip; Unscaled keeps playing while the game is paused."
    field "Volume" {
      type="float"
    }
    field "Pitch" {
      type="float"
    }
    field "Pan" {
      type="float"
    }
    field "Bus" {
      type="enum:aego/audio.Bus"
    }
    field "Loop" {
      type="bool"
    }
    field "FadeIn" {
      type="float"
    }
    field "Priority" {
      type="int"
    }
    field "Unscaled" {
      type="bool"
    }
  }
  struct "Pose" module="aego/camera" slots=3 {
    doc="Pose is a camera position in world units, a rotation in radians and a zoom in pixels per unit."
    field "Position" {
      type="Vec2"
    }
    field "Rotation" {
      type="float"
    }
    field "Zoom" {
      type="float"
    }
  }
  struct "AudioEvent" module="aego/data" slots=15 {
    doc="AudioEvent is an audio event asset."
    field "Volume" {
      type="float"
    }
    field "VolumeRand" {
      type="float"
    }
    field "Pitch" {
      type="float"
    }
    field "PitchRand" {
      type="float"
    }
    field "Bus" {
      type="enum:aego/audio.Bus"
    }
    field "Priority" {
      type="int"
    }
    field "MaxVoices" {
      type="int"
    }
    field "Steal" {
      type="enum:aego/audio.Steal"
    }
    field "Cooldown" {
      type="float"
    }
    field "Spatial" {
      type="bool"
    }
    field "MinDistance" {
      type="float"
    }
    field "MaxDistance" {
      type="float"
    }
    field "PanWidth" {
      type="float"
    }
    field "Loop" {
      type="bool"
    }
    field "PauseWith" {
      type="enum:aego/audio.PauseWith"
    }
  }
  struct "Vec4" module="aego/material" slots=4 {
    doc="Four numeric lanes, with no color-space conversion."
    field "X" {
      type="float"
    }
    field "Y" {
      type="float"
    }
    field "Z" {
      type="float"
    }
    field "W" {
      type="float"
    }
  }
  struct "Contact" module="aego/physics" slots=6 {
    doc="Contact describes a touch between two colliders from the receiver's side.\nNormal points from the other body into this one, RelativeVelocity is this body's velocity relative to the other at Point."
    field "Point" {
      type="Vec2"
    }
    field "Normal" {
      type="Vec2"
    }
    field "NormalImpulse" {
      type="float"
    }
    field "RelativeVelocity" {
      type="Vec2"
    }
    field "SelfCollider" {
      type="NodeRef"
    }
    field "OtherCollider" {
      type="NodeRef"
    }
  }
  struct "RayHit" module="aego/physics" slots=6 {
    doc="RayHit is the result of a ray query. Hit is false when nothing was found; Node is the body, Collider the node of the shape that was hit."
    field "Hit" {
      type="bool"
    }
    field "Point" {
      type="Vec2"
    }
    field "Normal" {
      type="Vec2"
    }
    field "Distance" {
      type="float"
    }
    field "Node" {
      type="NodeRef"
    }
    field "Collider" {
      type="NodeRef"
    }
  }
  handle "aego/action.Action" await=true {
    doc="Action runs tweens, timers and other actions one after another or together; yield a waits until it ends."
  }
  handle "aego/audio.Sound" await=true {
    doc="Sound is a playing sound. yield s waits until it ends; a nil or finished sound is done. It is a presentation event: wait for game logic with a timer, not a sound."
  }
  handle "aego/camera.Blend" await=true {
    doc="Blend is a running blend between virtual cameras. yield b waits until it ends; a nil blend is done."
  }
  handle "aego/timer.Timer" await=true {
    doc="Timer counts down and fires. yield t waits for the next fire or the end; a timer dies with the node of the script that made it."
  }
  handle "aego/tween.Tween" await=true {
    doc="Tween animates one property of a node. A finished, stopped or nil tween reads as done; yield t waits until it ends."
  }
  event "OnCollisionEnter" {
    params=["NodeRef", "struct:aego/physics.Contact"]
    names=["other", "contact"]
    doc="OnCollisionEnter runs after the physics step in which this body started touching other."
  }
  event "OnCollisionStay" {
    params=["NodeRef", "struct:aego/physics.Contact"]
    names=["other", "contact"]
    doc="OnCollisionStay runs after every later physics step while the bodies keep touching. It costs nothing when no script declares it."
  }
  event "OnCollisionExit" {
    params=["NodeRef", "struct:aego/physics.Contact"]
    names=["other", "contact"]
    doc="OnCollisionExit runs when the bodies stop touching, including when one of them is destroyed or disabled. Contact.Point is the last known point."
  }
  event "OnTriggerEnter" {
    params=["NodeRef"]
    names=["other"]
    doc="OnTriggerEnter runs when other's collider entered a trigger of this body, or this body entered other's trigger."
  }
  event "OnTriggerExit" {
    params=["NodeRef"]
    names=["other"]
    doc="OnTriggerExit runs when the overlap with a trigger ends."
  }
  event "OnSettingChanged" {
    params=["string"]
    names=["id"]
    doc="OnSettingChanged runs on every script with this method after a setting's effective value changed: Apply, Revert, an override or a confirmation timeout."
  }
  event "OnAnimEvent" {
    params=["int", "float"]
    names=["id", "payload"]
    doc="OnAnimEvent runs on the scripts of a node whose Animation Player reaches an event of its clip; anim.EventName(id) gives the name."
  }
  event "OnSpawned" {
    params=[]
    doc="OnSpawned runs on every script of a spawned prefab copy, after Ready for a new copy and instead of it for a copy taken from a pool."
  }
  event "OnDespawned" {
    params=[]
    doc="OnDespawned runs on every script of a pooled copy when it is despawned, before its coroutines and connections end."
  }
  event "OnSave" {
    params=[]
    doc="OnSave runs on every script that has it while a game is saved; write values with save.Put*."
  }
  event "OnLoad" {
    params=[]
    doc="OnLoad runs after Ready on every script that has it when a saved game is loaded; read values with save.Get*."
  }
  method "AddTag" recv="NodeRef" {
    params=["string"]
    result="bool"
    names=["tag"]
    doc="AddTag adds a tag and returns false when it is malformed."
    example="node.AddTag(\"Enemy.Stunned\")"
  }
  method "Child" recv="NodeRef" {
    params=["string"]
    result="NodeRef"
    names=["name"]
    doc="Child returns the direct child with this name, or nil."
    example="gun := node.Child(\"Gun\")"
  }
  method "Destroy" recv="NodeRef" {
    params=[]
    result="void"
    doc="Destroy removes the node and its children at the end of the phase."
    example="node.Destroy()"
  }
  method "Enabled" recv="NodeRef" {
    params=[]
    result="bool"
    doc="Enabled reports the node's own enabled flag, ignoring its parents."
    example="if !Door.Enabled() {"
  }
  method "Find" recv="NodeRef" {
    params=["string"]
    result="NodeRef"
    names=["path"]
    doc="Find resolves a path relative to the node: Weapon/Gun, ../Sibling or /Root/Player."
    example="muzzle := node.Find(\"Weapon/Muzzle\")"
  }
  method "HasTag" recv="NodeRef" {
    params=["string"]
    result="bool"
    names=["tag"]
    doc="HasTag reports whether the node has the tag or a tag under it: Enemy matches Enemy.Flying."
    example="if other.HasTag(\"Enemy\") {"
  }
  method "IsAlive" recv="NodeRef" {
    params=[]
    result="bool"
    doc="IsAlive reports whether the node exists. It is false right after Destroy."
    example="if Target != nil && Target.IsAlive() {"
  }
  method "IsPrefabInstance" recv="NodeRef" {
    params=[]
    result="bool"
    doc="IsPrefabInstance reports whether the node is a prefab copy or lies inside one."
    example="if node.IsPrefabInstance() {"
  }
  method "Name" recv="NodeRef" {
    params=[]
    result="string"
    doc="Name returns the node name, unique among its siblings."
    example="log.Info(node.Name())"
  }
  method "Parent" recv="NodeRef" {
    params=[]
    result="NodeRef"
    doc="Parent returns the parent node, or nil for top-level nodes."
    example="owner := node.Parent()"
  }
  method "Position" recv="NodeRef" {
    params=[]
    result="Vec2"
    doc="Position returns the local position relative to the parent."
    example="p := node.Position()"
  }
  method "Position3" recv="NodeRef" {
    params=[]
    result="Vec3"
    doc="Position3 returns the local 3D position."
    example="p := node.Position3()"
  }
  method "PrefabRoot" recv="NodeRef" {
    params=[]
    result="NodeRef"
    doc="PrefabRoot returns the root of the nearest prefab copy that holds the node, the node itself for a root, or nil."
    example="owner := node.PrefabRoot()\nowner.Destroy()"
  }
  method "RemoveTag" recv="NodeRef" {
    params=["string"]
    result="bool"
    names=["tag"]
    doc="RemoveTag removes a tag and returns whether the node had it."
  }
  method "Rotation" recv="NodeRef" {
    params=[]
    result="float"
    doc="Rotation returns the local rotation in radians, clockwise."
    example="a := node.Rotation()"
  }
  method "Rotation3" recv="NodeRef" {
    params=[]
    result="Quat"
    doc="Rotation3 returns the local 3D rotation."
    example="q := node.Rotation3()"
  }
  method "Scale" recv="NodeRef" {
    params=[]
    result="Vec2"
    doc="Scale returns the local scale."
    example="s := node.Scale()"
  }
  method "SetEnabled" recv="NodeRef" {
    params=["bool"]
    result="void"
    names=["enabled"]
    doc="SetEnabled turns the node on or off. Disabled nodes and their children are not drawn."
    example="Shield.SetEnabled(false)"
  }
  method "SetPosition" recv="NodeRef" {
    params=["Vec2"]
    result="void"
    names=["p"]
    doc="SetPosition sets the local position."
    example="node.SetPosition(node.Position() + velocity * dt)"
  }
  method "SetPosition3" recv="NodeRef" {
    params=["Vec3"]
    result="void"
    names=["p"]
    doc="SetPosition3 sets the local 3D position."
    example="node.SetPosition3(node.Position3() + Vec3{0, 0, -Speed * dt})"
  }
  method "SetRotation" recv="NodeRef" {
    params=["float"]
    result="void"
    names=["radians"]
    doc="SetRotation sets the local rotation in radians."
    example="node.SetRotation(node.Rotation() + Spin * dt)"
  }
  method "SetRotation3" recv="NodeRef" {
    params=["Quat"]
    result="void"
    names=["q"]
    doc="SetRotation3 sets the local 3D rotation."
    example="node.SetRotation3(math.QuatEuler(0, angle, 0))"
  }
  method "SetScale" recv="NodeRef" {
    params=["Vec2"]
    result="void"
    names=["scale"]
    doc="SetScale sets the local scale. A negative X mirrors the node."
    example="node.SetScale(Vec2{-1, 1})"
  }
  method "SetTransform2D" recv="NodeRef" {
    params=["Transform2D"]
    result="void"
    names=["t"]
    doc="SetTransform2D replaces the local 2D transform."
    example="node.SetTransform2D(t)"
  }
  method "SetTransform3D" recv="NodeRef" {
    params=["Transform3D"]
    result="void"
    names=["t"]
    doc="SetTransform3D replaces the local 3D transform."
    example="node.SetTransform3D(t)"
  }
  method "Space" recv="NodeRef" {
    params=[]
    result="int"
    doc="Space returns 0 for 2D nodes and 1 for 3D nodes."
    example="if node.Space() == 1 {"
  }
  method "Transform2D" recv="NodeRef" {
    params=[]
    result="Transform2D"
    doc="Transform2D returns a copy of the local 2D transform. Change it and pass it to SetTransform2D."
    example="t := node.Transform2D()\nt.Position.X += 1\nnode.SetTransform2D(t)"
  }
  method "Transform3D" recv="NodeRef" {
    params=[]
    result="Transform3D"
    doc="Transform3D returns a copy of the local 3D transform."
    example="t := node.Transform3D()\nt.Position.Y += 1\nnode.SetTransform3D(t)"
  }
  method "WorldPosition" recv="NodeRef" {
    params=[]
    result="Vec2"
    doc="WorldPosition returns the position in world space, as of the last transform pass."
    example="d := math.Dist(node.WorldPosition(), Target.WorldPosition())"
  }
  cmethod "Pause" comp="animation.AnimationPlayer" {
    params=[]
    result="void"
    doc="Pause holds the clip where it is."
  }
  cmethod "Play" comp="animation.AnimationPlayer" {
    params=["AssetRef<anim>"]
    result="void"
    names=["clip"]
    doc="Play starts a clip from its beginning on the next fixed step; nil plays the current clip again."
    example="node.Get<AnimationPlayer>().Play(Attack)"
  }
  cmethod "Resume" comp="animation.AnimationPlayer" {
    params=[]
    result="void"
    doc="Resume continues a paused clip."
  }
  cmethod "Seek" comp="animation.AnimationPlayer" {
    params=["float"]
    result="void"
    names=["time"]
    doc="Seek jumps to a time inside the clip on the next fixed step without firing the events in between."
  }
  cmethod "SetSpeed" comp="animation.AnimationPlayer" {
    params=["float"]
    result="void"
    names=["speed"]
    doc="SetSpeed changes the playback speed; a negative speed plays backwards."
  }
  cmethod "Stop" comp="animation.AnimationPlayer" {
    params=[]
    result="void"
    doc="Stop ends the clip on the next fixed step: tracks with onEnd=restore get back the values they had before Play, Finished runs with cycle -1."
  }
  cmethod "CrossFade" comp="animation.Animator" {
    params=["string", "float"]
    result="void"
    names=["state", "seconds"]
    doc="CrossFade blends into a state over some seconds, starting on the next fixed step."
  }
  cmethod "GetBool" comp="animation.Animator" {
    params=["string"]
    result="bool"
    names=["name"]
    doc="GetBool reads a bool or trigger parameter."
  }
  cmethod "GetFloat" comp="animation.Animator" {
    params=["string"]
    result="float"
    names=["name"]
    doc="GetFloat reads a float parameter."
  }
  cmethod "GetInt" comp="animation.Animator" {
    params=["string"]
    result="int"
    names=["name"]
    doc="GetInt reads an int parameter."
  }
  cmethod "IsState" comp="animation.Animator" {
    params=["string"]
    result="bool"
    names=["state"]
    doc="IsState reports whether the animator is in a state; during a blend that is the state it blends into."
  }
  cmethod "Play" comp="animation.Animator" {
    params=["string"]
    result="void"
    names=["state"]
    doc="Play switches to a state on the next fixed step, without a blend."
  }
  cmethod "ResetTrigger" comp="animation.Animator" {
    params=["string"]
    result="void"
    names=["name"]
    doc="ResetTrigger clears a trigger that has not fired yet."
  }
  cmethod "SetBool" comp="animation.Animator" {
    params=["string", "bool"]
    result="void"
    names=["name", "value"]
    doc="SetBool sets a bool parameter; transitions read it on the next fixed step."
  }
  cmethod "SetFloat" comp="animation.Animator" {
    params=["string", "float"]
    result="void"
    names=["name", "value"]
    doc="SetFloat sets a float parameter."
    example="anim.SetFloat(\"Speed\", math.Abs(motion.Velocity.X))"
  }
  cmethod "SetInt" comp="animation.Animator" {
    params=["string", "int"]
    result="void"
    names=["name", "value"]
    doc="SetInt sets an int parameter."
  }
  cmethod "SetTrigger" comp="animation.Animator" {
    params=["string"]
    result="void"
    names=["name"]
    doc="SetTrigger sets a trigger for the next fixed step; a transition that uses it, or the end of that step, clears it."
  }
  cmethod "StateName" comp="animation.Animator" {
    params=["int"]
    result="string"
    names=["index"]
    doc="StateName returns the name of a state index, as StateEntered and StateExited report it."
  }
  cmethod "IsPlaying" comp="audio.AudioSource2D" {
    params=[]
    result="bool"
    doc="IsPlaying reports whether the source plays a sound."
  }
  cmethod "Play" comp="audio.AudioSource2D" {
    params=[]
    result="void"
    doc="Play starts the source from the beginning, stopping a sound it already plays."
  }
  cmethod "Stop" comp="audio.AudioSource2D" {
    params=[]
    result="void"
    doc="Stop ends the sound of the source with a short fade."
  }
  cmethod "StopFade" comp="audio.AudioSource2D" {
    params=["float"]
    result="void"
    names=["seconds"]
    doc="StopFade fades the sound of the source out over seconds."
  }
  cmethod "Snap" comp="camera.CameraFollow2D" {
    params=[]
    result="void"
    doc="Snap moves the camera onto the target at once, for example after a teleport."
  }
  cmethod "Add" comp="camera.CameraShake2D" {
    params=["float"]
    result="void"
    names=["trauma"]
    doc="Add adds trauma to the output of this camera; trauma is capped at 1."
  }
  cmethod "IsActive" comp="camera.VirtualCamera2D" {
    params=[]
    result="bool"
    doc="IsActive reports whether this virtual camera drives its output now."
  }
  cmethod "GetBool" comp="engine.MaterialOverride" {
    params=["string"]
    result="bool"
    doc="Reads the effective bool parameter."
  }
  cmethod "GetColor" comp="engine.MaterialOverride" {
    params=["string"]
    result="Color"
    doc="Reads the effective linear Color of a parameter declared with the color hint."
  }
  cmethod "GetFloat" comp="engine.MaterialOverride" {
    params=["string"]
    result="float"
    doc="Reads the effective float after shader default, material value and node override."
  }
  cmethod "GetInt" comp="engine.MaterialOverride" {
    params=["string"]
    result="int"
    doc="Reads the exact signed int32 effective parameter."
  }
  cmethod "GetVec2" comp="engine.MaterialOverride" {
    params=["string"]
    result="Vec2"
    doc="Reads the effective vec2 parameter."
  }
  cmethod "GetVec3" comp="engine.MaterialOverride" {
    params=["string"]
    result="Vec3"
    doc="Reads the effective vec3 parameter."
  }
  cmethod "GetVec4" comp="engine.MaterialOverride" {
    params=["string"]
    result="struct:aego/material.Vec4"
    doc="Reads four numerical effective lanes as material.Vec4, without color conversion."
  }
  cmethod "GetVec4Lane" comp="engine.MaterialOverride" {
    params=["string", "int"]
    result="float"
    doc="Reads one lane from an ordinary vec4 parameter. The lane index must be from 0 through 3."
  }
  cmethod "Reset" comp="engine.MaterialOverride" {
    params=["string"]
    result="bool"
    doc="Removes the explicit instance value and inherits the shared material value. Returns whether an explicit value existed."
  }
  cmethod "SetBool" comp="engine.MaterialOverride" {
    params=["string", "bool"]
    result="void"
    doc="Sets an instance bool parameter on this node."
  }
  cmethod "SetColor" comp="engine.MaterialOverride" {
    params=["string", "Color"]
    result="void"
    doc="Sets a linear Color instance parameter declared with the color hint."
  }
  cmethod "SetFloat" comp="engine.MaterialOverride" {
    params=["string", "float"]
    result="void"
    doc="Sets an instance float parameter on this node. Type mismatch leaves its previous value unchanged."
  }
  cmethod "SetInt" comp="engine.MaterialOverride" {
    params=["string", "int"]
    result="void"
    doc="Sets an exact signed int32 instance parameter. Values outside the int32 range are rejected."
  }
  cmethod "SetVec2" comp="engine.MaterialOverride" {
    params=["string", "Vec2"]
    result="void"
    doc="Sets an instance vec2 parameter on this node."
  }
  cmethod "SetVec3" comp="engine.MaterialOverride" {
    params=["string", "Vec3"]
    result="void"
    doc="Sets an instance vec3 parameter on this node."
  }
  cmethod "SetVec4" comp="engine.MaterialOverride" {
    params=["string", "struct:aego/material.Vec4"]
    result="void"
    doc="Sets four numerical instance lanes using material.Vec4 without color conversion."
  }
  cmethod "Damage" comp="gameplay.Health" {
    params=["int", "NodeRef"]
    result="bool"
    names=["amount", "source"]
    doc="Damage removes hit points and reports whether they were removed: not while invulnerable, dead or for amounts below 1."
  }
  cmethod "Heal" comp="gameplay.Health" {
    params=["int"]
    result="void"
    names=["amount"]
    doc="Heal adds hit points up to Max; it does nothing while dead."
  }
  cmethod "Kill" comp="gameplay.Health" {
    params=["NodeRef"]
    result="void"
    names=["source"]
    doc="Kill sets the hit points to zero."
  }
  cmethod "Revive" comp="gameplay.Health" {
    params=["int"]
    result="void"
    names=["hp"]
    doc="Revive brings the node back with this many hit points; 0 means Max."
  }
  cmethod "SetInvulnerable" comp="gameplay.Health" {
    params=["float"]
    result="void"
    names=["seconds"]
    doc="SetInvulnerable ignores damage for some seconds of game time."
  }
  cmethod "Activate" comp="gameplay.Hitbox2D" {
    params=[]
    result="void"
    doc="Activate starts a new attack: targets hit before can be hit again."
  }
  cmethod "Deactivate" comp="gameplay.Hitbox2D" {
    params=[]
    result="void"
    doc="Deactivate stops dealing damage."
  }
  cmethod "Pulse" comp="gameplay.Hitbox2D" {
    params=[]
    result="void"
    doc="Pulse deals one round of damage in the next step, active or not."
  }
  cmethod "AddDisplacement" comp="gameplay.Motion2D" {
    params=["Vec2"]
    result="void"
    names=["offset"]
    doc="AddDisplacement moves by an offset in world units on the next step, through walls and slopes like a move, without changing the velocity; root motion of an Animator uses it."
  }
  cmethod "AddVelocity" comp="gameplay.Motion2D" {
    params=["Vec2"]
    result="void"
    names=["velocity"]
    doc="AddVelocity adds a push once, for knockback."
  }
  cmethod "Dash" comp="gameplay.Motion2D" {
    params=["Vec2", "float"]
    result="void"
    names=["velocity", "seconds"]
    doc="Dash moves at a fixed velocity for some seconds."
  }
  cmethod "Jump" comp="gameplay.Motion2D" {
    params=[]
    result="void"
    doc="Jump jumps on the next step if grounded, within coyote time or later within the jump buffer."
  }
  cmethod "JumpReleased" comp="gameplay.Motion2D" {
    params=[]
    result="void"
    doc="JumpReleased cuts a rising jump by Jump Cut Multiplier."
  }
  cmethod "Move" comp="gameplay.Motion2D" {
    params=["float"]
    result="void"
    names=["x"]
    doc="Move sets the horizontal input, -1..1; it stays until the next Move."
  }
  cmethod "MoveDir" comp="gameplay.Motion2D" {
    params=["Vec2"]
    result="void"
    names=["dir"]
    doc="MoveDir sets the top-down input; a longer vector is cut to length 1."
  }
  cmethod "Stop" comp="gameplay.Motion2D" {
    params=[]
    result="void"
    doc="Stop zeroes the velocity and ends a dash."
  }
  cmethod "Teleport" comp="gameplay.Motion2D" {
    params=["Vec2"]
    result="void"
    names=["position"]
    doc="Teleport moves to a position on the next step and resets velocity and state."
  }
  cmethod "SetPoint" comp="gameplay.Respawn" {
    params=["Vec2"]
    result="void"
    names=["position"]
    doc="SetPoint sets the respawn point."
  }
  cmethod "Trigger" comp="gameplay.Respawn" {
    params=[]
    result="void"
    doc="Trigger respawns the node after Delay."
  }
  cmethod "Go" comp="gameplay.StateMachine" {
    params=["string"]
    result="bool"
    names=["state"]
    doc="Go switches to a state after the current hook returns; Exit of the old state and Enter of the new one run in between. Returns false for an unknown state."
  }
  cmethod "Is" comp="gameplay.StateMachine" {
    params=["string"]
    result="bool"
    names=["state"]
    doc="Is reports whether the machine is in a state."
  }
  cmethod "TimeIn" comp="gameplay.StateMachine" {
    params=[]
    result="float"
    doc="TimeIn returns the seconds spent in the current state."
  }
  cmethod "Burst" comp="particles.ParticleSystem2D" {
    params=["int"]
    result="void"
    names=["count"]
    doc="Requests count births at the emitter. Does not start automatic emission."
    example="Dust.Get<ParticleSystem2D>().Burst(8)"
  }
  cmethod "Clear" comp="particles.ParticleSystem2D" {
    params=[]
    result="void"
    doc="Removes live particles without changing the emission schedule."
  }
  cmethod "Count" comp="particles.ParticleSystem2D" {
    params=[]
    result="int"
    doc="Returns the current number of living particles on the emitter."
  }
  cmethod "Emitting" comp="particles.ParticleSystem2D" {
    params=[]
    result="bool"
    doc="Reports whether automatic emission is running."
  }
  cmethod "Play" comp="particles.ParticleSystem2D" {
    params=[]
    result="void"
    doc="Starts automatic emission. Repeating Play while emitting does nothing."
  }
  cmethod "Playing" comp="particles.ParticleSystem2D" {
    params=[]
    result="bool"
    doc="Reports whether the schedule is running or particles remain."
  }
  cmethod "Restart" comp="particles.ParticleSystem2D" {
    params=[]
    result="void"
    doc="Clears live particles and starts a new emission schedule."
  }
  cmethod "Stop" comp="particles.ParticleSystem2D" {
    params=[]
    result="void"
    doc="Stops new emissions and lets live particles drain."
  }
  cmethod "StopAndClear" comp="particles.ParticleSystem2D" {
    params=[]
    result="void"
    doc="Stops automatic emission and immediately removes living particles."
  }
  cmethod "ApplyForce" comp="physics.Body2D" {
    params=["Vec2"]
    result="void"
    names=["force"]
    doc="ApplyForce pushes the body's center of mass during the next physics step. Call it from FixedUpdate."
  }
  cmethod "ApplyForceAt" comp="physics.Body2D" {
    params=["Vec2", "Vec2"]
    result="void"
    names=["force", "point"]
    doc="ApplyForceAt pushes the body at a world point, which also spins it."
  }
  cmethod "ApplyImpulse" comp="physics.Body2D" {
    params=["Vec2"]
    result="void"
    names=["impulse"]
    doc="ApplyImpulse changes the velocity at once, scaled by mass."
    example="body.ApplyImpulse(Vec2{Y: -jumpImpulse})"
  }
  cmethod "ApplyImpulseAt" comp="physics.Body2D" {
    params=["Vec2", "Vec2"]
    result="void"
    names=["impulse", "point"]
    doc="ApplyImpulseAt applies an impulse at a world point."
  }
  cmethod "ApplyTorque" comp="physics.Body2D" {
    params=["float"]
    result="void"
    names=["torque"]
    doc="ApplyTorque spins the body during the next physics step."
  }
  cmethod "Mass" comp="physics.Body2D" {
    params=[]
    result="float"
    doc="Mass returns the mass computed from the colliders or the override."
  }
  cmethod "MoveTo" comp="physics.Body2D" {
    params=["Vec2", "float"]
    result="void"
    names=["position", "angle"]
    doc="MoveTo drives a kinematic body to the pose by the end of the next physics step, pushing dynamic bodies on the way. Call it from FixedUpdate."
  }
  cmethod "SetAngularVelocity" comp="physics.Body2D" {
    params=["float"]
    result="void"
    names=["velocity"]
    doc="SetAngularVelocity sets the spin in radians per second."
  }
  cmethod "SetVelocity" comp="physics.Body2D" {
    params=["Vec2"]
    result="void"
    names=["velocity"]
    doc="SetVelocity sets the linear velocity in units per second."
  }
  cmethod "Sleep" comp="physics.Body2D" {
    params=[]
    result="void"
    doc="Sleep stops the body until something touches it."
  }
  cmethod "Teleport" comp="physics.Body2D" {
    params=["Vec2", "float"]
    result="void"
    names=["position", "angle"]
    doc="Teleport moves the body to a world pose without sweeping, keeping its velocity."
  }
  cmethod "WakeUp" comp="physics.Body2D" {
    params=[]
    result="void"
    doc="WakeUp makes a sleeping body simulate again."
  }
  cmethod "SetBool" comp="render2d.PostProcess" {
    params=["string", "bool"]
    result="void"
    doc="Sets a boolean parameter by instanceID:Field."
  }
  cmethod "SetEffectEnabled" comp="render2d.PostProcess" {
    params=["string", "bool"]
    result="void"
    doc="Enables or disables an effect by its stable instance ID."
  }
  cmethod "SetFloat" comp="render2d.PostProcess" {
    params=["string", "float"]
    result="void"
    doc="Sets a float parameter using instanceID:Field, without changing any shared material."
  }
  cmethod "SetInt" comp="render2d.PostProcess" {
    params=["string", "int"]
    result="void"
    doc="Sets a signed int32 parameter by instanceID:Field."
  }
  cmethod "SetVec2" comp="render2d.PostProcess" {
    params=["string", "Vec2"]
    result="void"
    doc="Sets a vec2 parameter using instanceID:Field."
  }
  cmethod "SetVec3" comp="render2d.PostProcess" {
    params=["string", "Vec3"]
    result="void"
    doc="Sets a vec3 parameter by instanceID:Field."
  }
  cmethod "SetVec4" comp="render2d.PostProcess" {
    params=["string", "struct:aego/material.Vec4"]
    result="void"
    doc="Sets a vec4 parameter by instanceID:Field."
  }
  hmethod "Done" handle="aego/action.Action" {
    params=[]
    result="bool"
    doc="Done reports whether the action ended, was stopped or is nil."
  }
  hmethod "Running" handle="aego/action.Action" {
    params=[]
    result="bool"
    doc="Running is the opposite of Done."
  }
  hmethod "Stop" handle="aego/action.Action" {
    params=[]
    result="void"
    doc="Stop stops every unfinished step; the properties keep their current values."
  }
  hmethod "Then" handle="aego/action.Action" {
    params=["Handle<aego/tween.Tween>"]
    result="Handle<aego/action.Action>"
    names=["tween"]
    doc="Then adds a tween created in this frame; it waits for its turn."
  }
  hmethod "ThenAction" handle="aego/action.Action" {
    params=["Handle<aego/action.Action>"]
    result="Handle<aego/action.Action>"
    names=["action"]
    doc="ThenAction adds another action that has not started."
  }
  hmethod "ThenTimer" handle="aego/action.Action" {
    params=["Handle<aego/timer.Timer>"]
    result="Handle<aego/action.Action>"
    names=["timer"]
    doc="ThenTimer adds a timer created in this frame; the step ends when the timer ends."
  }
  hmethod "Wait" handle="aego/action.Action" {
    params=["float"]
    result="Handle<aego/action.Action>"
    names=["seconds"]
    doc="Wait adds a pause in game seconds."
  }
  hmethod "Done" handle="aego/audio.Sound" {
    params=[]
    result="bool"
    doc="Done reports whether the sound ended, was stopped or is nil."
  }
  hmethod "Pause" handle="aego/audio.Sound" {
    params=[]
    result="void"
    doc="Pause holds the sound where it is."
  }
  hmethod "Playing" handle="aego/audio.Sound" {
    params=[]
    result="bool"
    doc="Playing reports whether the sound is audible now: not done, not stopping and not paused."
  }
  hmethod "Position" handle="aego/audio.Sound" {
    params=[]
    result="float"
    doc="Position returns the seconds played, within the loop for a looping sound."
  }
  hmethod "Resume" handle="aego/audio.Sound" {
    params=[]
    result="void"
    doc="Resume continues a paused sound."
  }
  hmethod "SetPan" handle="aego/audio.Sound" {
    params=["float"]
    result="void"
    names=["pan"]
    doc="SetPan pans a sound that is not spatial, -1 to 1."
  }
  hmethod "SetPitch" handle="aego/audio.Sound" {
    params=["float"]
    result="void"
    names=["pitch"]
    doc="SetPitch changes speed and pitch, 0.25 to 4."
  }
  hmethod "SetVolume" handle="aego/audio.Sound" {
    params=["float"]
    result="void"
    names=["volume"]
    doc="SetVolume changes the volume with a short ramp."
  }
  hmethod "Stop" handle="aego/audio.Sound" {
    params=[]
    result="void"
    doc="Stop ends the sound with a short fade."
  }
  hmethod "StopFade" handle="aego/audio.Sound" {
    params=["float"]
    result="void"
    names=["seconds"]
    doc="StopFade fades the sound out over seconds."
  }
  hmethod "Done" handle="aego/camera.Blend" {
    params=[]
    result="bool"
    doc="Done reports whether the blend ended, was replaced or is nil."
  }
  hmethod "Running" handle="aego/camera.Blend" {
    params=[]
    result="bool"
    doc="Running is the opposite of Done."
  }
  hmethod "Stop" handle="aego/camera.Blend" {
    params=[]
    result="void"
    doc="Stop ends the blend at the target camera."
  }
  hmethod "Cancel" handle="aego/timer.Timer" {
    params=[]
    result="void"
    doc="Cancel ends the timer without firing."
  }
  hmethod "Count" handle="aego/timer.Timer" {
    params=[]
    result="int"
    doc="Count returns how many times the timer has fired."
  }
  hmethod "Done" handle="aego/timer.Timer" {
    params=[]
    result="bool"
    doc="Done reports whether the timer ended, was cancelled or is nil."
  }
  hmethod "Pause" handle="aego/timer.Timer" {
    params=[]
    result="void"
    doc="Pause stops the countdown."
  }
  hmethod "Ready" handle="aego/timer.Timer" {
    params=[]
    result="bool"
    doc="Ready reports whether a cooldown can be used."
  }
  hmethod "Remaining" handle="aego/timer.Timer" {
    params=[]
    result="float"
    doc="Remaining returns the seconds left until the next fire."
  }
  hmethod "Repeat" handle="aego/timer.Timer" {
    params=["int"]
    result="Handle<aego/timer.Timer>"
    names=["count"]
    doc="Repeat makes the timer fire n times; -1 repeats until Cancel."
  }
  hmethod "Restart" handle="aego/timer.Timer" {
    params=[]
    result="bool"
    doc="Restart starts the countdown again; it does nothing on a one-shot timer that already fired."
  }
  hmethod "Resume" handle="aego/timer.Timer" {
    params=[]
    result="void"
    doc="Resume continues a paused countdown."
  }
  hmethod "Unscaled" handle="aego/timer.Timer" {
    params=[]
    result="Handle<aego/timer.Timer>"
    doc="Unscaled counts real time, also while the game is paused."
  }
  hmethod "Use" handle="aego/timer.Timer" {
    params=[]
    result="bool"
    doc="Use takes a ready cooldown and starts its wait; it returns false while the cooldown runs."
  }
  hmethod "Curve" handle="aego/tween.Tween" {
    params=["Curve"]
    result="Handle<aego/tween.Tween>"
    names=["curve"]
    doc="Curve replaces the easing with a curve field; its time range is stretched over the duration."
  }
  hmethod "Delay" handle="aego/tween.Tween" {
    params=["float"]
    result="Handle<aego/tween.Tween>"
    names=["seconds"]
    doc="Delay waits before the tween starts; the start value is read when the delay ends. Call it right after creating the tween."
    example="tween.ToFloat(node, \"Light.Range\", 4, 1, curve.Linear).Delay(0.5)"
  }
  hmethod "Done" handle="aego/tween.Tween" {
    params=[]
    result="bool"
    doc="Done reports whether the tween finished, was stopped or is nil."
  }
  hmethod "Loop" handle="aego/tween.Tween" {
    params=["int"]
    result="Handle<aego/tween.Tween>"
    names=["count"]
    doc="Loop plays the tween n times from the start; -1 repeats until Stop."
  }
  hmethod "PingPong" handle="aego/tween.Tween" {
    params=["int"]
    result="Handle<aego/tween.Tween>"
    names=["legs"]
    doc="PingPong plays n legs, every second one backwards; 2 goes there and back, -1 repeats until Stop."
  }
  hmethod "Running" handle="aego/tween.Tween" {
    params=[]
    result="bool"
    doc="Running is the opposite of Done."
  }
  hmethod "Stop" handle="aego/tween.Tween" {
    params=[]
    result="void"
    doc="Stop ends the tween where it is; the property keeps its current value."
  }
  hmethod "Unscaled" handle="aego/tween.Tween" {
    params=[]
    result="Handle<aego/tween.Tween>"
    doc="Unscaled runs the tween in real time, also while the game is paused."
  }
  csignal "Started" comp="audio.AudioSource2D" {
    params=[]
    doc="Started runs when the source starts a sound."
  }
  csignal "Finished" comp="audio.AudioSource2D" {
    params=["bool"]
    names=["finished"]
    doc="Finished runs when the sound of the source ends; finished is false after Stop or when it was cut off."
  }
  csignal "Finished" comp="animation.AnimationPlayer" {
    params=["int"]
    names=["cycle"]
    doc="Finished runs when a clip that does not loop ends, with cycle 0, or after Stop, with cycle -1."
  }
  csignal "Event" comp="animation.AnimationPlayer" {
    params=["int", "float"]
    names=["id", "payload"]
    doc="Event runs when the clip reaches an event; anim.EventName(id) gives its name."
  }
  csignal "StateEntered" comp="animation.Animator" {
    params=["int"]
    names=["state"]
    doc="StateEntered runs when the animator enters a state, at the start of the transition."
  }
  csignal "StateExited" comp="animation.Animator" {
    params=["int"]
    names=["state"]
    doc="StateExited runs when a state stops playing, at the end of the transition."
  }
  csignal "Event" comp="animation.Animator" {
    params=["int", "float"]
    names=["id", "payload"]
    doc="Event runs when a state reaches an event of its clip; during a blend the state's event policy decides which side reports."
  }
  csignal "Landed" comp="gameplay.Motion2D" {
    params=["float"]
    names=["speed"]
    doc="Landed fires when the character touches a floor, with the falling speed."
  }
  csignal "LeftGround" comp="gameplay.Motion2D" {
    params=[]
    doc="LeftGround fires when the character walks off a floor without jumping."
  }
  csignal "Jumped" comp="gameplay.Motion2D" {
    params=[]
    doc="Jumped fires when a jump starts."
  }
  csignal "HitWall" comp="gameplay.Motion2D" {
    params=["Vec2"]
    names=["normal"]
    doc="HitWall fires when the character starts touching a wall."
  }
  csignal "HitCeiling" comp="gameplay.Motion2D" {
    params=[]
    doc="HitCeiling fires when the character bumps into a ceiling."
  }
  csignal "Climbed" comp="gameplay.Motion2D" {
    params=[]
    doc="Climbed fires when the character starts climbing onto a ledge."
  }
  csignal "Damaged" comp="gameplay.Health" {
    params=["int", "NodeRef"]
    names=["amount", "source"]
    doc="Damaged fires once per step with the damage taken in it."
  }
  csignal "Healed" comp="gameplay.Health" {
    params=["int"]
    names=["amount"]
    doc="Healed fires with the hit points restored."
  }
  csignal "Died" comp="gameplay.Health" {
    params=["NodeRef"]
    names=["source"]
    doc="Died fires once when the hit points reach zero."
  }
  csignal "Revived" comp="gameplay.Health" {
    params=[]
    doc="Revived fires after Revive."
  }
  csignal "Hit" comp="gameplay.Hitbox2D" {
    params=["NodeRef", "int"]
    names=["target", "damage"]
    doc="Hit fires for each target damaged."
  }
  csignal "Reached" comp="gameplay.Checkpoint2D" {
    params=["NodeRef"]
    names=["by"]
    doc="Reached fires when a node takes this checkpoint."
  }
  csignal "Respawned" comp="gameplay.Respawn" {
    params=[]
    doc="Respawned fires when the node is back at its point."
  }
  csignal "Collected" comp="gameplay.Pickup2D" {
    params=["NodeRef"]
    names=["by"]
    doc="Collected fires with the node that took the pickup."
  }
  csignal "Changed" comp="gameplay.StateMachine" {
    params=["int", "int"]
    names=["from", "to"]
    doc="Changed fires after a state change with the indices of the old and the new state."
  }
  csignal "Completed" comp="particles.ParticleSystem2D" {
    params=[]
    doc="A finite emission schedule has ended and its last particle expired. A presentation signal, not a gameplay timer."
  }
  hsignal "Completed" handle="aego/action.Action" {
    params=["bool"]
    names=["finished"]
    doc="Completed runs once when the action ends; finished is false after Stop or when the node of its script died."
  }
  hsignal "Completed" handle="aego/audio.Sound" {
    params=["bool"]
    names=["finished"]
    doc="Completed runs once when the sound ends: finished is false after Stop, when it was cut off, or when its node died."
  }
  hsignal "Completed" handle="aego/camera.Blend" {
    params=["bool"]
    names=["finished"]
    doc="Completed runs once when the blend ends: finished is false after Stop or when another camera became active first."
  }
  hsignal "Fired" handle="aego/timer.Timer" {
    params=["int"]
    names=["count"]
    doc="Fired runs on every fire of the timer; count is the number of fires so far."
  }
  hsignal "Completed" handle="aego/tween.Tween" {
    params=["bool"]
    names=["finished"]
    doc="Completed runs once when the tween ends. Its finished parameter is true at the natural end, false after Stop, when a new tween on the same property replaced it, or when its node or target is gone."
  }
  component "engine.PrefabInstance" {
    short="PrefabInstance"
    category="engine"
    doc="Links a node to the prefab it was created from."
  }
  component "engine.Tags" {
    short="Tags"
    category="engine"
    doc="Tags names groups this node belongs to; scripts find them with scene.WithTag."
    builtin=true
  }
  component "engine.SpriteRenderer" {
    short="SpriteRenderer"
    category="engine"
    doc="Draws a texture region at the node transform."
    builtin=true
    field "Sprite" {
      type="AssetRef<texture>"
      readonly=false
      doc="Texture or atlas region to draw. Empty draws a solid rectangle in the tint color."
    }
    field "Material" {
      type="AssetRef<material>"
      readonly=false
      doc="Shared sprite-domain material. Per-node changes belong to MaterialOverride."
    }
    field "Layer" {
      type="int"
      readonly=false
      doc="Sorting layer. Higher layers are drawn on top of lower ones."
    }
    field "Order" {
      type="int"
      readonly=false
      doc="Order inside the layer. Higher values are drawn later, on top."
    }
    field "Tint" {
      type="Color"
      readonly=false
      doc="Color multiplied with the texture. Alpha controls transparency."
    }
    field "Origin" {
      type="Vec2"
      readonly=false
      doc="Pivot in normalized sprite space. (0.5, 0.5) is the center, (0, 0) the top-left corner."
    }
    field "Size" {
      type="Vec2"
      readonly=false
      doc="Size in world units. Zero uses the texture size divided by the camera zoom."
    }
    field "FlipX" {
      type="bool"
      readonly=false
      doc="Mirrors the sprite horizontally."
    }
    field "FlipY" {
      type="bool"
      readonly=false
      doc="Mirrors the sprite vertically."
    }
    field "Blend" {
      type="int"
      readonly=false
      doc="How the sprite blends with what is behind it: premultiplied alpha, opaque or additive."
    }
    field "Filter" {
      type="int"
      readonly=false
      doc="Texture sampling: nearest keeps pixel art sharp, linear smooths it."
    }
  }
  component "engine.Camera2D" {
    short="Camera2D"
    category="engine"
    doc="Renders an orthographic view from the node transform."
    builtin=true
    field "Zoom" {
      type="float"
      readonly=false
      doc="Pixels per world unit. Larger values show a smaller part of the world."
    }
    field "Viewport" {
      type="Rect"
      readonly=false
      doc="Part of the screen the camera draws into, in normalized coordinates."
    }
    field "Mask" {
      type="int"
      readonly=false
      doc="Visibility layers this camera renders. -1 renders every layer."
    }
    field "Order" {
      type="int"
      readonly=false
      doc="Cameras with a lower order render first."
    }
    field "Clear" {
      type="bool"
      readonly=false
      doc="Clears the viewport before drawing."
    }
    field "ClearColor" {
      type="Color"
      readonly=false
      doc="Background color used when clear is on."
    }
    field "Scale" {
      type="int"
      readonly=false
      doc="How the view adapts to the window: free, pixelPerfect or fitVirtual."
    }
    field "Virtual" {
      type="Vec2"
      readonly=false
      doc="Virtual resolution used by fitVirtual and pixelPerfect."
    }
    field "Active" {
      type="bool"
      readonly=false
      doc="Only active cameras render."
    }
  }
  component "engine.Mesh2D" {
    short="Mesh2D"
    category="engine"
    doc="Draws the standard mesh vertex layout in a 2D camera with a compatible Mesh2D material."
    builtin=true
    field "Mesh" {
      type="AssetRef<mesh>"
      readonly=false
      doc="Mesh asset with the standard position, normal, UV and vertex color layout."
    }
    field "Texture" {
      type="AssetRef<texture>"
      readonly=false
      doc="Main texture sampled in mesh UV coordinates. Empty uses white."
    }
    field "Material" {
      type="AssetRef<material>"
      readonly=false
      doc="Shared material asset. The shader domain must be mesh2d."
    }
    field "Tint" {
      type="Color"
      readonly=false
      doc="Linear color multiplied with the texture; alpha controls transparency."
    }
    field "Layer" {
      type="int"
      readonly=false
      doc="Visual layer for this 2D mesh."
    }
    field "Order" {
      type="int"
      readonly=false
      doc="Painter order among sprites and meshes in the same layer; higher values draw later."
    }
  }
  component "engine.MaterialOverride" {
    short="MaterialOverride"
    category="engine"
    doc="Overrides up to eight numeric shader parameters on this node. Removed parameters remain in the values list."
    builtin=true
  }
  component "render2d.PostProcess" {
    short="PostProcess"
    category="render2d"
    doc="Applies an ordered effect stack after all cameras sharing this camera's logical output, before UI."
    builtin=true
    field "Enabled" {
      type="bool"
      readonly=false
      doc="Enable this camera's output stack. Disabled stacks do not claim the output."
    }
  }
  component "engine.Light2D" {
    short="Light2D"
    category="engine"
    doc="Forward 2D diffuse light. Local +X defines Spot and Directional azimuth; presentation transforms also drive shadows."
    builtin=true
    field "Type" {
      type="int"
      readonly=false
      doc="Point, Spot, Directional or Sprite/cookie. Directional shadows are not supported."
    }
    field "Color" {
      type="Color"
      readonly=false
      doc="Linear light color; the color picker handles display conversion."
    }
    field "Intensity" {
      type="float"
      readonly=false
      doc="Nonnegative energy multiplier; zero disables this light's contribution."
    }
    field "Range" {
      type="float"
      readonly=false
      doc="Local light radius in world units, independent of node scale."
    }
    field "Height" {
      type="float"
      readonly=false
      doc="Virtual distance above the sprite surface for diffuse normal mapping; shadows remain planar."
    }
    field "InnerAngle" {
      type="float"
      readonly=false
      doc="Full Spot inner cone angle in radians, centered on local +X."
    }
    field "OuterAngle" {
      type="float"
      readonly=false
      doc="Full Spot outer cone angle in radians, no smaller than innerAngle."
    }
    field "Elevation" {
      type="float"
      readonly=false
      doc="Directional elevation above the surface in radians, greater than zero."
    }
    field "Falloff" {
      type="float"
      readonly=false
      doc="Nonnegative falloff exponent over normalized local-light distance."
    }
    field "Cookie" {
      type="AssetRef<texture>"
      readonly=false
      doc="Sprite light mask texture. Its own region and trim map to the light square."
    }
    field "Layers" {
      type="int"
      readonly=false
      doc="64-bit receiver visibility mask. -1 means all bits; zero receives no objects."
    }
    field "ShadowCasterMask" {
      type="int"
      readonly=false
      doc="64-bit shadow-occluder mask, independent of visibility and collision masks."
    }
    field "Shadows" {
      type="bool"
      readonly=false
      doc="Enable cached local-light shadow masks for Point, Spot and Sprite lights."
    }
    field "ShadowSoftness" {
      type="float"
      readonly=false
      doc="Bounded mask filtering radius; this is not a physical area-light penumbra."
    }
    field "Priority" {
      type="int"
      readonly=false
      doc="Higher priority is selected first when the per-draw light budget is exceeded."
    }
  }
  component "engine.LightOccluder2D" {
    short="LightOccluder2D"
    category="engine"
    doc="A planar shadow contour. Manual polygons require no Physics module; ShapeProvider reads local geometry through the shapes2d contract."
    builtin=true
    field "Source" {
      type="int"
      readonly=false
      doc="Use a manual polygon/chain or a registered local-shape provider."
    }
    field "Polygon" {
      type="[]Vec2"
      readonly=true
      doc="Simple local-space contour without holes; points follow the owner's presentation transform once."
    }
    field "Closed" {
      type="bool"
      readonly=false
      doc="Close the manual polygon. A ShapeProvider supplies each contour's closed state."
    }
    field "CullMode" {
      type="int"
      readonly=false
      doc="Shadow edge winding policy; independent of any physics one-sided setting."
    }
    field "Layers" {
      type="int"
      readonly=false
      doc="64-bit shadow participation mask. -1 is all bits; zero casts no shadows."
    }
    field "ShapeNode" {
      type="NodeRef"
      readonly=false
      doc="Source node for ShapeProvider. Empty uses this node; unresolved IDs are preserved."
    }
    field "Shape" {
      type="string"
      readonly=false
      doc="Stable provider shape key, such as physics.BoxCollider2D. Empty selects all of the source node's shapes."
    }
  }
  component "engine.LightingEnvironment2D" {
    short="LightingEnvironment2D"
    category="engine"
    doc="Lighting and output policy for a camera. An empty camera applies to the current output; overlapping environments are an error."
    builtin=true
    field "Camera" {
      type="NodeRef"
      readonly=false
      doc="Optional Camera2D node. Empty applies to all 2D views of this world."
    }
    field "AmbientColor" {
      type="Color"
      readonly=false
      doc="Linear ambient surface illumination. Default white preserves unlit-looking Lit scenes with no lights."
    }
    field "AmbientIntensity" {
      type="float"
      readonly=false
      doc="Nonnegative ambient energy multiplier."
    }
    field "ColorMode" {
      type="int"
      readonly=false
      doc="Auto chooses supported HDR for Lit output; LDR uses RGBA8 and HDR requests RGBA16F."
    }
    field "Exposure" {
      type="float"
      readonly=false
      doc="Positive display-resolve exposure, without changing UI or simulation."
    }
    field "ShadowResolution" {
      type="int"
      readonly=false
      doc="Power-of-two mask dimension between 64 and 2048. Initial profile uses 256."
    }
    field "MaxShadowedLights" {
      type="int"
      readonly=false
      doc="Per-camera local-shadow budget from 0 through 16; actual performance depends on the GPU."
    }
  }
  component "engine.Camera3D" {
    short="Camera3D"
    category="engine"
    doc="Renders a perspective view looking down the node -Z axis."
    builtin=true
    field "Fov" {
      type="float"
      readonly=false
      doc="Vertical field of view in degrees."
    }
    field "Near" {
      type="float"
      readonly=false
      doc="Distance to the near clipping plane."
    }
    field "Far" {
      type="float"
      readonly=false
      doc="Distance to the far clipping plane."
    }
    field "Viewport" {
      type="Rect"
      readonly=false
      doc="Part of the screen the camera draws into, in normalized coordinates."
    }
    field "Mask" {
      type="int"
      readonly=false
      doc="Visibility layers this camera renders. -1 renders every layer."
    }
    field "Order" {
      type="int"
      readonly=false
      doc="Cameras with a lower order render first."
    }
    field "Clear" {
      type="bool"
      readonly=false
      doc="Clears the viewport before drawing."
    }
    field "ClearColor" {
      type="Color"
      readonly=false
      doc="Background color used when clear is on."
    }
    field "Active" {
      type="bool"
      readonly=false
      doc="Only active cameras render."
    }
    field "Orthographic" {
      type="bool"
      readonly=false
      doc="Projects without perspective; sprites and meshes keep their size at any depth."
    }
    field "OrthoSize" {
      type="float"
      readonly=false
      doc="Half of the vertical extent in world units when orthographic is on."
    }
  }
  component "engine.MeshRenderer" {
    short="MeshRenderer"
    category="engine"
    doc="Draws an unlit mesh at the node transform."
    builtin=true
    field "Mesh" {
      type="AssetRef<mesh>"
      readonly=false
      doc="Mesh to draw: an imported .obj or a builtin Cube, Plane, Sphere or Cylinder."
    }
    field "Texture" {
      type="AssetRef<texture>"
      readonly=false
      doc="Texture mapped onto the mesh. Empty uses white."
    }
    field "Color" {
      type="Color"
      readonly=false
      doc="Color multiplied with the texture."
    }
    field "Blend" {
      type="int"
      readonly=false
      doc="Opaque writes depth. Premultiplied and additive are drawn after opaque meshes."
    }
    field "DoubleSided" {
      type="bool"
      readonly=false
      doc="Draws the back faces too."
    }
    field "Layer" {
      type="int"
      readonly=false
      doc="Sorting layer for transparent meshes."
    }
    field "Filter" {
      type="int"
      readonly=false
      doc="Texture sampling: nearest or linear."
    }
  }
  component "physics.Body2D" {
    short="Body2D"
    category="physics"
    doc="Simulates the node as a rigid body. Colliders on the node and its children form its shape."
    builtin=true
    field "Type" {
      type="int"
      readonly=false
      doc="static never moves, kinematic moves by velocity, dynamic reacts to forces and contacts."
    }
    field "MassMode" {
      type="int"
      readonly=false
      doc="auto takes the mass from collider density, override uses Mass."
    }
    field "Mass" {
      type="float"
      readonly=false
      doc="Mass in kilograms when Mass Mode is override."
    }
    field "GravityScale" {
      type="float"
      readonly=false
      doc="Multiplier of the project gravity for this body; 0 makes it float."
    }
    field "LinearDamping" {
      type="float"
      readonly=false
      doc="Slows the movement every step, like air resistance; 0 keeps the speed."
    }
    field "AngularDamping" {
      type="float"
      readonly=false
      doc="Slows the rotation every step; 0 keeps spinning."
    }
    field "FixedRotation" {
      type="bool"
      readonly=false
      doc="Keeps the body upright: contacts and torque never rotate it."
    }
    field "Bullet" {
      type="bool"
      readonly=false
      doc="Continuous collision against other dynamic bodies, so a fast body cannot pass through them. Costs more."
    }
    field "AllowSleep" {
      type="bool"
      readonly=false
      doc="Lets the body sleep after it comes to rest, which saves time; contacts and scripts wake it."
    }
    field "Interpolate" {
      type="bool"
      readonly=false
      doc="Draws the body between physics steps for smooth motion; scripts still see the exact pose."
    }
    field "Layer" {
      type="int"
      readonly=false
      doc="Collision layer, see Project Settings → Physics."
    }
    field "Mask" {
      type="int"
      readonly=false
      doc="Layers this body collides with."
    }
    field "Velocity" {
      type="Vec2"
      readonly=true
      doc="Velocity in units per second."
    }
    field "AngularVelocity" {
      type="float"
      readonly=true
      doc="Rotation speed in radians per second."
    }
    field "Awake" {
      type="bool"
      readonly=true
      doc="Whether the body is simulated this step or sleeping."
    }
  }
  component "physics.BoxCollider2D" {
    short="BoxCollider2D"
    category="physics"
    doc="Box shape in node space."
    builtin=true
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Position of the shape in node space."
    }
    field "IsTrigger" {
      type="bool"
      readonly=false
      doc="Detects overlaps and sends trigger events without pushing bodies apart."
    }
    field "Friction" {
      type="float"
      readonly=false
      doc="Resistance to sliding along other shapes; 0 is ice. Two shapes use the square root of the product."
    }
    field "Restitution" {
      type="float"
      readonly=false
      doc="Bounciness: 0 stops on impact, 1 bounces back at the same speed. Two shapes use the larger value."
    }
    field "Density" {
      type="float"
      readonly=false
      doc="Mass per square unit; gives the body its mass when Mass Mode is auto."
    }
    field "Size" {
      type="Vec2"
      readonly=false
      doc="Width and height in units, before the node scale."
    }
  }
  component "physics.CircleCollider2D" {
    short="CircleCollider2D"
    category="physics"
    doc="Circle shape. Needs a uniform node scale."
    builtin=true
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Position of the shape in node space."
    }
    field "IsTrigger" {
      type="bool"
      readonly=false
      doc="Detects overlaps and sends trigger events without pushing bodies apart."
    }
    field "Friction" {
      type="float"
      readonly=false
      doc="Resistance to sliding along other shapes; 0 is ice. Two shapes use the square root of the product."
    }
    field "Restitution" {
      type="float"
      readonly=false
      doc="Bounciness: 0 stops on impact, 1 bounces back at the same speed. Two shapes use the larger value."
    }
    field "Density" {
      type="float"
      readonly=false
      doc="Mass per square unit; gives the body its mass when Mass Mode is auto."
    }
    field "Radius" {
      type="float"
      readonly=false
      doc="Radius in units, before the node scale."
    }
  }
  component "physics.CapsuleCollider2D" {
    short="CapsuleCollider2D"
    category="physics"
    doc="Capsule along the local X axis; Length is the full extent including the caps."
    builtin=true
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Position of the shape in node space."
    }
    field "IsTrigger" {
      type="bool"
      readonly=false
      doc="Detects overlaps and sends trigger events without pushing bodies apart."
    }
    field "Friction" {
      type="float"
      readonly=false
      doc="Resistance to sliding along other shapes; 0 is ice. Two shapes use the square root of the product."
    }
    field "Restitution" {
      type="float"
      readonly=false
      doc="Bounciness: 0 stops on impact, 1 bounces back at the same speed. Two shapes use the larger value."
    }
    field "Density" {
      type="float"
      readonly=false
      doc="Mass per square unit; gives the body its mass when Mass Mode is auto."
    }
    field "Length" {
      type="float"
      readonly=false
      doc="Full length along the local X axis, caps included."
    }
    field "Radius" {
      type="float"
      readonly=false
      doc="Radius of the caps and half the thickness."
    }
  }
  component "physics.PolygonCollider2D" {
    short="PolygonCollider2D"
    category="physics"
    doc="Convex polygon of 3 to 8 points."
    builtin=true
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Position of the shape in node space."
    }
    field "IsTrigger" {
      type="bool"
      readonly=false
      doc="Detects overlaps and sends trigger events without pushing bodies apart."
    }
    field "Friction" {
      type="float"
      readonly=false
      doc="Resistance to sliding along other shapes; 0 is ice. Two shapes use the square root of the product."
    }
    field "Restitution" {
      type="float"
      readonly=false
      doc="Bounciness: 0 stops on impact, 1 bounces back at the same speed. Two shapes use the larger value."
    }
    field "Density" {
      type="float"
      readonly=false
      doc="Mass per square unit; gives the body its mass when Mass Mode is auto."
    }
    field "Points" {
      type="[]Vec2"
      readonly=true
      doc="Corners in node space, 3 to 8, forming a convex shape; edit them in the Scene View."
    }
  }
  component "physics.EdgeCollider2D" {
    short="EdgeCollider2D"
    category="physics"
    doc="Polyline for level geometry. OneSided lets bodies pass from below."
    builtin=true
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Position of the shape in node space."
    }
    field "IsTrigger" {
      type="bool"
      readonly=false
      doc="Detects overlaps and sends trigger events without pushing bodies apart."
    }
    field "Friction" {
      type="float"
      readonly=false
      doc="Resistance to sliding along other shapes; 0 is ice. Two shapes use the square root of the product."
    }
    field "Restitution" {
      type="float"
      readonly=false
      doc="Bounciness: 0 stops on impact, 1 bounces back at the same speed. Two shapes use the larger value."
    }
    field "Density" {
      type="float"
      readonly=false
      doc="Mass per square unit; gives the body its mass when Mass Mode is auto."
    }
    field "Points" {
      type="[]Vec2"
      readonly=true
      doc="Points of the line in node space, at least 2; edit them in the Scene View."
    }
    field "Loop" {
      type="bool"
      readonly=false
      doc="Joins the last point to the first, for closed outlines; needs at least 3 points."
    }
    field "OneSided" {
      type="bool"
      readonly=false
      doc="Collides only from above, so bodies can jump through from below, as on a platform."
    }
  }
  component "physics.DistanceJoint2D" {
    short="DistanceJoint2D"
    category="physics"
    doc="Keeps a distance between this body and the Target body. Length 0 uses the distance at start."
    builtin=true
    field "Target" {
      type="NodeRef"
      readonly=false
      doc="The other body; both nodes need a Rigid Body 2D."
    }
    field "AnchorA" {
      type="Vec2"
      readonly=false
      doc="Attachment point on this node, in node space."
    }
    field "AnchorB" {
      type="Vec2"
      readonly=false
      doc="Attachment point on the Target node, in its node space."
    }
    field "Length" {
      type="float"
      readonly=false
      doc="Rest length in units; 0 takes the distance between the anchors at start."
    }
    field "MinLength" {
      type="float"
      readonly=false
      doc="Shortest allowed length. With Min and Max both 0 the joint is a rigid rod, or a spring without a lower limit when Stiffness is set."
    }
    field "MaxLength" {
      type="float"
      readonly=false
      doc="Longest allowed length; a rope has Min 0 and Max at the rope length."
    }
    field "Stiffness" {
      type="float"
      readonly=false
      doc="Spring stiffness in newtons per unit; 0 makes the length rigid within Min and Max."
    }
    field "Damping" {
      type="float"
      readonly=false
      doc="Spring damping; 0 never damps, higher values stop the oscillation sooner."
    }
    field "CollideConnected" {
      type="bool"
      readonly=false
      doc="Lets the two connected bodies collide with each other."
    }
  }
  component "physics.RevoluteJoint2D" {
    short="RevoluteJoint2D"
    category="physics"
    doc="Pins this body to the Target body at Anchor, with an optional limit and motor."
    builtin=true
    field "Target" {
      type="NodeRef"
      readonly=false
      doc="The body this one turns around; both nodes need a Rigid Body 2D."
    }
    field "Anchor" {
      type="Vec2"
      readonly=false
      doc="Pivot point in this node's space; both bodies turn around it."
    }
    field "EnableLimit" {
      type="bool"
      readonly=false
      doc="Keeps the angle between Lower and Upper."
    }
    field "Lower" {
      type="float"
      readonly=false
      doc="Smallest angle in radians, relative to the angle at start."
    }
    field "Upper" {
      type="float"
      readonly=false
      doc="Largest angle in radians, relative to the angle at start."
    }
    field "EnableMotor" {
      type="bool"
      readonly=false
      doc="Drives the joint at Speed, up to Max Torque."
    }
    field "Speed" {
      type="float"
      readonly=false
      doc="Motor speed in radians per second; negative turns the other way."
    }
    field "MaxTorque" {
      type="float"
      readonly=false
      doc="Strongest torque the motor may apply; with 0 the motor does nothing."
    }
    field "CollideConnected" {
      type="bool"
      readonly=false
      doc="Lets the two connected bodies collide with each other."
    }
  }
  component "audio.AudioListener2D" {
    short="AudioListener2D"
    category="audio"
    doc="Hears spatial sound from its node. Without one the camera of the main output listens."
    builtin=true
    field "Active" {
      type="bool"
      readonly=false
      doc="The first active listener in the hierarchy is used."
    }
  }
  component "audio.AudioSource2D" {
    short="AudioSource2D"
    category="audio"
    doc="Plays a clip or an audio event from its node."
    builtin=true
    field "Clip" {
      type="AssetRef<audio>"
      readonly=false
      doc="Sound to play; ignored when Event is set."
    }
    field "Event" {
      type="AssetRef<data>"
      readonly=false
      doc="Audio event to play instead of Clip; its settings replace the fields below."
    }
    field "Volume" {
      type="float"
      readonly=false
      doc="Volume before the bus: 0 is silent, 1 is the clip as recorded."
    }
    field "Pitch" {
      type="float"
      readonly=false
      doc="Playback speed and pitch together: 1 is normal, 2 an octave higher and twice as fast."
    }
    field "Pan" {
      type="float"
      readonly=false
      doc="Left -1 to right 1, for a sound that is not spatial."
    }
    field "Bus" {
      type="int"
      readonly=false
      doc="Mixer bus."
    }
    field "Loop" {
      type="bool"
      readonly=false
      doc="Loops until stopped."
    }
    field "PlayOnStart" {
      type="bool"
      readonly=false
      doc="Plays when Play starts."
    }
    field "Spatial" {
      type="bool"
      readonly=false
      doc="Fades and pans with the distance to the listener."
    }
    field "MinDistance" {
      type="float"
      readonly=false
      doc="Full volume up to this distance, in world units."
    }
    field "MaxDistance" {
      type="float"
      readonly=false
      doc="Silent from this distance, in world units."
    }
    field "Rolloff" {
      type="Curve"
      readonly=true
      doc="Volume from Min Distance (time 0) to Max Distance (time 1)."
    }
    field "PanWidth" {
      type="float"
      readonly=false
      doc="How far a spatial sound pans when it is at Max Distance to the side: 0 stays centred, 1 is fully left or right."
    }
    field "PauseWith" {
      type="int"
      readonly=false
      doc="game pauses with the world, never keeps playing."
    }
    field "Playing" {
      type="bool"
      readonly=true
      doc="True while a sound of this source plays."
    }
    field "Position" {
      type="float"
      readonly=true
      doc="Seconds into the sound."
    }
  }
  component "audio.AudioZone2D" {
    short="AudioZone2D"
    category="audio"
    doc="While the listener is inside Area, Bus is turned to Gain."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Bus" {
      type="int"
      readonly=false
      doc="Bus the zone turns down or up."
    }
    field "Gain" {
      type="float"
      readonly=false
      doc="Volume of the bus inside the zone, 0 to 1."
    }
    field "Priority" {
      type="int"
      readonly=false
      doc="Among overlapping zones on one bus the highest priority wins, then the one entered later."
    }
    field "FadeTime" {
      type="float"
      readonly=false
      doc="Seconds to fade in and out of the zone."
    }
  }
  component "animation.AnimationPlayer" {
    short="AnimationPlayer"
    category="animation"
    doc="Plays an animation clip on its node and the nodes below it: property tracks, sprite frames and events. Clip time, gameplay events and tracks other than the transform pose advance on fixed steps, so a replay gives the same result at any frame rate."
    builtin=true
    field "Clip" {
      type="AssetRef<anim>"
      readonly=false
      doc="Clip to play."
    }
    field "PlayOnStart" {
      type="bool"
      readonly=false
      doc="Starts the clip when Play starts."
    }
    field "Speed" {
      type="float"
      readonly=false
      doc="Playback speed: 1 is normal, 2 twice as fast; a negative speed plays backwards."
    }
    field "Loop" {
      type="int"
      readonly=false
      doc="clip keeps the loop mode of the clip; once, loop and pingPong override it."
    }
    field "TimeDomain" {
      type="int"
      readonly=false
      doc="game follows game time and pauses with it; unscaled runs in real time while paused, for menus and other presentation."
    }
    field "Time" {
      type="float"
      readonly=true
      doc="Time inside the clip, in seconds."
    }
    field "Playing" {
      type="bool"
      readonly=true
      doc="Whether the clip plays."
    }
    field "Cycle" {
      type="int"
      readonly=true
      doc="Cycles of a looping clip so far."
    }
  }
  component "animation.Animator" {
    short="Animator"
    category="animation"
    doc="Plays the states of an animation controller and blends between them when its parameters change. The graph, the blends, root motion and gameplay events run on fixed steps, so replays match at any frame rate."
    builtin=true
    field "Controller" {
      type="AssetRef<animctrl>"
      readonly=false
      doc="Controller with the states, parameters and transitions."
    }
    field "PlayOnStart" {
      type="bool"
      readonly=false
      doc="Enters the entry state when Play starts."
    }
    field "Speed" {
      type="float"
      readonly=false
      doc="Multiplies the speed of every state; 1 is normal speed."
    }
    field "TimeDomain" {
      type="int"
      readonly=false
      doc="game follows game time and pauses with it; unscaled runs in real time while paused, for presentation only."
    }
    field "RootMotion" {
      type="int"
      readonly=false
      doc="What the root track moves: none ignores it, toMotion moves the node through Motion 2D so walls stop it, toTransform sets its position."
    }
    field "RootFallback" {
      type="bool"
      readonly=false
      doc="toMotion moves the transform instead when the node has no Motion 2D."
    }
    field "RootScale" {
      type="Vec2"
      readonly=false
      doc="Multiplies root motion in the node's parent space; set X to -1 while the character faces left."
    }
    field "State" {
      type="string"
      readonly=true
      doc="Current state."
    }
    field "Time" {
      type="float"
      readonly=true
      doc="Seconds in the current state."
    }
    field "Progress" {
      type="float"
      readonly=true
      doc="Time in the current state divided by the length of its clip; 1 is one full clip."
    }
    field "Blending" {
      type="bool"
      readonly=true
      doc="Whether a transition is blending."
    }
  }
  component "camera.VirtualCamera2D" {
    short="VirtualCamera2D"
    category="camera"
    doc="A camera pose the brain can pick. The highest priority wins; switching blends from the current view."
    builtin=true
    field "Priority" {
      type="int"
      readonly=false
      doc="The enabled virtual camera with the highest priority drives its output."
    }
    field "Output" {
      type="string"
      readonly=false
      doc="Output this camera drives. Empty is the main output; a Camera 2D picks another one with Camera Brain 2D."
    }
    field "Zoom" {
      type="float"
      readonly=false
      doc="Pixels per world unit while this camera is active. 0 keeps the zoom of the Camera 2D."
    }
    field "BlendTime" {
      type="float"
      readonly=false
      doc="Seconds to blend into this camera when it becomes active. 0 cuts."
    }
    field "BlendCurve" {
      type="Curve"
      readonly=true
      doc="Shape of the blend; its time range is stretched over Blend Time."
    }
    field "TimeDomain" {
      type="int"
      readonly=false
      doc="unscaled blends and shakes in real time, also during hit-stop and pause; game follows the time scale."
    }
    field "UseBounds" {
      type="bool"
      readonly=false
      doc="Keeps the visible area inside Bounds."
    }
    field "Bounds" {
      type="Rect"
      readonly=false
      doc="World rectangle the view stays inside. A smaller area centres the view on it."
    }
    field "SnapToPixels" {
      type="bool"
      readonly=false
      doc="Rounds the final position to whole screen pixels. pixelPerfect cameras already do this."
    }
  }
  component "camera.CameraFollow2D" {
    short="CameraFollow2D"
    category="camera"
    doc="Moves its virtual camera after Target, with a deadzone, damping and lookahead."
    builtin=true
    field "Target" {
      type="NodeRef"
      readonly=false
      doc="Node to follow; its interpolated position is used."
    }
    field "Deadzone" {
      type="Rect"
      readonly=false
      doc="Area of the view, in 0..1 of its width and height, where the target moves without moving the camera."
    }
    field "Damping" {
      type="Vec2"
      readonly=false
      doc="How fast the camera catches up, per second on each axis. 0 follows rigidly."
    }
    field "Lookahead" {
      type="Vec2"
      readonly=false
      doc="Seconds of target velocity the camera looks ahead on each axis."
    }
    field "MaxLookahead" {
      type="Vec2"
      readonly=false
      doc="Largest lookahead in world units on each axis. 0 is unlimited."
    }
    field "LookaheadSmoothing" {
      type="float"
      readonly=false
      doc="How fast the lookahead changes, per second. 0 changes at once."
    }
    field "SnapDistance" {
      type="float"
      readonly=false
      doc="A target jump longer than this, in world units, moves the camera at once. 0 never snaps."
    }
  }
  component "camera.CameraShake2D" {
    short="CameraShake2D"
    category="camera"
    doc="Tunes the shake of its virtual camera. Shake grows with trauma and fades over time."
    builtin=true
    field "Decay" {
      type="float"
      readonly=false
      doc="Trauma lost per second."
    }
    field "MaxOffset" {
      type="Vec2"
      readonly=false
      doc="Largest offset in world units at full trauma."
    }
    field "MaxAngle" {
      type="float"
      readonly=false
      doc="Largest rotation in radians at full trauma."
    }
    field "Frequency" {
      type="float"
      readonly=false
      doc="How fast the shake changes, in noise steps per second."
    }
    field "Exponent" {
      type="float"
      readonly=false
      doc="Shake is trauma to this power: 2 keeps small hits subtle."
    }
  }
  component "camera.CameraZone2D" {
    short="CameraZone2D"
    category="camera"
    doc="While Target is inside Area, Camera gets Priority and the zone's zoom and bounds."
    builtin=true
    field "Target" {
      type="NodeRef"
      readonly=false
      doc="Node that triggers the zone. Empty uses the follow target of the zone's camera."
    }
    field "Camera" {
      type="NodeRef"
      readonly=false
      doc="Virtual camera the zone activates. Empty uses the one on this node."
    }
    field "Priority" {
      type="int"
      readonly=false
      doc="Priority of the camera while the target is inside."
    }
    field "Zoom" {
      type="float"
      readonly=false
      doc="Zoom while the zone is in effect. 0 keeps the camera's zoom."
    }
    field "UseBounds" {
      type="bool"
      readonly=false
      doc="Replaces the camera's bounds while the zone is in effect."
    }
    field "Bounds" {
      type="Rect"
      readonly=false
      doc="World rectangle used instead of the camera's bounds."
    }
    field "Area" {
      type="Rect"
      readonly=false
      doc="Trigger rectangle in this node's space."
    }
  }
  component "camera.CameraBrain2D" {
    short="CameraBrain2D"
    category="camera"
    doc="Picks which output of virtual cameras drives this Camera 2D. Without it the camera shows the main output."
    builtin=true
    field "Output" {
      type="string"
      readonly=false
      doc="Output name; virtual cameras with the same Output drive this camera."
    }
  }
  component "gameplay.Motion2D" {
    short="Motion2D"
    category="gameplay"
    doc="Moves a kinematic Body2D by casting its colliders: walking, jumping, slopes, steps and moving platforms, or free top-down movement. Call Move and Jump from a script; the controller acts on the next fixed step."
    builtin=true
    field "Mode" {
      type="int"
      readonly=false
      doc="platformer walks on floors under gravity; topDown moves freely in the plane."
    }
    field "UpDirection" {
      type="Vec2"
      readonly=false
      doc="Up for floors, jumps and gravity. (0, -1) is up on screen."
    }
    field "MaxSpeed" {
      type="float"
      readonly=false
      doc="Top speed in units per second."
    }
    field "Accel" {
      type="float"
      readonly=false
      doc="How fast the speed grows towards the target, units per second squared."
    }
    field "Decel" {
      type="float"
      readonly=false
      doc="How fast the speed falls without input, in units per second squared."
    }
    field "AirControl" {
      type="float"
      readonly=false
      doc="Share of Accel and Decel available in the air: 0 cannot steer, 1 steers as on the ground."
    }
    field "GravityScale" {
      type="float"
      readonly=false
      doc="Multiplies the physics gravity; 0 turns gravity off for the character."
    }
    field "MaxFallSpeed" {
      type="float"
      readonly=false
      doc="Fastest fall in units per second. 0 is unlimited."
    }
    field "JumpHeight" {
      type="float"
      readonly=false
      doc="Height of a full jump in units; sets the jump speed unless Jump Speed is set."
    }
    field "JumpSpeed" {
      type="float"
      readonly=false
      doc="Upward speed of a jump. 0 derives it from Jump Height and gravity."
    }
    field "JumpCutMultiplier" {
      type="float"
      readonly=false
      doc="Upward speed is multiplied by this when the jump button is released early."
    }
    field "CoyoteTime" {
      type="float"
      readonly=false
      doc="Seconds after leaving a ledge during which a jump still works."
    }
    field "JumpBuffer" {
      type="float"
      readonly=false
      doc="Seconds a jump pressed in the air is remembered until landing."
    }
    field "MaxSlope" {
      type="float"
      readonly=false
      doc="Steepest floor in degrees; steeper surfaces are walls."
    }
    field "StepHeight" {
      type="float"
      readonly=false
      doc="Steps up to this height, in units, are climbed without jumping. 0 never steps up."
    }
    field "SnapToGround" {
      type="float"
      readonly=false
      doc="Keeps the character on slopes and steps down by up to this distance, in units. 0 never snaps."
    }
    field "SafeMargin" {
      type="float"
      readonly=false
      doc="Gap in units kept to surfaces so casts never start inside them."
    }
    field "MaxSlides" {
      type="int"
      readonly=false
      doc="How many surfaces one step may slide along."
    }
    field "CollisionMask" {
      type="int"
      readonly=false
      doc="Layers the character collides with."
    }
    field "PushBodies" {
      type="bool"
      readonly=false
      doc="Moves through dynamic bodies and pushes them instead of stopping at them."
    }
    field "MovingPlatforms" {
      type="bool"
      readonly=false
      doc="Carries the character with the body it stands on."
    }
    field "PlatformOnLeave" {
      type="int"
      readonly=false
      doc="keep keeps the platform's velocity after leaving it, drop loses it, add keeps only its horizontal part."
    }
    field "FaceMovement" {
      type="bool"
      readonly=false
      doc="topDown: turns the node towards the movement."
    }
    field "DashGravity" {
      type="bool"
      readonly=false
      doc="Applies gravity during a dash."
    }
    field "LedgeClimb" {
      type="float"
      readonly=false
      doc="platformer: in the air, moving into a wall whose top is at most this far above the feet climbs onto it. 0 never climbs."
    }
    field "ClimbTime" {
      type="float"
      readonly=false
      doc="Seconds a ledge climb takes: rising, then stepping onto the ledge."
    }
    field "Velocity" {
      type="Vec2"
      readonly=true
      doc="Velocity in units per second."
    }
    field "Grounded" {
      type="bool"
      readonly=true
      doc="Whether the character stands on a floor."
    }
    field "OnWall" {
      type="bool"
      readonly=true
      doc="Whether the character touched a wall in the last step."
    }
    field "OnCeiling" {
      type="bool"
      readonly=true
      doc="Whether the character touched a ceiling in the last step."
    }
    field "WallNormal" {
      type="Vec2"
      readonly=true
      doc="Normal of the last wall touched."
    }
    field "FloorNormal" {
      type="Vec2"
      readonly=true
      doc="Normal of the floor under the character."
    }
    field "FloorAngle" {
      type="float"
      readonly=true
      doc="Slope of the floor in degrees."
    }
    field "GroundBody" {
      type="NodeRef"
      readonly=true
      doc="Body the character stands on."
    }
    field "Climbing" {
      type="bool"
      readonly=true
      doc="Whether the character is climbing onto a ledge."
    }
  }
  component "gameplay.Health" {
    short="Health"
    category="gameplay"
    doc="Hit points of a node. Hitboxes, kill zones and scripts damage it; it dies once at zero until revived."
    builtin=true
    field "Max" {
      type="int"
      readonly=false
      doc="Hit points at the start and after a full revive."
    }
    field "Current" {
      type="int"
      readonly=true
      doc="Hit points now."
    }
    field "Team" {
      type="int"
      readonly=false
      doc="Hitboxes of the same team do not hurt this node unless they allow friendly fire."
    }
    field "InvulnTime" {
      type="float"
      readonly=false
      doc="Seconds of game time without damage after a hit. Hits in the same step all count."
    }
    field "DestroyOnDeath" {
      type="bool"
      readonly=false
      doc="Destroys the node at death, unless it has Respawn."
    }
    field "DespawnOnDeath" {
      type="bool"
      readonly=false
      doc="Returns the node to its pool at death; a node that was not spawned is destroyed."
    }
    field "Invulnerable" {
      type="bool"
      readonly=true
      doc="True while damage is ignored."
    }
    field "Dead" {
      type="bool"
      readonly=true
      doc="True from death until Revive."
    }
  }
  component "gameplay.Hurtbox2D" {
    short="Hurtbox2D"
    category="gameplay"
    doc="Area where hitboxes damage a Health: on this node or on its nearest parent with Health."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Shape" {
      type="int"
      readonly=false
      doc="box uses the rectangle; circle uses the circle inside it."
    }
    field "Multiplier" {
      type="float"
      readonly=false
      doc="Damage taken here is multiplied by this, for weak spots and armour."
    }
    field "Active" {
      type="bool"
      readonly=false
      doc="Off ignores hits."
    }
    field "Health" {
      type="NodeRef"
      readonly=false
      doc="Health that takes the damage. Empty uses this node or its nearest parent with Health."
    }
  }
  component "gameplay.Hitbox2D" {
    short="Hitbox2D"
    category="gameplay"
    doc="Damages hurtboxes inside its area, once per target per activation, on every entry or periodically."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Shape" {
      type="int"
      readonly=false
      doc="box uses the rectangle; circle uses the circle inside it."
    }
    field "Damage" {
      type="int"
      readonly=false
      doc="Damage per hit before the hurtbox multiplier."
    }
    field "Knockback" {
      type="Vec2"
      readonly=false
      doc="Push on a hit: velocity in units per second for a Motion 2D target, impulse for a dynamic body. Turns with the node."
    }
    field "KnockbackFromCenter" {
      type="bool"
      readonly=false
      doc="Pushes away from the hitbox centre instead, with the length of Knockback."
    }
    field "Team" {
      type="int"
      readonly=false
      doc="Team of the attack; -1 takes the team of the nearest Health above."
    }
    field "FriendlyFire" {
      type="bool"
      readonly=false
      doc="Also hits targets of the same team."
    }
    field "Policy" {
      type="int"
      readonly=false
      doc="onEnter hits on every entry, oncePerActivation hits each target once until Activate, periodic hits every Period while overlapping."
    }
    field "Period" {
      type="float"
      readonly=false
      doc="Seconds between hits for the periodic policy."
    }
    field "Active" {
      type="bool"
      readonly=false
      doc="Off deals no damage."
    }
  }
  component "gameplay.Lifetime" {
    short="Lifetime"
    category="gameplay"
    doc="Removes the node after some seconds: back to its pool or destroyed."
    builtin=true
    field "Seconds" {
      type="float"
      readonly=false
      doc="Seconds the node lives."
    }
    field "Unscaled" {
      type="bool"
      readonly=false
      doc="Counts real time, also while paused or slowed down."
    }
    field "Despawn" {
      type="bool"
      readonly=false
      doc="Returns the node to its pool instead of destroying it."
    }
    field "Remaining" {
      type="float"
      readonly=true
      doc="Seconds left."
    }
  }
  component "gameplay.KillZone2D" {
    short="KillZone2D"
    category="gameplay"
    doc="Kills a Health that enters the area, or respawns a node with Respawn and no Health."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Tag" {
      type="string"
      readonly=false
      doc="Only nodes with this tag; empty affects every node with Health or Respawn."
    }
  }
  component "gameplay.Checkpoint2D" {
    short="Checkpoint2D"
    category="gameplay"
    doc="Sets the respawn point of a node with Respawn that enters the area."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Priority" {
      type="int"
      readonly=false
      doc="A checkpoint does not replace one with a higher priority."
    }
    field "Once" {
      type="bool"
      readonly=false
      doc="Works for the first node only."
    }
    field "SpawnPoint" {
      type="NodeRef"
      readonly=false
      doc="Node whose position becomes the respawn point. Empty uses this checkpoint's position."
    }
  }
  component "gameplay.Respawn" {
    short="Respawn"
    category="gameplay"
    doc="Brings the node back to its respawn point after death or Trigger. The first point is where the node starts."
    builtin=true
    field "Delay" {
      type="float"
      readonly=false
      doc="Seconds of game time before the node comes back."
    }
    field "RestoreHealth" {
      type="bool"
      readonly=false
      doc="Revives Health with full hit points."
    }
    field "ResetVelocity" {
      type="bool"
      readonly=false
      doc="Stops a Motion 2D on respawn."
    }
    field "Persist" {
      type="bool"
      readonly=false
      doc="Saves the respawn point with the game."
    }
  }
  component "gameplay.Pickup2D" {
    short="Pickup2D"
    category="gameplay"
    doc="Fires Collected when a node enters the area; with Once the pickup then disappears."
    builtin=true
    field "Area" {
      type="Rect"
      readonly=false
      doc="Rectangle in this node's space."
    }
    field "Tag" {
      type="string"
      readonly=false
      doc="Only nodes with this tag; empty accepts every node with Motion 2D."
    }
    field "Once" {
      type="bool"
      readonly=false
      doc="Removes the pickup after the first collection."
    }
    field "Despawn" {
      type="bool"
      readonly=false
      doc="Returns the pickup to its pool instead of destroying it."
    }
  }
  component "gameplay.StateMachine" {
    short="StateMachine"
    category="gameplay"
    doc="Named states with Enter, Exit, Fixed and Update hooks found by name on the node's scripts: EnterRun(), ExitRun(), FixedRun(dt), UpdateRun(dt). Scripts change the state with Go."
    builtin=true
    field "Initial" {
      type="string"
      readonly=false
      doc="State entered when the node starts, after the scripts' Ready. Empty uses the first state."
    }
    field "Current" {
      type="string"
      readonly=true
      doc="State now."
    }
    field "Previous" {
      type="string"
      readonly=true
      doc="State before the last change."
    }
    field "Time" {
      type="float"
      readonly=true
      doc="Seconds of fixed steps spent in the current state."
    }
    field "Index" {
      type="int"
      readonly=true
      doc="Index of the current state in States."
    }
  }
  component "save.Persist" {
    short="Persist"
    category="save"
    doc="Saves the node's transform and enabled flag in save games."
    builtin=true
    field "NoTransform" {
      type="bool"
      readonly=false
      doc="Leaves the transform out of save games, for nodes whose position comes from elsewhere."
    }
    field "NoEnabled" {
      type="bool"
      readonly=false
      doc="Leaves the enabled flag out of save games."
    }
  }
  component "particles.ParticleSystem2D" {
    short="ParticleSystem2D"
    category="particles"
    doc="Emits visual sprites from a bounded CPU pool. World-space particles stay at their birth location when the emitter moves."
    builtin=true
    field "Prewarm" {
      type="float"
      readonly=false
      doc="Seconds of bounded preparation for a looping effect, up to two."
    }
    field "EdgeA" {
      type="Vec2"
      readonly=false
      doc="First endpoint in emitter coordinates."
    }
    field "EdgeB" {
      type="Vec2"
      readonly=false
      doc="Second endpoint in emitter coordinates."
    }
    field "Mask" {
      type="AssetRef<texture>"
      readonly=false
      doc="Source sprite frame. Its prepared alpha mask is independent of atlas packing."
    }
    field "MaskThreshold" {
      type="float"
      readonly=false
      doc="Minimum source alpha used by the sprite mask, from zero to one."
    }
    field "FrameFPS" {
      type="float"
      readonly=false
      doc="Flipbook playback speed in frames per second."
    }
    field "FrameLoop" {
      type="bool"
      readonly=false
      doc="Repeat the flipbook; otherwise hold its last frame."
    }
    field "SortMode" {
      type="int"
      readonly=false
      doc="Oldest first, youngest first or farthest first for each camera."
    }
    field "ReducedMotion" {
      type="int"
      readonly=false
      doc="Keep, reduce or hide this effect when Reduce Motion is enabled."
    }
    field "ReducedRate" {
      type="float"
      readonly=false
      doc="Fraction of births kept under the Reduce policy."
    }
    field "Drag" {
      type="float"
      readonly=false
      doc="Nonnegative damping coefficient per second."
    }
    field "NoiseStrength" {
      type="float"
      readonly=false
      doc="Magnitude of deterministic presentation noise."
    }
    field "NoiseFrequency" {
      type="float"
      readonly=false
      doc="How fast the noise field changes."
    }
    field "KillYEnabled" {
      type="bool"
      readonly=false
      doc="Remove particles on the side of increasing Y past Kill Y."
    }
    field "KillY" {
      type="float"
      readonly=false
      doc="Threshold in simulation space, in world units."
    }
    field "PlaneEnabled" {
      type="bool"
      readonly=false
      doc="Remove particles past the configured clipping plane."
    }
    field "PlaneNormal" {
      type="Vec2"
      readonly=false
      doc="Outward normal of the clipping plane in simulation space."
    }
    field "PlaneDistance" {
      type="float"
      readonly=false
      doc="Plane offset along its normalized normal."
    }
    field "VelocityOverLife" {
      type="Curve"
      readonly=true
      doc="Speed multiplier by normalized age, applied without compounding."
    }
    field "PlayOnStart" {
      type="bool"
      readonly=false
      doc="Starts the emission schedule when this emitter becomes active."
    }
    field "Loop" {
      type="bool"
      readonly=false
      doc="Repeats the schedule at the end of each cycle."
    }
    field "Duration" {
      type="float"
      readonly=false
      doc="Length of one emission cycle in seconds."
    }
    field "TimeDomain" {
      type="int"
      readonly=false
      doc="Game pauses with the world; unscaled uses real presentation time."
    }
    field "Seed" {
      type="int"
      readonly=false
      doc="Nonzero locks the seed. Zero derives it from the session, stable node ID and activation."
    }
    field "MaxParticles" {
      type="int"
      readonly=false
      doc="Maximum live particles. When full, keep living particles and drop excess births."
    }
    field "Rate" {
      type="float"
      readonly=false
      doc="Continuous births per second. Zero allows manual bursts without a continuous stream."
    }
    field "Bursts" {
      type="[]Vec2"
      readonly=true
      doc="Cycle keys as (time in seconds, birth count). Times must be in [0, duration)."
    }
    field "Shape" {
      type="int"
      readonly=false
      doc="Birth positions come from a point, disk, rectangle, line segment or sprite alpha mask."
    }
    field "Offset" {
      type="Vec2"
      readonly=false
      doc="Local offset of the emitter shape."
    }
    field "RectSize" {
      type="Vec2"
      readonly=false
      doc="Full rectangle dimensions in world units."
    }
    field "Radius" {
      type="float"
      readonly=false
      doc="Circle radius in world units."
    }
    field "Lifetime" {
      type="Vec2"
      readonly=false
      doc="Minimum and maximum particle lifetime in seconds."
    }
    field "Speed" {
      type="Vec2"
      readonly=false
      doc="Minimum and maximum initial speed in units per second."
    }
    field "Size" {
      type="Vec2"
      readonly=false
      doc="Minimum and maximum starting side length in world units."
    }
    field "Rotation" {
      type="Vec2"
      readonly=false
      doc="Minimum and maximum initial rotation in radians."
    }
    field "Direction" {
      type="float"
      readonly=false
      doc="Central angle of launch in radians."
    }
    field "Spread" {
      type="float"
      readonly=false
      doc="Full angular width around direction, in radians."
    }
    field "Color" {
      type="Color"
      readonly=false
      doc="Straight linear tint and opacity at birth."
    }
    field "Gravity" {
      type="Vec2"
      readonly=false
      doc="Acceleration in units per second squared."
    }
    field "SizeOverLife" {
      type="Curve"
      readonly=true
      doc="Size multiplier sampled at normalized particle age."
    }
    field "AlphaOverLife" {
      type="Curve"
      readonly=true
      doc="Opacity multiplier sampled at normalized particle age."
    }
    field "RotationSpeed" {
      type="float"
      readonly=false
      doc="Angular speed in radians per second."
    }
    field "Space" {
      type="int"
      readonly=false
      doc="Local particles follow the emitter; world particles keep their birth transform."
    }
    field "Sprite" {
      type="AssetRef<texture>"
      readonly=false
      doc="Texture region to draw. Empty uses the built-in white texture."
    }
    field "Material" {
      type="AssetRef<material>"
      readonly=false
      doc="Optional unlit sprite-domain material. Its shader controls the blend mode."
    }
    field "Layer" {
      type="int"
      readonly=false
      doc="Painter layer shared with SpriteRenderer and Mesh2D."
    }
    field "Order" {
      type="int"
      readonly=false
      doc="Painter order within the layer."
    }
  }
}