Skip to main content

Types


babak

babak: nav-enemysource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
collide-info: collide-shape-moving
enemy-info: fact-info-enemy
hit-from-dir: vector
event-param-point: vector
frustration-point: vector
jump-dest: vector
jump-trajectory: trajectory
jump-time: time-frame
nav-info: nav-enemy-info
target-speed: float
momentum-speed: float
acceleration: float
rotate-speed: float
turn-time: time-frame
frustration-time: time-frame
speed-scale: float
neck: joint-mod
reaction-time: time-frame
notice-time: time-frame
state-timeout: time-frame
free-time: time-frame
touch-time: time-frame
nav-enemy-flags: nav-enemy-flags
incomming-attack-id: handle
jump-return-state: state
rand-gen: random-generator
States
babak-run-to-cannon: TODO

Variables


*babak-nav-enemy-info*

*babak-nav-enemy-info*: nav-enemy-infosource

basebutton

source

Types


basebutton

basebutton: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
down?: symbol
spawned-by-other?: symbol
move-to?: symbol
notify-actor: entity-actor
timeout: float
button-id: int32
event-going-down: symbol
event-down: symbol
event-going-up: symbol
event-up: symbol
anim-speed: float
move-to-pos: vector
move-to-quat: quaternion
Methods
basebutton-down-idle: unknown
basebutton-going-down: unknown
basebutton-going-up: unknown
basebutton-startup: unknown
basebutton-up-idle: unknown
reset!(obj: basebutton) => floatsource
basebutton-method-26(obj: basebutton) => nonesource
basebutton-method-27(obj: basebutton) => collide-shape-movingsource
arm-trigger-event!(obj: basebutton) => symbolsource
basebutton-method-29(obj: basebutton, arg0: symbol, arg1: entity) => nonesource
move-to-vec-or-quat!(obj: basebutton, arg0: vector, arg1: quaternion) => quaternionsource
press!(obj: basebutton, arg0: symbol) => intsource

warp-gate

warp-gate: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
level: symbol
level-slot: int32
min-slot: int32
max-slot: int32
Methods
idle: unknown
active: unknown
use: unknown
hidden: unknown

Functions


basebutton-init-by-other

basebutton-init-by-other(arg0: entity-actor, arg1: vector, arg2: quaternion, arg3: entity-actor, arg4: symbol, arg5: float) => nonesource

Variables


*warp-info*

*warp-info*: arraysource

*warp-jump-mods*

*warp-jump-mods*: surfacesource

baseplat

source

Types


baseplat

baseplat: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
basetrans: vector
bouncing: symbol
Methods
baseplat-method-20(obj: baseplat) => nonesource
baseplat-method-21(obj: baseplat) => nonesource
baseplat-method-22(obj: baseplat) => nonesource
get-unlit-skel(obj: plat-eco) => skeleton-groupsource
baseplat-method-24(obj: plat-eco) => nonesource
baseplat-method-25(obj: baseplat) => sparticle-launch-groupsource
baseplat-method-26(obj: plat) => nonesource

eco-door

eco-door: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
speed: float
open-distance: float
close-distance: float
out-dir: vector
open-sound: sound-name
close-sound: sound-name
state-actor: entity-actor
flags: eco-door-flags
locked: symbol
auto-close: symbol
one-way: symbol
Methods
door-closed: unknown
door-opening: unknown
door-open: unknown
door-closing: unknown
eco-door-method-24(obj: eco-door) => nonesource
eco-door-method-25(obj: eco-door) => nonesource
eco-door-method-26(obj: eco-door) => nonesource

Functions


eco-door-event-handler

eco-door-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource

plat-code

plat-code() => nonesource

plat-event

plat-event(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource

plat-post

plat-post() => nonesource

plat-trans

plat-trans() => nonesource

collectables-part

source

Functions


eco-fadeout

eco-fadeout(arg0: sparticle-system, arg1: sparticle-cpuinfo) => nonesource

eco-track-root-prim-fadeout

eco-track-root-prim-fadeout(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

part-tracker-move-to-target

part-tracker-move-to-target(arg0: part-tracker) => vectorsource

part-tracker-track-root

part-tracker-track-root(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

part-tracker-track-target

part-tracker-track-target(arg0: part-tracker) => vectorsource

sparticle-track-root-money

sparticle-track-root-money(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

collectables

source

Types


buzzer

buzzer: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32
victory-anim: spool-anim

collectable

collectable: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
Methods
initialize(obj: eco-collectable) => _type_source
initialize-params(obj: collectable, arg0: time-frame, arg1: float) => nonesource

eco

eco: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

eco-blue

eco-blue: ecosource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

eco-collectable

eco-collectable: collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32
Methods
wait: unknown
pickup: unknown
die: unknown
jump: unknown
notice-blue: unknown
initialize-effect(obj: eco-collectable, arg0: pickup-type) => nonesource
initialize-eco(obj: eco-collectable, arg0: entity-actor, arg1: pickup-type, arg2: float) => objectsource
animate(obj: eco-collectable) => nonesource
blocked: unknown

eco-pill

eco-pill: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

eco-red

eco-red: ecosource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

eco-yellow

eco-yellow: ecosource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

ecovalve

ecovalve: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
offset: vector
offset-target: vector
block-func: function
States
ecovalve-idle: TODO

ecovent

ecovent: ventsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
show-particles: symbol
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
blocker: entity-actor
block-func: function
pickup-handle: handle

fuel-cell

fuel-cell: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32
victory-anim: spool-anim
state-object: symbol
States
fuel-cell-clone-anim: TODO
fuel-cell-spline-slider: TODO

health

health: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

money

money: eco-collectablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
pickup-type: pickup-type
pickup-amount: float
notify-parent: basic
old-base: vector
base: vector
extra-trans: vector
jump-pos: vector
flags: collectable-flags
birth-time: time-frame
collect-timeout: time-frame
fadeout-timeout: time-frame
bob-offset: int64
bob-amount: float
pickup-handle: handle
actor-pause: symbol
eco-effect: sparticle-launch-group
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
respawn-delay: time-frame
sound-name: sound-spec
target: handle
suck-time: time-frame
suck-y-offset: float
speed: vector
movie-pos-index: int32

vent

vent: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
show-particles: symbol
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
blocker: entity-actor
block-func: function
pickup-handle: handle
Methods
initialize(obj: vent, arg0: entity-actor, arg1: pickup-type) => nonesource
States
vent-blocked: TODO
vent-pickup: TODO
vent-wait-for-touch: TODO

ventblue

ventblue: ventsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
show-particles: symbol
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
blocker: entity-actor
block-func: function
pickup-handle: handle

ventred

ventred: ventsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
show-particles: symbol
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
blocker: entity-actor
block-func: function
pickup-handle: handle

ventyellow

ventyellow: ventsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
show-particles: symbol
collect-effect: sparticle-launch-group
collect-effect2: sparticle-launch-group
collect-effect-time: time-frame
blocker: entity-actor
block-func: function
pickup-handle: handle

Functions


add-blue-motion

add-blue-motion(arg0: symbol, arg1: symbol, arg2: symbol, arg3: symbol) => symbolsource

add-blue-shake

add-blue-shake(arg0: vector, arg1: vector, arg2: vector) => vectorsource

birth-pickup-at-point

birth-pickup-at-point(arg0: vector, arg1: pickup-type, arg2: float, arg3: symbol, arg4: process-tree, arg5: fact-info) => pointersource

buzzer-init-by-other

buzzer-init-by-other(arg0: vector, arg1: vector, arg2: fact-info, arg3: entity-actor) => nonesource

check-blue-suck

check-blue-suck(arg0: process-drawable) => nonesource

ecovalve-init-by-other

ecovalve-init-by-other(arg0: function) => nonesource

fuel-cell-animate

fuel-cell-animate() => nonesource

fuel-cell-init-as-clone

fuel-cell-init-as-clone(arg0: handle, arg1: int) => nonesource

fuel-cell-init-by-other

fuel-cell-init-by-other(arg0: vector, arg1: vector, arg2: fact-info, arg3: entity-actor) => nonesource

fuel-cell-pick-anim

fuel-cell-pick-anim(arg0: process-drawable) => spool-animsource

initialize-eco-by-other

initialize-eco-by-other(arg0: vector, arg1: vector, arg2: fact-info) => nonesource

money-init-by-other

money-init-by-other(arg0: vector, arg1: vector, arg2: fact-info, arg3: entity-actor) => nonesource

money-init-by-other-no-bob

money-init-by-other-no-bob(arg0: vector, arg1: vector, arg2: fact-info, arg3: float, arg4: entity-actor) => nonesource

vent-standard-event-handler

vent-standard-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource

Variables


*eco-pill-count*

*eco-pill-count*: intsource

*fuel-cell-tune-pos*

*fuel-cell-tune-pos*: vectorsource

crates

source

Types


barrel

barrel: cratesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
base: vector
look: symbol
defense: symbol
incomming-attack-id: uint64
target: handle
child-count: int32
victory-anim: spool-anim

bucket

bucket: cratesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
base: vector
look: symbol
defense: symbol
incomming-attack-id: uint64
target: handle
child-count: int32
victory-anim: spool-anim

crate

crate: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
base: vector
look: symbol
defense: symbol
incomming-attack-id: uint64
target: handle
child-count: int32
victory-anim: spool-anim
Methods
wait: unknown
die: unknown
special-contents-die: unknown
bounce-on: unknown
notice-blue: unknown
params-init(obj: crate, arg0: entity) => nonesource
art-init(obj: crate) => cratesource
params-set!(obj: crate, arg0: symbol, arg1: symbol) => nonesource
check-dead(obj: crate) => nonesource
smush-update!(obj: crate) => nonesource

crate-bank

crate-bank: basicsource
Fields
type: type
COLLIDE_YOFF: float
COLLIDE_RADIUS: float
DARKECO_EXPLODE_RADIUS: float

crate-buzzer

crate-buzzer: cratesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
base: vector
look: symbol
defense: symbol
incomming-attack-id: uint64
target: handle
child-count: int32
victory-anim: spool-anim

pickup-spawner

pickup-spawner: cratesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
base: vector
look: symbol
defense: symbol
incomming-attack-id: uint64
target: handle
child-count: int32
victory-anim: spool-anim
blocker: entity-actor

Functions


crate-init-by-other

crate-init-by-other(arg0: entity, arg1: vector, arg2: symbol) => nonesource

crate-post

crate-post() => intsource

crate-standard-event-handler

crate-standard-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource

Variables


*CRATE-bank*

*CRATE-bank*: crate-banksource

dark-eco-pool

source

Types


dark-eco-pool

dark-eco-pool: water-animsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
water-height: meters
wade-height: meters
swim-height: meters
bottom-height: meters
attack-event: symbol
target: handle
flags: water-flags
ppointer-water-anim: pointer
look: int32
play-ambient-sound?: symbol

Variables


ripple-for-dark-eco-pool

ripple-for-dark-eco-pool: ripple-wave-setsource

ripple-for-finalboss-dark-eco-pool

ripple-for-finalboss-dark-eco-pool: ripple-wave-setsource

ripple-for-maincave-dark-eco-pool

ripple-for-maincave-dark-eco-pool: ripple-wave-setsource

ripple-for-misty-dark-eco-pool

ripple-for-misty-dark-eco-pool: ripple-wave-setsource

ripple-for-sunken-dark-eco-helix-room

ripple-for-sunken-dark-eco-helix-room: ripple-wave-setsource

generic-obs-h

source

Types


camera-tracker

camera-tracker: processsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
grab-target: handle
grab-event: symbol
release-event: symbol
old-global-mask: process-mask
old-self-mask: process-mask
old-parent-mask: process-mask
look-at-target: handle
pov-target: handle
work-process: handle
anim-process: handle
start-time: time-frame
callback: basic
userdata: basic
message: basic
border-value: basic
mask-to-clear: process-mask
script: pair
script-line: pair
script-func: function
Methods
eval(obj: camera-tracker, arg0: pair) => processsource
States
camera-tracker-process: TODO

gui-query

gui-query: structuresource
Fields
x-position: int32
y-position: int32
message: string
decision: symbol
only-allow-cancel: symbol
no-msg: string
message-space: int32
Methods
init!(obj: gui-query, arg0: string, arg1: int, arg2: int, arg3: int, arg4: symbol, arg5: string) => nonesource
get-response(obj: gui-query) => symbolsource

manipy

manipy: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
new-trans-hook: function
cur-trans-hook: function
cur-event-hook: function
new-joint-anim: art-joint-anim
new-joint-anim-blend: uint64
anim-mode: symbol
cur-grab-handle: handle
cur-target-handle: handle
old-grab-pos: vector
joint: joint-mod
new-post-hook: function
cur-post-hook: function
clone-copy-trans: symbol
shadow-backup: basic
draw?: symbol
States
manipy-idle: TODO

othercam

othercam: processsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
hand: handle
old-global-mask: process-mask
mask-to-clear: process-mask
cam-joint-index: int32
old-pos: vector
old-mat-z: vector
had-valid-frame: basic
border-value: basic
die?: symbol
survive-anim-end?: symbol
spooling?: symbol
States
othercam-running: TODO

part-spawner

part-spawner: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
mode: pointer
enable: symbol
radius: meters
world-sphere: sphere
Methods
is-visible?(obj: part-spawner) => symbolsource
States
part-spawner-active: TODO

part-tracker

part-tracker: processsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
part: sparticle-launch-control
target: handle
callback: function
linger-callback: function
duration: time-frame
linger-duration: time-frame
start-time: time-frame
offset: vector
userdata: uint64
user-time: time-frame
user-vector: vector
user-handle: uint32
States
part-tracker-process: TODO

process-hidden

process-hidden: processsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
Methods
die: unknown

swingpole

swingpole: processsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsq
dir: vector
range: meters
edge-length: meters
States
swingpole-active: TODO
swingpole-stance: TODO

touch-tracker

touch-tracker: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
duration: time-frame
target: handle
event: symbol
run-function: function
callback: function
event-mode: basic
States
touch-tracker-idle: TODO

generic-obs

source

Types


camera-start

camera-start: process-hiddensource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8

launcher

launcher: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
spring-height: meters
camera: state
active-distance: float
seek-time: time-frame
dest: vector
sound-id: sound-id
States
launcher-active: TODO
launcher-deactivated: TODO
launcher-idle: TODO

med-res-level

med-res-level: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
level: symbol
part-mode: basic
index: int32
States
med-res-level-idle: TODO

target-start

target-start: process-hiddensource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8

Functions


birth-func-set-quat

birth-func-set-quat(arg0: int, arg1: sparticle-cpuinfo, arg2: sparticle-launchinfo) => nonesource

cam-launcher-joystick

cam-launcher-joystick() => vectorsource

cam-launcher-long-joystick

cam-launcher-long-joystick() => vectorsource

camera-anim

camera-anim(arg0: symbol, arg1: basic, arg2: entity) => pointersource

camera-change-to

camera-change-to(arg0: string, arg1: int, arg2: symbol) => symbolsource

camera-look-at

camera-look-at(arg0: pair, arg1: uint) => processsource

camera-pov-from

camera-pov-from(arg0: pair, arg1: uint) => processsource

camera-tracker-init

camera-tracker-init(arg0: object) => objectsource

clone-anim

clone-anim(arg0: handle, arg1: int, arg2: symbol, arg3: string) => nonesource

clone-anim-once

clone-anim-once(arg0: handle, arg1: int, arg2: symbol, arg3: string) => nonesource

command-get-camera

command-get-camera(arg0: object, arg1: state) => statesource

command-get-process

command-get-process(arg0: object, arg1: process) => processsource

command-get-trans

command-get-trans(arg0: object, arg1: vector) => vectorsource

draw-eco-beam

draw-eco-beam(arg0: vector, arg1: vector) => nonesource

ja-anim-done?

ja-anim-done?(arg0: process) => symbolsource

launcher-init-by-other

launcher-init-by-other(arg0: vector, arg1: float, arg2: int, arg3: float) => nonesource

manipy-init

manipy-init(arg0: vector, arg1: entity-actor, arg2: skeleton-group, arg3: vector) => nonesource

part-tracker-init

part-tracker-init(arg0: sparticle-launch-group, arg1: time-frame, arg2: function, arg3: pointer, arg4: process, arg5: collide-prim-core) => nonesource

part-tracker-notify

part-tracker-notify() => objectsource

process-drawable-pair-random-point!

process-drawable-pair-random-point!(arg0: process-drawable, arg1: process-drawable, arg2: vector, arg3: float) => vectorsource

process-drawable-random-point!

process-drawable-random-point!(arg0: process-drawable, arg1: vector) => vectorsource

process-grab?

process-grab?(arg0: process) => symbolsource

process-release?

process-release?(arg0: process) => symbolsource

touch-tracker-init

touch-tracker-init(arg0: vector, arg1: float, arg2: time-frame) => nonesource

Variables


*lev-string*

*lev-string*: stringsource

*particle-quat*

*particle-quat*: quaternionsource
source

Types


nav-enemy: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
collide-info: collide-shape-moving
enemy-info: fact-info-enemy
hit-from-dir: vector
event-param-point: vector
frustration-point: vector
jump-dest: vector
jump-trajectory: trajectory
jump-time: time-frame
nav-info: nav-enemy-info
target-speed: float
momentum-speed: float
acceleration: float
rotate-speed: float
turn-time: time-frame
frustration-time: time-frame
speed-scale: float
neck: joint-mod
reaction-time: time-frame
notice-time: time-frame
state-timeout: time-frame
free-time: time-frame
touch-time: time-frame
nav-enemy-flags: nav-enemy-flags
incomming-attack-id: handle
jump-return-state: state
rand-gen: random-generator
Methods
nav-enemy-attack: unknown
nav-enemy-chase: unknown
nav-enemy-flee: unknown
nav-enemy-die: unknown
nav-enemy-fuel-cell: unknown
nav-enemy-give-up: unknown
nav-enemy-jump: unknown
nav-enemy-jump-land: unknown
nav-enemy-idle: unknown
nav-enemy-notice: unknown
nav-enemy-patrol: unknown
nav-enemy-stare: unknown
nav-enemy-stop-chase: unknown
nav-enemy-victory: unknown
nav-enemy-method-34: unknown
nav-enemy-wait-for-cue: unknown
nav-enemy-jump-to-point: unknown
nav-enemy-method-37(obj: nav-enemy) => nonesource
nav-enemy-method-38(obj: nav-enemy) => nonesource
common-post(obj: nav-enemy) => nonesource
nav-enemy-method-40(obj: nav-enemy) => nonesource
nav-enemy-method-41(obj: nav-enemy) => nonesource
new-patrol-point!(obj: nav-enemy) => intsource
attack-handler(obj: nav-enemy, arg0: process, arg1: event-message-block) => objectsource
touch-handler(obj: nav-enemy, arg0: process, arg1: event-message-block) => objectsource
init-defaults!(obj: nav-enemy, arg0: nav-enemy-info) => nonesource
target-in-range?(obj: nav-enemy, arg0: float) => basicsource
initialize-collision(obj: babak) => nonesource
nav-enemy-method-48(obj: babak) => nonesource
init-jm!(obj: nav-enemy, arg0: nav-enemy-info) => floatsource
nav-enemy-method-50(obj: nav-enemy, arg0: vector) => symbolsource
nav-enemy-method-51(obj: baby-spider) => nonesource
nav-enemy-method-52(obj: green-eco-lurker, arg0: vector) => symbolsource
nav-enemy-method-53(obj: green-eco-lurker) => symbolsource
nav-enemy-method-54(obj: ice-cube, arg0: vector) => symbolsource
nav-enemy-method-55(obj: snow-bunny) => symbolsource
set-jump-height-factor!(obj: citb-bunny, arg0: int) => nonesource
nav-enemy-method-57(obj: ice-cube) => nonesource
nav-enemy-method-58(obj: ice-cube) => nonesource
nav-enemy-method-59(obj: babak) => nonesource
nav-enemy-method-60(obj: ice-cube, arg0: symbol) => symbolsource
snow-bunny-attack: unknown
snow-bunny-chase-hop: unknown
snow-bunny-defend: unknown
nav-enemy-method-64: unknown
snow-bunny-lunge: unknown
snow-bunny-nav-resume: unknown
snow-bunny-patrol-hop: unknown
snow-bunny-patrol-idle: unknown
nav-enemy-method-69: unknown
snow-bunny-retreat-hop: unknown
snow-bunny-tune-spheres: unknown
nav-enemy-touch-handler(obj: nav-enemy, arg0: process, arg1: event-message-block) => objectsource
nav-enemy-attack-handler(obj: nav-enemy, arg0: process, arg1: event-message-block) => objectsource
nav-enemy-jump-blocked: unknown
nav-enemy-method-75: unknown
nav-enemy-info: basicsource
Fields
type: type
idle-anim: int32
walk-anim: int32
turn-anim: int32
notice-anim: int32
run-anim: int32
jump-anim: int32
jump-land-anim: int32
victory-anim: int32
taunt-anim: int32
die-anim: int32
neck-joint: int32
player-look-at-joint: int32
run-travel-speed: meters
run-rotate-speed: degrees
run-acceleration: meters
run-turn-time: seconds
walk-travel-speed: meters
walk-rotate-speed: degrees
walk-acceleration: meters
walk-turn-time: seconds
attack-shove-back: meters
attack-shove-up: meters
shadow-size: meters
notice-nav-radius: meters
nav-nearest-y-threshold: meters
notice-distance: meters
proximity-notice-distance: meters
stop-chase-distance: meters
frustration-distance: meters
frustration-time: time-frame
die-anim-hold-frame: float
jump-anim-start-frame: float
jump-land-anim-end-frame: float
jump-height-min: meters
jump-height-factor: float
jump-start-anim-speed: float
shadow-max-y: meters
shadow-min-y: meters
shadow-locus-dist: meters
use-align: symbol
draw-shadow: symbol
move-to-ground: symbol
hover-if-no-ground: symbol
use-momentum: symbol
use-flee: symbol
use-proximity-notice: symbol
use-jump-blocked: symbol
use-jump-patrol: symbol
gnd-collide-with: collide-kind
debug-draw-neck: symbol
debug-draw-jump: symbol
source

Functions


ja-group-index?

ja-group-index?(arg0: int) => symbolsource

nav-enemy-chase-post

nav-enemy-chase-post() => nonesource

nav-enemy-common-post

nav-enemy-common-post() => nonesource

nav-enemy-death-post

nav-enemy-death-post() => nonesource
nav-enemy-default-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => nonesource
nav-enemy-execute-custom-jump(arg0: int, arg1: float, arg2: float) => nonesource
nav-enemy-execute-jump() => nonesource

nav-enemy-face-player-post

nav-enemy-face-player-post() => nonesource
nav-enemy-facing-direction?(arg0: vector, arg1: float) => symbolsource
nav-enemy-facing-player?(arg0: float) => symbolsource
nav-enemy-facing-point?(arg0: vector, arg1: float) => symbolsource
nav-enemy-fall-and-play-death-anim(arg0: art-joint-anim, arg1: float, arg2: float, arg3: float, arg4: int) => nonesource

nav-enemy-falling-post

nav-enemy-falling-post() => nonesource

nav-enemy-flee-post

nav-enemy-flee-post() => nonesource
nav-enemy-frustrated?() => symbolsource
nav-enemy-get-new-patrol-point() => intsource
nav-enemy-init-by-other(arg0: battlecontroller, arg1: vector, arg2: vector) => nonesource
nav-enemy-initialize-custom-jump(arg0: vector, arg1: symbol, arg2: float, arg3: float, arg4: float) => nonesource
nav-enemy-initialize-jump(arg0: vector) => nonesource
nav-enemy-jump-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource
nav-enemy-jump-land-anim() => nonesource

nav-enemy-jump-land-post

nav-enemy-jump-land-post() => nonesource

nav-enemy-jump-post

nav-enemy-jump-post() => nonesource
nav-enemy-neck-control-inactive() => nonesource
nav-enemy-neck-control-look-at() => nonesource
nav-enemy-notice-player?() => symbolsource

nav-enemy-patrol-post

nav-enemy-patrol-post() => nonesource
nav-enemy-player-at-frustration-point?() => symbolsource
nav-enemy-player-vulnerable?() => symbolsource
nav-enemy-reset-frustration() => nonesource
nav-enemy-rnd-float() => floatsource
nav-enemy-rnd-float-range(arg0: float, arg1: float) => floatsource
nav-enemy-rnd-go-idle?(arg0: float) => symbolsource
nav-enemy-rnd-int-count(arg0: int) => intsource
nav-enemy-rnd-int-range(arg0: int, arg1: int) => intsource
nav-enemy-rnd-percent?(arg0: float) => symbolsource
nav-enemy-send-attack(arg0: process, arg1: touching-shapes-entry, arg2: symbol) => objectsource
nav-enemy-set-base-collide-sphere-collide-with(arg0: uint) => nonesource
nav-enemy-set-hit-from-direction(arg0: process) => nonesource

nav-enemy-simple-post

nav-enemy-simple-post() => nonesource
nav-enemy-test-nav-mesh-intersection-xz?(arg0: vector) => symbolsource
nav-enemy-test-point-in-nav-mesh?(arg0: vector) => symbolsource
nav-enemy-test-point-near-nav-mesh?(arg0: vector) => symbolsource

nav-enemy-travel-post

nav-enemy-travel-post() => nonesource
nav-enemy-turn-to-face-dir(arg0: vector, arg1: float) => nonesource
nav-enemy-turn-to-face-point(arg0: vector, arg1: float) => nonesource

process-drawable-death-event-handler

process-drawable-death-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => nonesource

Variables


*nav-enemy-dummy-shadow-control*: shadow-controlsource

orb-cache

source

Types


orb-cache-top

orb-cache-top: baseplatsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
basetrans: vector
bouncing: symbol
active-distance: float
inactive-distance: float
money-list: handle
money-pos-list: float
money-pos-actual: float
platform-pos: float
root-pos: float
money: int32
activated: symbol
Methods
pos-logic(obj: orb-cache-top, arg0: symbol) => symbolsource
calculate-pos(obj: orb-cache-top, arg0: symbol) => nonesource
States
orb-cache-top-activate: TODO
orb-cache-top-complete: TODO
orb-cache-top-idle: TODO

plat-button

source

Types


plat-button

plat-button: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
go-back-if-lost-player?: symbol
grab-player?: symbol
should-grab-player?: symbol
path-pos: float
bidirectional?: symbol
allow-auto-kill: symbol
sound-id: sound-id
trans-off: vector
spawn-pos: vector
Methods
plat-button-at-end: unknown
plat-button-idle: unknown
plat-button-pressed: unknown
plat-button-move-downward: unknown
plat-button-move-upward: unknown
plat-button-teleport-to-other-end: unknown
can-activate?(obj: plat-button) => symbolsource
plat-button-method-27(obj: plat-button) => nonesource
plat-button-method-28(obj: plat-button) => collide-shape-movingsource
can-target-move?(obj: plat-button) => nonesource
should-teleport?(obj: plat-button) => symbolsource
plat-button-method-31(obj: plat-button) => nonesource
plat-button-method-32(obj: plat-button) => nonesource

Functions


plat-button-camera-off

plat-button-camera-off() => nonesource

plat-button-camera-on

plat-button-camera-on() => nonesource

plat-eco

source

Types


plat-eco

plat-eco: platsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
basetrans: vector
bouncing: symbol
path-pos: float
sync: sync-info-eased
sound-id: sound-id
notice-dist: float
sync-offset-dest: float
sync-offset-faux: float
sync-linear-val: float
target: handle
unlit-look: lod-set
lit-look: lod-set
Methods
notice-blue: unknown

Types


plat

plat: baseplatsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape-moving
smush: smush-control
basetrans: vector
bouncing: symbol
path-pos: float
sync: sync-info-eased
sound-id: sound-id
Methods
get-lit-skel(obj: plat-eco) => skeleton-groupsource
plat-method-28: unknown
wad: unknown
plat-startup: unknown
plat-idle: unknown
plat-path-active: unknown

process-drawable-h

source

Functions


cspace-by-name-no-fail

cspace-by-name-no-fail(arg0: process-drawable, arg1: string) => cspacesource

Get a cspace by name from the given process-drawable. If it fails, print an error and return the first one

cspace-index-by-name-no-fail

cspace-index-by-name-no-fail(arg0: process-drawable, arg1: string) => intsource

Get the index of a cspace by name from the given process drawable. If it fails, print an error and return 0.

num-func-+!

num-func-+!(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Increment the frame number, taking into account the animation speed and current game rate.

num-func--!

num-func--!(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Decrement the frame number, taking into account the animation speed and current game rate.

num-func-blend-in!

num-func-blend-in!(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Seek frame-interp toward 1. Once its there, do a joint-control-reset.

num-func-chan

num-func-chan(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Copies the frame number from the channel arg1.

num-func-identity

num-func-identity(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

seems to be the same thing as none.

num-func-loop!

num-func-loop!(chan: joint-control-channel, inc: float, arg2: float) => floatsource

Like num-func-+!, but will wrap to 0 after going past the end.

num-func-none

num-func-none(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Don't change anything.

num-func-seek!

num-func-seek!(arg0: joint-control-channel, arg1: float, arg2: float) => floatsource

Seek toward arg1 by at most arg2 (taking into account speed etc)

process-drawable

source

Functions


anim-loop

anim-loop() => nonesource

cspace-by-name

cspace-by-name(arg0: process-drawable, arg1: string) => cspacesource

cspace-children

cspace-children(arg0: process-drawable, arg1: int) => pairsource

cspace-index-by-name

cspace-index-by-name(arg0: process-drawable, arg1: string) => intsource

draw-bone-lines

draw-bone-lines(obj: process-drawable) => symbolsource

draw-joint-spheres

draw-joint-spheres(arg0: process-drawable) => symbolsource

execute-math-engine

execute-math-engine() => intsource

fill-skeleton-cache

fill-skeleton-cache(arg0: process-drawable) => intsource

ja-aframe

ja-aframe(arg0: float, arg1: int) => floatsource

ja-aframe-num

ja-aframe-num(arg0: int) => floatsource

ja-blend-eval

ja-blend-eval() => intsource

ja-channel-push!

ja-channel-push!(arg0: int, arg1: time-frame) => intsource

ja-channel-set!

ja-channel-set!(arg0: int) => intsource

ja-done?

ja-done?(arg0: int) => symbolsource

ja-eval

ja-eval() => intsource

ja-frame-num

ja-frame-num(arg0: int) => floatsource

ja-group-size

ja-group-size() => intsource

ja-max?

ja-max?(arg0: int) => symbolsource

ja-min?

ja-min?(arg0: int) => symbolsource

ja-num-frames

ja-num-frames(arg0: int) => intsource

ja-post

ja-post() => nonesource

ja-speed

ja-speed(arg0: int) => floatsource

ja-step

ja-step(arg0: int) => floatsource

joint-control-reset!

joint-control-reset!(arg0: joint-control, arg1: joint-control-channel) => nonesource

make-nodes-from-jg

make-nodes-from-jg(arg0: art-joint-geo, arg1: pair, arg2: symbol) => cspace-arraysource

process-drawable-birth-fuel-cell

process-drawable-birth-fuel-cell(arg0: entity, arg1: vector, arg2: symbol) => nonesource

process-drawable-delay-player

process-drawable-delay-player(arg0: time-frame) => intsource

process-drawable-fuel-cell-handler

process-drawable-fuel-cell-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => nonesource

process-drawable-valid?

process-drawable-valid?(arg0: process-drawable) => symbolsource

pusher-post

pusher-post() => intsource

rider-post

rider-post() => intsource

rider-trans

rider-trans() => intsource

transform-post

transform-post() => intsource

vector<-cspace!

vector<-cspace!(arg0: vector, arg1: cspace) => vectorsource

vector<-cspace+vector!

vector<-cspace+vector!(arg0: vector, arg1: cspace, arg2: vector) => vectorsource

Variables


*default-skel-template*

*default-skel-template*: pairsource

*display-bones*

*display-bones*: symbolsource

*display-joint-names*

*display-joint-names*: symbolsource

*valid-con*

*valid-con*: stringsource

process-taskable

source

Functions


othercam-calc

othercam-calc(arg0: float) => nonesource

othercam-init-by-other

othercam-init-by-other(arg0: process-taskable, arg1: symbol, arg2: symbol, arg3: symbol) => nonesource

process-taskable-anim-loop

process-taskable-anim-loop() => nonesource

process-taskable-clean-up-after-talking

process-taskable-clean-up-after-talking() => nonesource

process-taskable-hide-enter

process-taskable-hide-enter() => intsource

process-taskable-hide-exit

process-taskable-hide-exit(arg0: symbol) => nonesource

process-taskable-hide-handler

process-taskable-hide-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => nonesource

process-taskable-play-anim-code

process-taskable-play-anim-code(arg0: art-joint-anim, arg1: basic) => objectsource

process-taskable-play-anim-enter

process-taskable-play-anim-enter() => symbolsource

process-taskable-play-anim-exit

process-taskable-play-anim-exit() => nonesource

process-taskable-play-anim-trans

process-taskable-play-anim-trans() => nonesource

vector-for-ambient

vector-for-ambient(arg0: process-drawable, arg1: vector) => vectorsource

Variables


*play-anim-time*

*play-anim-time*: time-framesource

rigid-body-h

source

Types


rigid-body

rigid-body: structuresource
Fields
mass: float
inv-mass: float
lin-momentum-damping-factor: float
ang-momentum-damping-factor: float
inertial-tensor: matrix
inv-inertial-tensor: matrix
cm-offset-joint: vector
position: vector
rotation: quaternion
lin-momentum: vector
ang-momentum: vector
lin-velocity: vector
ang-velocity: vector
inv-i-world: matrix
matrix: matrix
force: vector
torque: vector
max-ang-momentum: float
max-ang-velocity: float
Methods
rigid-body-method-9(obj: rigid-body, arg0: float, arg1: float, arg2: float, arg3: float) => nonesource
rigid-body-method-10(obj: rigid-body, arg0: float) => nonesource
clear-force-torque!(obj: rigid-body) => nonesource
clear-momentum!(obj: rigid-body) => nonesource
rigid-body-method-13(obj: rigid-body, arg0: vector, arg1: vector) => nonesource
rigid-body-method-14(obj: rigid-body, arg0: vector, arg1: vector) => nonesource
rigid-body-method-15(obj: rigid-body, arg0: vector) => nonesource
rigid-body-method-16(obj: rigid-body, arg0: vector, arg1: vector, arg2: float) => nonesource
rigid-body-method-17(obj: rigid-body, arg0: vector, arg1: vector) => vectorsource
rigid-body-method-18(obj: rigid-body, arg0: vector) => vectorsource
print-stats(obj: rigid-body) => nonesource
rigid-body-method-20(obj: rigid-body) => nonesource
rigid-body-method-21(obj: rigid-body) => nonesource
rigid-body-method-22(obj: rigid-body, arg0: vector, arg1: quaternion, arg2: float, arg3: float) => nonesource

rigid-body-control-point

rigid-body-control-point: structuresource
Fields
local-pos: vector
world-pos: vector
velocity: vector

rigid-body

source

Types


rigid-body-control-point-inline-array

rigid-body-control-point-inline-array: inline-array-classsource
Fields
type: type
length: int32
allocated-length: int32
_data: uint8
data: rigid-body-control-point

rigid-body-platform

rigid-body-platform: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-overlay: collide-shape-moving
info: rigid-body-platform-constants
rbody: rigid-body
control-point-array: rigid-body-control-point-inline-array
player-velocity: vector
player-velocity-prev: vector
player-force-position: vector
player-force: vector
sim-time-remaining: float
float-height-offset: float
player-attack-id: int32
player-bonk-timeout: time-frame
water-anim: water-anim
player-contact: basic
player-impulse: collide-shape-prim-mesh
Methods
rigid-body-platform-idle: unknown
rigid-body-platform-float: unknown
rigid-body-platform-method-22(obj: rigid-body-platform, arg0: vector, arg1: float) => floatsource
rigid-body-platform-method-23(obj: rigid-body-platform, arg0: float) => nonesource
rigid-body-platform-method-24(obj: rigid-body-platform, arg0: rigid-body-control-point, arg1: float) => nonesource
rigid-body-platform-method-25(obj: rigid-body-platform) => nonesource
rigid-body-platform-method-26(obj: rigid-body-platform) => nonesource
rigid-body-platform-method-27(obj: rigid-body-platform, arg0: vector) => nonesource
rigid-body-platform-method-28(obj: rigid-body-platform) => nonesource
rigid-body-platform-method-29(obj: rigid-body-platform, arg0: rigid-body-platform-constants) => nonesource
rigid-body-platform-method-30(obj: rigid-body-platform) => nonesource
rigid-body-platform-method-31(obj: rigid-body-platform) => nonesource
rigid-body-platform-method-32(obj: qbert-plat) => sound-idsource
rigid-body-platform-method-33(obj: qbert-plat) => objectsource
rigid-body-platform-method-34(obj: rigid-body-platform) => nonesource

rigid-body-platform-constants

rigid-body-platform-constants: structuresource
Fields
drag-factor: float
buoyancy-factor: float
max-buoyancy-depth: meters
gravity-factor: float
gravity: meters
player-weight: meters
player-bonk-factor: float
player-dive-factor: float
player-force-distance: meters
player-force-clamp: meters
player-force-timeout: time-frame
explosion-force: meters
linear-damping: float
angular-damping: float
control-point-count: int32
mass: float
inertial-tensor-x: meters
inertial-tensor-y: meters
inertial-tensor-z: meters
cm-joint-x: meters
cm-joint-y: meters
cm-joint-z: meters
idle-distance: meters
platform: symbol
sound-name: string

Functions


matrix-3x3-triple-transpose-product

matrix-3x3-triple-transpose-product(arg0: matrix, arg1: matrix, arg2: matrix) => matrixsource

rigid-body-platform-event-handler

rigid-body-platform-event-handler(arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => vectorsource

rigid-body-platform-post

rigid-body-platform-post() => intsource

Variables


*rigid-body-platform-constants*

*rigid-body-platform-constants*: rigid-body-platform-constantssource

ropebridge

source

Types


ropebridge

ropebridge: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
root-override: collide-shape
subtype: uint64
subtype-name: string
agitated-time-stamp: time-frame
bonk-time-stamp: time-frame
attack-flop-time-stamp: time-frame
player-attack-id: uint64
sleep-dist: float
do-physics?: basic
tuning: ropebridge-tuning
world-matrix: matrix
inv-world-matrix: matrix
extra-trans: vector
spring-point: ropebridge-spring-point
Methods
set-vel-from-impact(obj: ropebridge, arg0: uint, arg1: vector, arg2: int, arg3: float) => nonesource
set-vel-from-riders(obj: ropebridge) => nonesource
set-vel-from-rider(obj: ropebridge, arg0: uint, arg1: vector, arg2: int) => nonesource
clear-spring-forces(obj: ropebridge) => nonesource
debug-draw(obj: ropebridge) => nonesource
set-to-rest-state(obj: ropebridge) => nonesource
add-collision-meshes(obj: ropebridge) => nonesource
do-integration(obj: ropebridge) => nonesource
ropebridge-method-28(obj: ropebridge) => nonesource
States
ropebridge-idle: TODO

ropebridge-spring-point

ropebridge-spring-point: structuresource
Fields
local-pos: vector
vel: vector
extra-force: vector

ropebridge-tuning

ropebridge-tuning: structuresource
Fields
num-springs: int32
num-spring-points: int32
col-mesh-indexes: pointer
view-frustum-radius: float
root-prim-radius: float
desired-spring-len: float
gravity: float
spring-coefficient: float
spring-mass: float
friction: float
max-influence-dist: float
rider-max-gravity: float
max-bonk-influence-dist: float
rider-bonk-force: float
rider-bonk-min: float
rider-bonk-max: float
normal-board-len: float
bridge-end-to-end-len: float
rest-state: symbol

Functions


ropebridge-joint-callback

ropebridge-joint-callback(arg0: ropebridge) => nonesource

Variables


*ropebridge-32-rest-state*

*ropebridge-32-rest-state*: inline-arraysource

*ropebridge-36-rest-state*

*ropebridge-36-rest-state*: inline-arraysource

*ropebridge-52-rest-state*

*ropebridge-52-rest-state*: inline-arraysource

*ropebridge-70-rest-state*

*ropebridge-70-rest-state*: inline-arraysource

*ropebridge-tunings*

*ropebridge-tunings*: inline-arraysource

sharkey

source

Types


sharkey

sharkey: nav-enemysource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
collide-info: collide-shape-moving
enemy-info: fact-info-enemy
hit-from-dir: vector
event-param-point: vector
frustration-point: vector
jump-dest: vector
jump-trajectory: trajectory
jump-time: time-frame
nav-info: nav-enemy-info
target-speed: float
momentum-speed: float
acceleration: float
rotate-speed: float
turn-time: time-frame
frustration-time: time-frame
speed-scale: float
neck: joint-mod
reaction-time: time-frame
notice-time: time-frame
state-timeout: time-frame
free-time: time-frame
touch-time: time-frame
nav-enemy-flags: nav-enemy-flags
incomming-attack-id: handle
jump-return-state: state
rand-gen: random-generator
dir: vector
spawn-point: vector
scale: float
anim-speed: float
y-max: meters
y-min: meters
attack-time: float
player-water-time: time-frame
player-in-water: basic
last-y: float
spawn-distance: meters
chase-speed: meters
y-speed: meters
sound-id: sound-id
enable-patrol: basic

Functions


sharkey-follow-trajectory

sharkey-follow-trajectory(arg0: float) => quaternionsource

sharkey-get-player-position

sharkey-get-player-position(arg0: vector) => nonesource

sharkey-move-to-attack-position

sharkey-move-to-attack-position() => floatsource

sharkey-notice-player?

sharkey-notice-player?() => symbolsource

sharkey-reset-position

sharkey-reset-position() => nonesource

Variables


*sharkey-nav-enemy-info*

*sharkey-nav-enemy-info*: nav-enemy-infosource

Types


ticky

ticky: structuresource
Fields
delay-til-ramp: time-frame
delay-til-timeout: time-frame
starting-time: time-frame
last-tick-time: time-frame
Methods
sleep(obj: ticky, arg0: time-frame) => nonesource
reached-delay?(obj: ticky, arg0: time-frame) => symbolsource
completed?(obj: ticky) => symbolsource

Types


tippy

tippy: structuresource
Fields
axis: vector
angle: float
orig: quaternion
dist-ratio: float
damping: float
1-damping: float
Methods
reset!(obj: tippy, arg0: process-drawable, arg1: float, arg2: float) => nonesource
tippy-method-10(obj: tippy, arg0: process-drawable, arg1: vector) => symbolsource

voicebox

source

Types


camera-voicebox

camera-voicebox: camera-slavesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
trans: vector
fov: float
fov0: float
fov1: float
fov-index: cam-index
tracking: cam-rotation-tracker
view-off-param: float
unknown-symbol: symbol
view-off: vector
min-z-override: float
view-flat: vector
string-vel-dir: uint32
string-trans: vector
position-spline: tracking-spline
pivot-pt: vector
pivot-rad: float
circular-follow: vector
max-angle-offset: float
max-angle-curr: float
options: uint32
cam-entity: entity
velocity: vector
desired-pos: vector
time-dist-too-far: uint32
los-state: slave-los-state
good-point: vector
los-tgt-spline-pt: int32
los-tgt-spline-pt-incarnation: int32
los-last-pos: vector
intro-curve: curve
intro-offset: vector
intro-t: float
intro-t-step: float
outro-exit-value: float
spline-exists: basic
spline-curve: curve
spline-offset: vector
index: cam-index
saved-pt: vector
spline-tt: float
spline-follow-dist: float
change-event-from: pointer
enter-has-run: symbol
blend-from-type: uint64
blend-to-type: uint64
have-phony-joystick: basic
phony-joystick-x: float
phony-joystick-y: float
string-min-val: vector
string-max-val: vector
string-val-locked: basic
States
cam-voicebox: TODO

voicebox

voicebox: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
parent-override: pointer
base-trans: vector
seeker: cam-float-seeker
blend: float
twist: float
hint: handle
Methods
enter: unknown
idle: unknown
exit: unknown

Functions


voicebox-init-by-other

voicebox-init-by-other(arg0: vector, arg1: handle) => nonesource

voicebox-spawn

voicebox-spawn(arg0: process, arg1: vector) => pointersource

voicebox-track

voicebox-track() => nonesource

water-anim

source

Types


water-anim

water-anim: water-volsource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
water-height: meters
wade-height: meters
swim-height: meters
bottom-height: meters
attack-event: symbol
target: handle
flags: water-flags
ppointer-water-anim: pointer
look: int32
play-ambient-sound?: symbol

water-anim-look

water-anim-look: structuresource
Fields
skel-group: symbol
anim: int32
ambient-sound-spec: sound-spec

Variables


*water-anim-look*

*water-anim-look*: arraysource

water-h

source

Types


water-control

water-control: basicsource
Fields
type: type
flags: water-flags
process: process-drawable
joint-index: int32
top-y-offset: float
ripple-size: meters
enter-water-time: time-frame
wade-time: time-frame
on-water-time: time-frame
enter-swim-time: time-frame
swim-time: time-frame
base-height: meters
wade-height: meters
swim-height: meters
surface-height: meters
bottom-height: meters
height: meters
height-offset: float
real-ocean-offset: meters
ocean-offset: meters
bob-offset: meters
align-offset: meters
swim-depth: meters
bob: smush-control
volume: handle
bottom: vector
top: vector
enter-water-pos: vector
drip-old-pos: vector
drip-joint-index: int32
drip-wetness: float
drip-time: time-frame
drip-speed: float
drip-height: meters
drip-mult: float
Methods
water-control-method-9(obj: water-control) => nonesource
water-control-method-10(obj: water-control) => nonesource
start-bobbing!(obj: water-control, arg0: float, arg1: int, arg2: int) => nonesource
distance-from-surface(obj: water-control) => floatsource
create-splash(obj: water-control, arg0: float, arg1: vector, arg2: int, arg3: vector) => nonesource
display-water-marks?(obj: water-control) => symbolsource
water-control-method-15(obj: water-control) => nonesource
water-control-method-16(obj: water-control) => nonesource

water-vol

water-vol: process-drawablesource
Fields
type: type
name: basic
mask: process-mask
parent: pointer
brother: pointer
child: pointer
ppointer: pointer
self: process-tree
pool: dead-pool
status: basic
pid: int32
main-thread: cpu-thread
top-thread: thread
entity: entity-actor
state: state
trans-hook: function
post-hook: function
event-hook: function
allocated-length: int32
next-state: state
heap-base: pointer
heap-top: pointer
heap-cur: pointer
stack-frame-top: stack-frame
connection-list: connectable
stack: uint8
root: trsqv
node-list: cspace-array
draw: draw-control
skel: joint-control
nav: nav-control
align: align-control
path: path-control
vol: vol-control
fact: fact-info
link: actor-link-info
part: sparticle-launch-control
water: water-control
sound: ambient-sound
state-flags: state-flags
state-time: time-frame
water-height: meters
wade-height: meters
swim-height: meters
bottom-height: meters
attack-event: symbol
target: handle
flags: water-flags
Methods
water-vol-idle: unknown
water-vol-startup: unknown
water-vol-method-22(obj: dark-eco-pool) => nonesource
reset-root!(obj: water-vol) => nonesource
set-stack-size!(obj: water-anim) => nonesource
water-vol-method-25(obj: dark-eco-pool) => nonesource
update!(obj: water-vol) => nonesource
on-exit-water(obj: water-vol) => nonesource
get-ripple-height(obj: water-anim, arg0: vector) => floatsource
init!(obj: water-vol) => nonesource

Functions


birth-func-ocean-height

birth-func-ocean-height(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: matrix) => nonesource

birth-func-y->userdata

birth-func-y->userdata(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: matrix) => nonesource

check-water-level-above-and-die

check-water-level-above-and-die(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

check-water-level-drop

check-water-level-drop(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

check-water-level-drop-and-die

check-water-level-drop-and-die(arg0: sparticle-system, arg1: sparticle-cpuinfo, arg2: vector) => nonesource

part-water-splash-callback

part-water-splash-callback(arg0: part-tracker) => nonesource

splash-spawn

splash-spawn(arg0: basic, arg1: basic, arg2: int) => nonesource

water-vol-init-by-other

water-vol-init-by-other(arg0: entity-actor) => nonesource