aego/tests/integration/testdata/bindings.aetext

manifest version=6 {
  abi="adb913902ea0c5d3a0f32f5813f232bfb9ebece19fe37fcd4106e0c9b8d1be36"
  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/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 is the inBack easing preset."
    }
    const "InBounce" {
      type="enum:aego/curve.Easing"
      int=20
      float=0
      bool=false
      str=""
      doc="InBounce is the inBounce easing preset."
    }
    const "InCubic" {
      type="enum:aego/curve.Easing"
      int=5
      float=0
      bool=false
      str=""
      doc="InCubic is the inCubic easing preset."
    }
    const "InElastic" {
      type="enum:aego/curve.Easing"
      int=17
      float=0
      bool=false
      str=""
      doc="InElastic is the inElastic easing preset."
    }
    const "InExpo" {
      type="enum:aego/curve.Easing"
      int=11
      float=0
      bool=false
      str=""
      doc="InExpo is the inExpo easing preset."
    }
    const "InOutBack" {
      type="enum:aego/curve.Easing"
      int=16
      float=0
      bool=false
      str=""
      doc="InOutBack is the inOutBack easing preset."
    }
    const "InOutBounce" {
      type="enum:aego/curve.Easing"
      int=22
      float=0
      bool=false
      str=""
      doc="InOutBounce is the inOutBounce easing preset."
    }
    const "InOutCubic" {
      type="enum:aego/curve.Easing"
      int=7
      float=0
      bool=false
      str=""
      doc="InOutCubic is the inOutCubic easing preset."
    }
    const "InOutElastic" {
      type="enum:aego/curve.Easing"
      int=19
      float=0
      bool=false
      str=""
      doc="InOutElastic is the inOutElastic easing preset."
    }
    const "InOutExpo" {
      type="enum:aego/curve.Easing"
      int=13
      float=0
      bool=false
      str=""
      doc="InOutExpo is the inOutExpo easing preset."
    }
    const "InOutQuad" {
      type="enum:aego/curve.Easing"
      int=4
      float=0
      bool=false
      str=""
      doc="InOutQuad is the inOutQuad easing preset."
    }
    const "InOutSine" {
      type="enum:aego/curve.Easing"
      int=10
      float=0
      bool=false
      str=""
      doc="InOutSine is the inOutSine easing preset."
    }
    const "InQuad" {
      type="enum:aego/curve.Easing"
      int=2
      float=0
      bool=false
      str=""
      doc="InQuad is the inQuad easing preset."
    }
    const "InSine" {
      type="enum:aego/curve.Easing"
      int=8
      float=0
      bool=false
      str=""
      doc="InSine is the inSine easing preset."
    }
    const "Linear" {
      type="enum:aego/curve.Easing"
      int=1
      float=0
      bool=false
      str=""
      doc="Linear is the linear easing preset."
    }
    const "OutBack" {
      type="enum:aego/curve.Easing"
      int=15
      float=0
      bool=false
      str=""
      doc="OutBack is the outBack easing preset."
    }
    const "OutBounce" {
      type="enum:aego/curve.Easing"
      int=21
      float=0
      bool=false
      str=""
      doc="OutBounce is the outBounce easing preset."
    }
    const "OutCubic" {
      type="enum:aego/curve.Easing"
      int=6
      float=0
      bool=false
      str=""
      doc="OutCubic is the outCubic easing preset."
    }
    const "OutElastic" {
      type="enum:aego/curve.Easing"
      int=18
      float=0
      bool=false
      str=""
      doc="OutElastic is the outElastic easing preset."
    }
    const "OutExpo" {
      type="enum:aego/curve.Easing"
      int=12
      float=0
      bool=false
      str=""
      doc="OutExpo is the outExpo easing preset."
    }
    const "OutQuad" {
      type="enum:aego/curve.Easing"
      int=3
      float=0
      bool=false
      str=""
      doc="OutQuad is the outQuad easing preset."
    }
    const "OutSine" {
      type="enum:aego/curve.Easing"
      int=9
      float=0
      bool=false
      str=""
      doc="OutSine is the outSine easing preset."
    }
  }
  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: ttl 0 lasts one frame, a positive ttl lasts that many game seconds, a negative ttl lasts 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/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/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/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 when physics runs; without physics, 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)"
    }
  }
  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 "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 "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/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 "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 "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 "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."
  }
  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/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."
  }
  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/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: finished is true at its 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."
  }
  component "engine.SpriteRenderer" {
    short="SpriteRenderer"
    category="engine"
    doc="Draws a texture region at the node transform."
    field "Sprite" {
      type="AssetRef<texture>"
      readonly=false
      doc="Texture or atlas region to draw. Empty draws a solid rectangle in the tint color."
    }
    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."
    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.Camera3D" {
    short="Camera3D"
    category="engine"
    doc="Renders a perspective view looking down the node -Z axis."
    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."
    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."
    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."
    }
    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="Current velocity in units per second, during Play."
    }
    field "AngularVelocity" {
      type="float"
      readonly=true
      doc="Current rotation speed in radians per second, during Play."
    }
    field "Awake" {
      type="bool"
      readonly=true
      doc="Whether the body is simulated this step or sleeping, during Play."
    }
  }
  component "physics.BoxCollider2D" {
    short="BoxCollider2D"
    category="physics"
    doc="Box shape in node space."
    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."
    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."
    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."
    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."
    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."
    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; 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."
    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 "camera.VirtualCamera2D" {
    short="VirtualCamera2D"
    category="camera"
    doc="A camera pose the brain can pick. The highest priority wins; switching blends from the current view."
    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."
    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."
    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."
    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."
    field "Output" {
      type="string"
      readonly=false
      doc="Output name; virtual cameras with the same Output drive this camera."
    }
  }
  component "save.Persist" {
    short="Persist"
    category="save"
    doc="Persist saves the node's transform and enabled flag in save games."
    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."
    }
  }
}