target

*collide-edge-board-spec*: collide-edge-specsource

Functions

`gravel-surface-touch`

gravel-surface-touch() => nonesource

`poly-find-nearest-edge`

poly-find-nearest-edge(arg0: nav-poly, arg1: inline-array, arg2: vector, arg3: vector) => nav-polysource

TODO- Not 100% sure here, but unused

`rail-surface-touch`

rail-surface-touch() => nonesource

`target-collision-low-coverage`

target-collision-low-coverage(arg0: control-info, arg1: collide-query, arg2: vector, arg3: pointer, arg4: pointer, arg5: pointer) => nonesource

`target-collision-no-reaction`

target-collision-no-reaction(arg0: control-info, arg1: collide-query, arg2: vector, arg3: vector) => nonesource

`target-collision-reaction`

target-collision-reaction(arg0: control-info, arg1: collide-query, arg2: vector, arg3: vector) => collide-statussource

Variables

`collide-edge-board-spec`

darkjak-h

Types

`darkjak-info`

darkjak-info: basicsource

Fields

type: type

process: pointer

attack-id: uint32

start-time: time-frame

attack-time: time-frame

attack-count: uint64

stage: uint32

want-stage: uint32

clock-pos: float

clock-vel: float

clock-on: symbol

hud: handle

tone: uint32

bomb: uint32

Methods

update-clock!(obj: darkjak-info, arg0: int) => nonesource

logic-target

Functions

`leg-ik-callback`

leg-ik-callback(arg0: joint-mod-ik, arg1: object, arg2: object, arg3: vector) => nonesource

`level-setup`

level-setup() => nonesource

`local-pad-angle`

local-pad-angle() => floatsource

`post-flag-setup`

post-flag-setup() => nonesource

`pre-collide-setup`

pre-collide-setup() => nonesource

`read-pad`

read-pad(arg0: vector) => vectorsource

`reset-target-state`

reset-target-state(arg0: symbol) => targetsource

`reverse-conversions`

reverse-conversions(arg0: vector) => nonesource

`set-pad`

set-pad(arg0: vector) => vectorsource

`start`

start(arg0: symbol, arg1: continue-point) => targetsource

`stop`

stop(arg0: symbol) => intsource

`target-add-slide-factor`

target-add-slide-factor(arg0: vector) => vectorsource

`target-bend-vel-turn`

target-bend-vel-turn(arg0: vector) => vectorsource

`target-calc-camera-pos`

target-calc-camera-pos() => nonesource

`target-compute-edge`

target-compute-edge() => nonesource

`target-compute-edge-rider`

target-compute-edge-rider() => nonesource

`target-compute-pole`

target-compute-pole() => nonesource

`target-compute-slopes`

target-compute-slopes(arg0: vector) => intsource

`target-init`

target-init(arg0: continue-point) => nonesource

`target-log-trans`

target-log-trans() => nonesource

`target-move-dist`

target-move-dist(arg0: time-frame) => floatsource

`target-no-ja-move-post`

target-no-ja-move-post() => nonesource

`target-no-move-post`

target-no-move-post() => nonesource

`target-no-stick-post`

target-no-stick-post() => nonesource

`target-post`

target-post() => nonesource

`target-print-stats`

target-print-stats(arg0: target, arg1: symbol) => symbolsource

`target-real-post`

target-real-post() => nonesource

`target-swim-post`

target-swim-post() => nonesource

`target-update-ik`

target-update-ik() => nonesource

`tobot-init`

tobot-init(arg0: symbol) => nonesource

`tobot-start`

tobot-start(arg0: symbol) => targetsource

`tobot-stop`

tobot-stop() => intsource

`turn-around?`

turn-around?() => symbolsource

`turn-to-vector`

turn-to-vector(arg0: vector, arg1: float) => symbolsource

`vector-turn-to`

vector-turn-to(arg0: vector) => vectorsource

`vector<-pad-in-matrix!`

vector<-pad-in-matrix!(arg0: vector, arg1: cpad-info, arg2: matrix) => nonesource

`vector<-pad-in-surface!`

vector<-pad-in-surface!(arg0: vector, arg1: symbol) => vectorsource

`wall-hide?`

wall-hide?() => symbolsource

`warp-vector-into-surface!`

warp-vector-into-surface!(arg0: vector, arg1: vector, arg2: vector, arg3: matrix) => vectorsource

sidekick

Functions

`cspace<-cspace+transformq!`

cspace<-cspace+transformq!(arg0: cspace, arg1: cspace, arg2: transformq) => matrixsource

`init-sidekick`

init-sidekick() => nonesource

`target-sidekick-setup`

target-sidekick-setup(arg0: symbol) => nonesource

Variables

`sidekick-remap`

*sidekick-remap*: pairsource

surface-h

*dive-bottom-mods*: surfacesource

Types

`surface`

surface: basicsource

Fields

type: type

turnv: float

turnvv: float

tiltv: float

tiltvv: float

transv-max: float

target-speed: float

seek0: float

seek90: float

seek180: float

fric: float

nonlin-fric-dist: float

slip-factor: float

slide-factor: float

slope-up-factor: float

slope-down-factor: float

slope-slip-angle: float

impact-fric: float

bend-factor: float

bend-speed: float

alignv: float

slope-up-traction: float

align-speed: float

slope-change-preserve: float

turnvf: float

turnvvf: float

tiltvf: float

tiltvvf: float

vel-turn: float

active-hook: function

touch-hook: function

impact-hook: function

mult-hook: function

exit-hook: function

mode: symbol

flags: surface-flag

data: float

hook: function

dataw: uint32

Functions

`calc-terminal-vel`

calc-terminal-vel(arg0: float, arg1: float, arg2: float) => floatsource

`calc-terminal2-vel`

calc-terminal2-vel(arg0: float, arg1: float, arg2: float, arg3: float) => floatsource

`calc-terminal4-vel`

calc-terminal4-vel(arg0: float, arg1: float, arg2: float) => floatsource

`surface-clamp-speed`

surface-clamp-speed(arg0: surface, arg1: surface, arg2: surface, arg3: int) => nonesource

`surface-interp!`

surface-interp!(arg0: surface, arg1: surface, arg2: surface, arg3: float) => surfacesource

`surface-mult!`

surface-mult!(arg0: surface, arg1: surface, arg2: surface) => surfacesource

Variables

`dive-bottom-mods`

`dive-mods`

*dive-mods*: surfacesource

`double-jump-mods`

*double-jump-mods*: surfacesource

`empty-mods`

*empty-mods*: surfacesource

`flip-jump-mods`

*flip-jump-mods*: surfacesource

`flop-mods`

*flop-mods*: surfacesource

`forward-high-jump-mods`

*forward-high-jump-mods*: surfacesource

`forward-jump-mods`

*forward-jump-mods*: surfacesource

`forward-pole-jump-mods`

*forward-pole-jump-mods*: surfacesource

`high-jump-mods`

*high-jump-mods*: surfacesource

`jump-mods`

*jump-mods*: surfacesource

`launch-jump-mods`

*launch-jump-mods*: surfacesource

`neutral-mods`

*neutral-mods*: surfacesource

`roll-flip-mods`

*roll-flip-mods*: surfacesource

`roll-mods`

*roll-mods*: surfacesource

`smack-jump-mods`

*smack-jump-mods*: surfacesource

`standard-ground-surface`

*standard-ground-surface*: surfacesource

`swim-mods`

*swim-mods*: surfacesource

`swim-surface`

*swim-surface*: surfacesource

`turn-around-mods`

*turn-around-mods*: surfacesource

`wade-mods`

*wade-mods*: surfacesource

`walk-mods`

*walk-mods*: surfacesource

`walk-no-turn-mods`

*walk-no-turn-mods*: surfacesource

target-anim

Functions

`target-attack-air-anim`

target-attack-air-anim() => nonesource

`target-edge-grab-anim`

target-edge-grab-anim(arg0: float) => nonesource

`target-falling-anim`

target-falling-anim(arg0: int, arg1: time-frame) => symbolsource

`target-falling-anim-trans`

target-falling-anim-trans() => nonesource

`target-hit-ground-anim`

target-hit-ground-anim(arg0: symbol, arg1: symbol) => nonesource

`target-hit-ground-flop-anim`

target-hit-ground-flop-anim(arg0: symbol, arg1: symbol) => nonesource

`target-land-anim`

target-land-anim() => art-elementsource

`target-stance-anim`

target-stance-anim() => nonesource

`target-stance-push`

target-stance-push(arg0: int) => nonesource

`target-walk-anim`

target-walk-anim(arg0: int) => nonesource

target-carry

*carry-jump-mods*: surfacesource

Functions

`target-carry-post`

target-carry-post() => nonesource

`target-carry-update`

target-carry-update() => nonesource

Variables

`carry-jump-mods`

`carry-walk-mods`

*carry-walk-mods*: surfacesource

target-darkjak

Functions

`target-bomb1-fire-shot`

target-bomb1-fire-shot(arg0: pointer, arg1: int, arg2: int, arg3: int) => nonesource

`target-darkjak-bomb-collide`

target-darkjak-bomb-collide(arg0: float, arg1: float) => nonesource

`target-darkjak-end-mode`

target-darkjak-end-mode() => nonesource

`target-darkjak-process`

target-darkjak-process() => nonesource

`target-darkjak-setup`

target-darkjak-setup(arg0: symbol) => nonesource

`want-to-darkjak?`

want-to-darkjak?() => symbolsource

target-death

*kill-nearby-enemies-info*: kill-nearby-enemies-infosource

Types

`kill-nearby-enemies-info`

kill-nearby-enemies-info: basicsource

Fields

type: type

dist: float

pos: vector

Functions

`death-movie-remap`

death-movie-remap(arg0: int, arg1: int) => intsource

`kill-nearby-enemies`

kill-nearby-enemies(arg0: vector, arg1: float) => objectsource

`next-continue`

next-continue(arg0: continue-point) => continue-pointsource

`target-death-anim`

target-death-anim(arg0: spool-anim) => nonesource

`target-death-anim-trans`

target-death-anim-trans() => nonesource

`target-death-main`

target-death-main(arg0: symbol) => nonesource

`target-death-reset`

target-death-reset(arg0: symbol, arg1: symbol) => nonesource

`target-hit-effect`

target-hit-effect(arg0: attack-info) => nonesource

`target-hit-move`

target-hit-move(arg0: attack-info, arg1: symbol, arg2: function, arg3: float) => nonesource

`target-hit-orient`

target-hit-orient(arg0: attack-info, arg1: vector) => symbolsource

`target-hit-push`

target-hit-push(arg0: vector, arg1: matrix, arg2: float, arg3: float, arg4: attack-info) => symbolsource

`target-hit-setup-anim`

target-hit-setup-anim(arg0: attack-info) => nonesource

`velocity-set-to-target!`

velocity-set-to-target!(arg0: vector, arg1: float, arg2: attack-info) => vectorsource

Variables

`auto-continue`

*auto-continue*: symbolsource

`death-spool-array`

*death-spool-array*: arraysource

`kill-nearby-enemies-info`

`smack-mods`

*smack-mods*: surfacesource

`smack-up-mods`

*smack-up-mods*: surfacesource

target-gun

*gun-walk-mods*: surfacesource

Functions

`camera-rotate-to-vector`

camera-rotate-to-vector(arg0: vector, arg1: vector) => nonesource

`quat<-gun!`

quat<-gun!(arg0: quaternion, arg1: quaternion) => quaternionsource

`target-gun-ammo-out-pick`

target-gun-ammo-out-pick() => intsource

`target-gun-build-track-list`

target-gun-build-track-list() => nonesource

`target-gun-check`

target-gun-check() => nonesource

`target-gun-combo-start`

target-gun-combo-start(arg0: int, arg1: time-frame) => nonesource

`target-gun-compute-pos`

target-gun-compute-pos() => matrixsource

`target-gun-end-mode`

target-gun-end-mode(arg0: symbol) => symbolsource

`target-gun-event-handler`

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

`target-gun-exit`

target-gun-exit() => symbolsource

`target-gun-find-track`

target-gun-find-track() => nonesource

`target-gun-fire`

target-gun-fire(arg0: pickup-type) => nonesource

`target-gun-init`

target-gun-init(arg0: int) => nonesource

`target-gun-joint-points`

target-gun-joint-points() => nonesource

`target-gun-joint-pre`

target-gun-joint-pre() => nonesource

`target-gun-joint-pre0`

target-gun-joint-pre0() => nonesource

`target-gun-marking-menu`

(arg0: target) => nonesource

`target-gun-post`

target-gun-post() => nonesource

`target-gun-real-post`

target-gun-real-post() => nonesource

`target-gun-setup`

target-gun-setup(arg0: symbol) => nonesource

`target-gun-type-set!`

target-gun-type-set!(arg0: int) => nonesource

`target-top-anim-base-mode`

target-top-anim-base-mode(arg0: int) => nonesource

Variables

`gun-walk-mods`

target-h

Types

`sidekick`

sidekick: process-drawablesource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

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

water: water-control

sound: ambient-sound

carry: carry-info

state-flags: state-flags

state-time: time-frame

parent-override: pointer

control: control-info

anim-seed: uint64

shadow-in-movie?: symbol

special-anim-time: time-frame

special-anim-interp: float

special-anim-frame: float

offset: transformq

mirror: pointer

States

sidekick-clone: TODO

`target`

target: process-focusablesource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

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

water: water-control

sound: ambient-sound

carry: carry-info

state-flags: state-flags

state-time: time-frame

root-override: collide-shape

focus-status: focus-status

self-override: target

control: control-info

fact-override: fact-info-target

skel2: joint-control

shadow-backup: shadow-geo

target-flags: uint32

game: game-info

neck: joint-mod

head: joint-mod

upper-body: joint-mod

horns: joint-mod

hair: joint-mod

darkjak-interp: float

darkjak-giant-interp: float

arm-ik: joint-mod-ik

leg-ik: joint-mod-ik

foot: joint-mod

mech-ik: joint-mod-ik

init-time: time-frame

teleport-time: time-frame

state-hook-time: time-frame

state-hook: function

cam-user-mode: symbol

sidekick: pointer

manipy: pointer

mirror: pointer

attack-info: attack-info

attack-info-rec: attack-info

attack-info-old: attack-info

anim-seed: uint64

alt-cam-pos: vector

current-level: level

saved-pos: transformq

saved-owner: uint64

alt-neck-pos: vector

focus-search: array

excitement: float

shock-effect-time: time-frame

beard?: symbol

spool-anim: spool-anim

ambient-time: time-frame

fp-hud: handle

no-load-wait: uint64

no-look-around-wait: uint64

burn-proc: handle

pre-joint-hook: function

notify: handle

mode-cache: basic

mode-param1: handle

mode-param2: uint64

mode-param3: uint64

tobot-state: state

tobot?: symbol

tobot-recorder: basic

color-effect: basic

color-effect-start-time: time-frame

color-effect-duration: uint64

racer: racer-info

tube: tube-info

flut: flut-info

board: board-info

pilot: pilot-info

gun: gun-info

mech: mech-info

turret: turret-info

darkjak: darkjak-info

indax: indax-info

Methods

do-edge-grabs(obj: target, arg0: collide-cache, arg1: collide-edge-spec) => nonesource

init-target(obj: target, arg0: continue-point, arg1: symbol) => nonesource

States

target-attack: TODO

target-attack-air: TODO

target-attack-uppercut: TODO

target-attack-uppercut-jump: TODO

target-board-clone-anim: TODO

target-board-duck-stance: TODO

target-board-falling: TODO

target-board-flip: TODO

target-board-get-off: TODO

target-board-get-on: TODO

target-board-grab: TODO

target-board-grenade: TODO

target-board-halfpipe: TODO

target-board-hit: TODO

target-board-hit-ground: TODO

target-board-hold: TODO

target-board-jump: TODO

target-board-jump-kick: TODO

target-board-pegasus: TODO

target-board-ride-edge: TODO

target-board-stance: TODO

target-board-start: TODO

target-board-trickx: TODO

target-board-turn-to: TODO

target-board-wall-kick: TODO

target-carry-drop: TODO

target-carry-falling: TODO

target-carry-hit-ground: TODO

target-carry-jump: TODO

target-carry-pickup: TODO

target-carry-stance: TODO

target-carry-throw: TODO

target-carry-walk: TODO

target-clone-anim: TODO

target-continue: TODO

target-darkjak-bomb0: TODO

target-darkjak-bomb1: TODO

target-darkjak-get-off: TODO

target-darkjak-get-on: TODO

target-darkjak-giant: TODO

target-darkjak-running-attack: TODO

target-death: TODO

target-demo: TODO

target-double-jump: TODO

target-duck-high-jump: TODO

target-duck-high-jump-jump: TODO

target-duck-stance: TODO

target-duck-walk: TODO

target-edge-grab: TODO

target-edge-grab-jump: TODO

target-edge-grab-off: TODO

target-falling: TODO

target-float: TODO

target-flop: TODO

target-flop-hit-ground: TODO

target-flut-start: TODO

target-grab: TODO

target-gun-stance: TODO

target-gun-walk: TODO

target-hide: TODO

target-high-jump: TODO

target-hit: TODO

target-hit-ground: TODO

target-hit-ground-hard: TODO

target-ice-stance: TODO

target-ice-walk: TODO

target-indax-attack: TODO

target-indax-attack-air: TODO

target-indax-death: TODO

target-indax-double-jump: TODO

target-indax-falling: TODO

target-indax-hit: TODO

target-indax-hit-ground: TODO

target-indax-jump: TODO

target-indax-running-attack: TODO

target-indax-stance: TODO

target-indax-start: TODO

target-indax-trip: TODO

target-indax-walk: TODO

target-jump: TODO

target-jump-forward: TODO

target-launch: TODO

target-load-wait: TODO

target-look-around: TODO

target-mech-carry-drag: TODO

target-mech-carry-drop: TODO

target-mech-carry-falling: TODO

target-mech-carry-hit-ground: TODO

target-mech-carry-jump: TODO

target-mech-carry-pickup: TODO

target-mech-carry-stance: TODO

target-mech-carry-throw: TODO

target-mech-carry-walk: TODO

target-mech-clone-anim: TODO

target-mech-death: TODO

target-mech-falling: TODO

target-mech-get-off: TODO

target-mech-get-on: TODO

target-mech-grab: TODO

target-mech-hit: TODO

target-mech-hit-ground: TODO

target-mech-jump: TODO

target-mech-punch: TODO

target-mech-stance: TODO

target-mech-start: TODO

target-mech-walk: TODO

target-pilot-clone-anim: TODO

target-pilot-death: TODO

target-pilot-edge-grab: TODO

target-pilot-get-off: TODO

target-pilot-get-on: TODO

target-pilot-grab: TODO

target-pilot-hit: TODO

target-pilot-impact: TODO

target-pilot-stance: TODO

target-pilot-start: TODO

target-play-anim: TODO

target-pole-cycle: TODO

target-pole-flip-forward: TODO

target-pole-flip-forward-jump: TODO

target-pole-flip-up: TODO

target-pole-flip-up-jump: TODO

target-racing-start: TODO

target-roll: TODO

target-roll-flip: TODO

target-running-attack: TODO

target-slide-down: TODO

target-slide-down-to-ground: TODO

target-stance: TODO

target-stance-ambient: TODO

target-stance-look-around: TODO

target-startup: TODO

target-swim-down: TODO

target-swim-jump: TODO

target-swim-jump-jump: TODO

target-swim-stance: TODO

target-swim-up: TODO

target-swim-walk: TODO

target-title: TODO

target-tube: TODO

target-tube-death: TODO

target-tube-hit: TODO

target-tube-jump: TODO

target-tube-start: TODO

target-turn-around: TODO

target-turret-get-off: TODO

target-turret-get-on: TODO

target-turret-stance: TODO

target-wade-stance: TODO

target-wade-walk: TODO

target-walk: TODO

target-warp-in: TODO

target-warp-out: TODO

target-yellow-jump-blast: TODO

target-handler

Functions

`attack-mode-is-invinc`

attack-mode-is-invinc(arg0: symbol) => symbolsource

`target-attacked`

target-attacked(arg0: symbol, arg1: attack-info, arg2: process, arg3: touching-shapes-entry, arg4: state) => objectsource

`target-bonk-event-handler`

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

`target-dangerous-event-handler`

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

`target-effect-exit`

target-effect-exit() => nonesource

`target-exit`

target-exit() => nonesource

`target-generic-event-handler`

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

`target-jump-event-handler`

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

`target-send-attack`

target-send-attack(arg0: process, arg1: symbol, arg2: touching-shapes-entry, arg3: int, arg4: int, arg5: penetrate) => symbolsource

`target-shoved`

target-shoved(arg0: meters, arg1: meters, arg2: process, arg3: state) => objectsource

`target-standard-event-handler`

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

`target-state-hook-exit`

target-state-hook-exit() => nonesource

`target-walk-event-handler`

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

target-part

*lightning-darkjak-pill*: lightning-specsource

Functions

`birth-func-copy-target-y-rot`

birth-func-copy-target-y-rot(arg0: int, arg1: sparticle-cpuinfo, arg2: sparticle-launchinfo) => nonesource

`birth-func-ground-orient`

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

`birth-func-set-alpha-from-userdata`

birth-func-set-alpha-from-userdata(arg0: int, arg1: sparticle-cpuinfo, arg2: sparticle-launchinfo) => floatsource

`birth-func-target-orient`

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

`birth-func-vector-orient`

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

`lightning-probe-callback`

lightning-probe-callback(arg0: lightning-tracker) => nonesource

`part-tracker-track-target-joint`

part-tracker-track-target-joint(arg0: int, arg1: sparticle-cpuinfo, arg2: sparticle-launchinfo) => nonesource

`process-drawable-burn-effect`

process-drawable-burn-effect(arg0: time-frame) => rgbafsource

`process-drawable-shock-effect`

process-drawable-shock-effect(arg0: process-drawable, arg1: lightning-spec, arg2: function, arg3: sparticle-launcher, arg4: int, arg5: int, arg6: float) => objectsource

`process-drawable-shock-skel-effect`

process-drawable-shock-skel-effect(arg0: process-drawable, arg1: lightning-spec, arg2: function, arg3: sparticle-launcher, arg4: float, arg5: int, arg6: int) => nonesource

`process-drawable2-shock-effect`

process-drawable2-shock-effect(arg0: process-drawable, arg1: process-drawable, arg2: lightning-spec, arg3: function, arg4: sparticle-launcher) => nonesource

Variables

`lightning-darkjak-pill`

target-swim

Functions

`target-swim-tilt`

target-swim-tilt(arg0: float, arg1: float, arg2: float, arg3: float) => floatsource

target-tube

Types

`slide-control`

slide-control: process-drawablesource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

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

water: water-control

sound: ambient-sound

carry: carry-info

*TUBE-bank*: tube-banksource

state-flags: state-flags

state-time: time-frame

target: handle

pos: float

trans: vector

rot: vector

side: vector

Methods

slide-control-watch: unknown

slide-control-ride: unknown

`tube-bank`

tube-bank: basicsource

Fields

type: type

`tube-info`

tube-info: basicsource

Fields

type: type

entity: basic

tube: handle

downhill: vector

centertube: vector

downtube: vector

sidetube: vector

foretube: vector

old-transv: vector

mod-x: float

mod-y: float

start-time: time-frame

turn-anim-targ: float

turn-anim-frame: float

turn-anim-vel: float

tube-sound-id: sound-id

tube-sound-vol: float

tube-sound-pitch: float

Functions

`distance-from-tangent`

distance-from-tangent(arg0: path-control, arg1: float, arg2: vector, arg3: vector, arg4: vector, arg5: vector) => floatsource

`find-target-point`

find-target-point(arg0: vector) => floatsource

`target-tube-post`

target-tube-post() => nonesource

`target-tube-turn-anim`

target-tube-turn-anim() => nonesource

`tube-sounds`

tube-sounds() => sound-idsource

`tube-thrust`

tube-thrust(arg0: float, arg1: float) => nonesource

Variables

`TUBE-bank`

`tube-hit-mods`

*tube-hit-mods*: surfacesource

`tube-jump-mods`

*tube-jump-mods*: surfacesource

`tube-mods`

*tube-mods*: surfacesource

target-turret-shot

Types

`turret-shot`

turret-shot: guard-shotsource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

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

water: water-control

sound: ambient-sound

carry: carry-info

state-flags: state-flags

state-time: time-frame

root-override: collide-shape-moving

starting-pos: vector

starting-dir: vector

target-pos: vector

base-target-pos: vector

pre-move-transv: vector

timeout: time-frame

spawn-time: time-frame

options: projectile-options

last-target: handle

notify-handle: handle

owner-handle: handle

ignore-handle: handle

update-velocity: function

move: function

pick-target: function

max-speed: float

old-dist: float

old-dist-count: int32

hits: int32

max-hits: int32

tween: float

attack-mode: symbol

attack-id: uint32

damage: float

charge-level: float

sound-id: sound-id

stop-speed: meters

invinc-time: time-frame

hit-actor?: symbol

tail-pos: vector

hit-pos: vector

target-turret

Types

`base-turret`

base-turret: process-focusablesource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

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

water: water-control

sound: ambient-sound

carry: carry-info

*turret-exploder-params*: joint-exploder-static-paramssource

state-flags: state-flags

state-time: time-frame

root-override: collide-shape

focus-status: focus-status

hud: handle

condition: int32

shadow-backup: symbol

rider: handle

actor-group: pointer

actor-group-count: int32

alt-actor: symbol

smush-control: smush-control

sound-id: sound-id

sound-playing: symbol

cam-string-vector: vector

path-event: turret-path

path-u: float

path-u-prev: float

path-mode: uint16

path-speed: float

path-speed-mult: float

path-speed-mult-final: float

path-old-pos: vector

path-direction: symbol

pause-proc: function

gun-recoil-jmod: joint-mod-add-local

gun-index: int32

shot-timeout: time-frame

fire-time: time-frame

fire-time-interval: time-frame

enable-controls: symbol

available-for-pickup: symbol

roty: degrees

rotyv: degrees

rotyvv: degrees

roty-min: degrees

roty-max: degrees

rotx: degrees

rotxv: degrees

rotxvv: degrees

rotx-min: degrees

rotx-max: degrees

target-quat: quaternion

init-quat: quaternion

health: float

track-handle: handle

heat: float

heat-target: float

arrow-angle: degrees

arrow-alpha: float

arrow-red: float

red-filter-timer: time-frame

ride-height: float

Methods

idle: unknown

setup: unknown

active: unknown

shutdown: unknown

dormant: unknown

die: unknown

turret-init!(obj: base-turret, arg0: entity-actor, arg1: matrix) => nonesource

base-turret-method-34(obj: base-turret, arg0: process) => nonesource

base-turret-method-35(obj: base-turret) => nonesource

base-turret-method-36(obj: base-turret) => nonesource

base-turret-method-37(obj: base-turret) => nonesource

base-turret-method-38(obj: base-turret) => nonesource

base-turret-method-39(obj: base-turret, arg0: turret-path-event) => nonesource

base-turret-method-40(obj: base-turret) => nonesource

base-turret-method-41(obj: base-turret, arg0: vector) => symbolsource

base-turret-method-42(obj: base-turret, arg0: vector, arg1: vector, arg2: float) => floatsource

base-turret-method-43(obj: base-turret) => nonesource

base-turret-method-44(obj: base-turret, arg0: vector, arg1: vector) => nonesource

base-turret-method-45(obj: base-turret, arg0: object, arg1: symbol) => nonesource

base-turret-method-46(obj: base-turret, arg0: process) => processsource

base-turret-method-47(obj: base-turret) => nonesource

turret-event-handler(obj: base-turret, arg0: process, arg1: int, arg2: symbol, arg3: event-message-block) => objectsource

`hud-drill-turret-health`

hud-drill-turret-health: hud-turret-healthsource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

heap-base: pointer

heap-top: pointer

heap-cur: pointer

stack-frame-top: stack-frame

connection-list: connectable

stack: uint8

trigger-time: time-frame

last-hide-time: time-frame

offset: float

flags: hud-flags

values: hud-value

strings: hud-string

sprites: hud-sprite

icons: hud-icon

gui-id: sound-id

fade-interp: float

`hud-port-turret-health`

hud-port-turret-health: hud-turret-healthsource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

heap-base: pointer

heap-top: pointer

heap-cur: pointer

stack-frame-top: stack-frame

connection-list: connectable

stack: uint8

trigger-time: time-frame

last-hide-time: time-frame

offset: float

flags: hud-flags

values: hud-value

strings: hud-string

sprites: hud-sprite

icons: hud-icon

gui-id: sound-id

fade-interp: float

`hud-turret-health`

hud-turret-health: hudsource

Fields

type: type

mask: process-mask

clock: clock

parent: pointer

brother: pointer

child: pointer

ppointer: pointer

self: process-tree

pool: dead-pool

status: symbol

pid: int32

main-thread: cpu-thread

top-thread: cpu-thread

entity: entity-actor

level: level

state: state

next-state: state

trans-hook: function

post-hook: function

event-hook: function

allocated-length: int32

pad-unknown-0: uint32

heap-base: pointer

heap-top: pointer

heap-cur: pointer

stack-frame-top: stack-frame

connection-list: connectable

stack: uint8

trigger-time: time-frame

last-hide-time: time-frame

offset: float

flags: hud-flags

values: hud-value

strings: hud-string

sprites: hud-sprite

icons: hud-icon

gui-id: sound-id

fade-interp: float

`turret-info`

turret-info: basicsource

Fields

type: type

process: pointer

handle: handle

turret: pointer

grabbed?: symbol

quat: quaternion

trans: vector

`turret-path`

turret-path: structuresource

Fields

event-count: int32

event-tbl: inline-array

`turret-path-event`

turret-path-event: structuresource

Fields

pos: float

event-type: symbol

param: object

Functions

`init-turret-hud`

init-turret-hud(arg0: hud-turret-health, arg1: string) => nonesource

`set-recoil`

set-recoil(arg0: joint-mod, arg1: float, arg2: symbol) => nonesource

`target-turret-post`

target-turret-post() => nonesource

`turret-handler`

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

Variables

`turret-exploder-params`

target-util

*TARGET-bank*: target-banksource

Types

`target-bank`

target-bank: basicsource

Fields

type: type

jump-collide-offset: meters

jump-height-min: meters

jump-height-max: meters

double-jump-height-min: meters

double-jump-height-max: meters

flip-jump-height-min: meters

flip-jump-height-max: meters

duck-jump-height-min: meters

duck-jump-height-max: meters

flop-jump-height-min: meters

flop-jump-height-max: meters

attack-jump-height-min: meters

attack-jump-height-max: meters

edge-grab-jump-height-min: meters

edge-grab-jump-height-max: meters

swim-jump-height-min: meters

swim-jump-height-max: meters

tube-jump-height-min: meters

tube-jump-height-max: meters

carry-jump-height-min: meters

carry-jump-height-max: meters

mech-jump-height-min: meters

mech-jump-height-max: meters

mech-carry-jump-height-min: meters

mech-carry-jump-height-max: meters

indax-jump-height-min: meters

indax-jump-height-max: meters

indax-double-jump-height-min: meters

indax-double-jump-height-max: meters

roll-duration: uint64

roll-jump-pre-window: uint64

roll-jump-post-window: uint64

roll-timeout: uint64

roll-speed-min: meters

roll-speed-inc: meters

roll-flip-duration: uint64

roll-flip-height: meters

roll-flip-dist: meters

roll-flip-art-height: meters

roll-flip-art-dist: meters

duck-slide-distance: meters

fall-far: meters

fall-far-inc: meters

attack-timeout: uint64

ground-timeout: uint64

slide-down-timeout: uint64

fall-timeout: uint64

fall-stumble-threshold: meters

yellow-projectile-speed: meters

hit-invulnerable-timeout: uint64

same-attack-invulnerable-timeout: uint64

run-cycle-length: float

walk-cycle-dist: meters

walk-up-cycle-dist: meters

walk-down-cycle-dist: meters

walk-side-cycle-dist: meters

run-cycle-dist: meters

run-up-cycle-dist: meters

run-down-cycle-dist: meters

run-side-cycle-dist: meters

run-wall-cycle-dist: meters

duck-walk-cycle-dist: meters

wade-shallow-walk-cycle-dist: meters

wade-deep-walk-cycle-dist: meters

mech-walk-cycle-dist: meters

mech-run-cycle-dist: meters

smack-surface-dist: meters

smack-surface-height: meters

min-dive-depth: meters

root-radius: meters

root-offset: vector

body-radius: meters

edge-radius: meters

edge-offset: vector

edge-grab-height-off-ground: meters

head-radius: meters

head-height: meters

head-offset: vector

spin-radius: meters

spin-offset: vector

duck-spin-radius: meters

duck-spin-offset: vector

punch-radius: meters

punch-offset: vector

uppercut-radius: meters

uppercut0-offset: vector

uppercut1-offset: vector

flop-radius: meters

flop0-offset: vector

flop1-offset: vector

stuck-time: seconds

stuck-timeout: seconds

stuck-distance: meters

tongue-pull-speed-min: float

tongue-pull-speed-max: float

yellow-attack-timeout: uint64

fall-height: meters

mech-jump-thrust-fuel: float

strafe-jump-pre-window: uint64

strafe-jump: basic

strafe-duck-jump: basic

dark-jump-height-min: meters

dark-jump-height-max: meters

Functions

`are-still?`

are-still?() => symbolsource

`average-turn-angle`

average-turn-angle(arg0: target) => floatsource

`can-duck?`

can-duck?() => symbolsource

`can-exit-duck?`

can-exit-duck?(arg0: target) => symbolsource

`can-feet?`

can-feet?(arg0: symbol) => symbolsource

`can-hands?`

can-hands?(arg0: symbol) => symbolsource

`can-jump?`

can-jump?(arg0: symbol) => symbolsource

`can-play-stance-amibent?`

can-play-stance-amibent?() => symbolsource

`can-roll?`

can-roll?() => symbolsource

`debounce-speed`

debounce-speed(arg0: float, arg1: float, arg2: vector, arg3: vector) => floatsource

`delete-back-vel`

delete-back-vel() => nonesource

`fall-test`

fall-test(arg0: state, arg1: float) => nonesource

`ground-tween-initialize`

ground-tween-initialize(arg0: ground-tween-info, arg1: uint, arg2: uint, arg3: uint, arg4: uint, arg5: uint, arg6: uint, arg7: float) => ground-tween-infosource

`ground-tween-update`

ground-tween-update(arg0: ground-tween-info, arg1: float, arg2: float, arg3: float) => nonesource

`jump-hit-ground-stuck?`

jump-hit-ground-stuck?() => symbolsource

`move-forward`

move-forward(arg0: float) => vectorsource

`move-legs?`

move-legs?() => symbolsource

`set-forward-vel`

set-forward-vel(arg0: float) => vectorsource

`set-side-vel`

set-side-vel(arg0: float) => vectorsource

`slide-down-test`

slide-down-test() => nonesource

`smack-surface?`

smack-surface?(arg0: symbol) => symbolsource

`target-align-vel-z-adjust`

target-align-vel-z-adjust(arg0: float) => floatsource

`target-cam-pos`

target-cam-pos() => vectorsource

`target-collide-set!`

target-collide-set!(arg0: symbol, arg1: float) => intsource

`target-danger-set!`

target-danger-set!(arg0: symbol, arg1: symbol) => nonesource

`target-height-above-ground`

target-height-above-ground() => floatsource

`target-jump-go`

target-jump-go() => nonesource

`target-log-attack`

target-log-attack(arg0: attack-info, arg1: symbol) => symbolsource

`target-pos`

target-pos(arg0: int) => vectorsource

`target-rot`

target-rot() => quaternionsource

`target-start-attack`

target-start-attack() => nonesource

`target-time-to-ground`

target-time-to-ground() => time-framesource

`target-timed-invulnerable`

target-timed-invulnerable(arg0: time-frame, arg1: target, arg2: int) => nonesource

`target-timed-invulnerable-off`

target-timed-invulnerable-off(arg0: target, arg1: int) => nonesource

`vector-local+!`

vector-local+!(arg0: vector, arg1: vector) => vectorsource

Variables

`TARGET-bank`

`target-shadow-control`

*target-shadow-control*: shadow-controlsource

*attack-mods*: surfacesource

Functions

`init-var-jump`

init-var-jump(arg0: float, arg1: float, arg2: symbol, arg3: symbol, arg4: vector, arg5: float) => vectorsource

`mod-var-jump`

mod-var-jump(arg0: symbol, arg1: symbol, arg2: symbol, arg3: vector) => vectorsource

`target-falling-trans`

target-falling-trans(arg0: symbol, arg1: time-frame) => nonesource

`target-jump-top-anim`

target-jump-top-anim() => nonesource

Variables

`attack-mods`

`duck-mods`

*duck-mods*: surfacesource

`jump-attack-mods`

*jump-attack-mods*: surfacesource

`run-attack-mods`

*run-attack-mods*: surfacesource

`slide-down-mods`

*slide-down-mods*: surfacesource

`slide-jump-mods`

*slide-jump-mods*: surfacesource

`uppercut-jump-mods`

*uppercut-jump-mods*: surfacesource

target2