The Luau API

MemoryType

type MemoryType = "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "f32"

Fields

type Fields = {
    hero: {
        position: {
            x: number, -- Where the hero is (gHeroPos).
            y: number,
            z: number,
        },
        facing: number, -- The way he faces (rot.z), in radians.
        move_yaw: number, -- Where the stick moves him: the stick's angle plus the camera's yaw.
        state: number, -- read-only; His state: 0 standing, 2 running, 7 jumping, ...
    },
    bolts: number, -- The player's bolts.
}

Pad_ProcessReportFn

rac1.pad.process_report (Pad_ProcessReport) void(u32,u32,i32): One pad report into the pad's state (PadState, at pad), each poll, before the tick reads it.

type Pad_ProcessReportFn = (pad: number, report: number, size: number) -> ()

Hero_UpdateMotionInputFn

rac1.player.update_motion_input (Hero_UpdateMotionInput) void(): The stick read into the hero, early in his update each tick.

type Hero_UpdateMotionInputFn = () -> ()

Hero_TurnToHeadingFn

rac1.player.turn_to_heading (Hero_TurnToHeading) void(i32,f32,f32,f32): Eases the hero's facing toward his move yaw.

type Hero_TurnToHeadingFn = (mode: number, accel: number, damping: number, limit: number) -> ()

Hero_SetPlanarVelocityFn

rac1.player.set_planar_velocity (Hero_SetPlanarVelocity) void(f32): The hero's velocity at his ground speed along an angle; an angle above pi means his facing.

type Hero_SetPlanarVelocityFn = (angle: number) -> ()

FollowCamera_ApplyOverridesFn

rac1.camera.follow.apply_overrides (FollowCamera_ApplyOverrides) void(u32): The follow camera's per-tick requests from the hero's state; the camera moby's update calls it before it places the eye.

type FollowCamera_ApplyOverridesFn = (camera: number) -> ()

Hero_AdvanceAnimationFn

rac1.player.advance_animation (Hero_AdvanceAnimation) void(): Ratchet's animation moved on by his animation speed, once a tick after his state's update.

type Hero_AdvanceAnimationFn = () -> ()

Item_GiveFn

rac1.item.give (Item_Give) void(i32,i32): Gives the player item id (GiveItem): sets its owned and obtained bytes, shows its banner, gives its starting ammo, marks it bought in the vendor's stock and adds it to the quick select; equip non-zero also puts it in hand. Every item the game gives goes through it but the Persuader's.

type Item_GiveFn = (id: number, equip: number) -> ()

Planet_UnlockFn

rac1.planet.unlock (Planet_Unlock) void(i32): Unlocks a planet's coordinates (UnlockPlanet): its flag (one byte per level), the galaxy list, and its banner unless it is the planet the player is on.

type Planet_UnlockFn = (planet: number) -> ()

Vendor_InitLevelStockFn

rac1.vendor.init_level_stock (Vendor_InitLevelStock) void(): The vendor's stock at each level start (VendorStockLevelInit): gives the Bomb Glove while the player has none, keeps the stock's known items and adds the level's new weapon.

type Vendor_InitLevelStockFn = () -> ()

Vendor_BuildItemListFn

rac1.vendor.build_item_list (Vendor_BuildItemList) void(i32): The vendor menu's list (VendorBuildItemList), from the stock and the items owned: each time the menu opens and after each purchase. skip_unflagged leaves out what is for sale (the menu opened from the pause screen).

type Vendor_BuildItemListFn = (skip_unflagged: number) -> ()

GoldBolts_CountCollectedFn

rac1.gold_bolt.count_collected (GoldBolts_CountCollected) i32(): The gold bolts collected, at most 40 (count_nonzero_entries_up_to_40): what the pause screen shows; the unspent ones are this less 4 per gold weapon.

type GoldBolts_CountCollectedFn = () -> number

Hero_TakeDamageFn

rac1.player.take_damage (Hero_TakeDamage) void(i32): Takes hit points off the hero's health (Hero_TakeDamage): at most one a call, none for 0, then the HUD's health bank. Every hit the hero takes goes through it but the instant kills (falls, crushers), which set his health to 0.

type Hero_TakeDamageFn = (amount: number) -> ()

Moby_GetHitMessageFn

rac1.combat.get_hit (Moby_GetHitMessage) u32(u32,i32,i32): The hit pending on moby (MobyGetHitMessage): the record of the last hit posted to it (+0x20 the attacker, +0x24 the flags, +0x2C the damage, an f32) when its flags match mask, else 0, dropping the hit unless keep. How the hero and every enemy read the hits they take, each tick, so a hit may be read more than once.

type Moby_GetHitMessageFn = (moby: number, mask: number, keep: number) -> number

Weapon_TakeAmmoFn

rac1.weapon.take_ammo (Weapon_TakeAmmo) i32(i32,i32): Takes amount of ammo from item for a shot (TakeAmmo; -1 is the item in hand): 1 when taken, 0 when there is too little. An item with no ammo limit takes none and gives 1.

type Weapon_TakeAmmoFn = (item: number, amount: number) -> number

Moby_RecordDeathFn

rac1.moby.record_death (Moby_RecordDeath) void(u32,i32,i32): Records a placed moby's death or a crate's break (SetDeathBits): its save id's killed bits (none for a save id below 0), its mission, then drops its bolts: about the s16 at +0xB4 (or what a tallied source has left of +0xB6), which it then clears.

type Moby_RecordDeathFn = (moby: number, flags: number, index: number) -> ()

Level_LoadGameplayFn

rac1.level.load_gameplay (Level_LoadGameplay) u32(i32): Loads a level's gameplay file into the level heap (LoadLevelGameplay), once per level start: the settings, the placed mobys and their pvars, the spare moby pool, the paths and the rest; returns the heap cursor. After it, every placed moby exists and none has run.

type Level_LoadGameplayFn = (full: number) -> number

Hero_ApproachSpeedFn

rac1.player.approach_speed (Hero_ApproachSpeed) void(f32,f32): Eases the hero's ground speed (+0x194, the speed Hero_SetPlanarVelocity moves him at) toward his target speed (+0x190) by up when below it and by down when above, each tick he moves on foot, in every level.

type Hero_ApproachSpeedFn = (up: number, down: number) -> ()

Ship_TravelToFn

rac1.ship.travel_to (Ship_TravelTo) void(i32): The ship's travel from the planet select (ShipTravelTo), once its menu closes: to the planet it is on (dest the level now), the landing again, as backing out of the select does; to another, the game saved to the card and the ship's flight out of the level, whose loop then ends and flies to dest. After the take-off; a level's only way to another planet by ship.

type Ship_TravelToFn = (dest: number) -> ()

Moby_CollectBoltFn

rac1.moby.collect_bolt (Moby_CollectBolt) void(u32): Collects a bolt (collect_bolt), called by the bolt update (classes 13 to 16) once the bolt reaches the hero: adds its value (1, or 5 / 20 / 50 for classes 14 / 15 / 16) to the bolt count, the level's total and its source's stats, shows the bolt counter and makes two sparkles at it. The bolt update then deletes the bolt (a placed one marked taken) whether or not this ran.

type Moby_CollectBoltFn = (bolt: number) -> ()

MobyUpdateFn

rac1.moby.<class>.update (experimental): (moby: number) -> (), or () -> () where it gets no moby.

type MobyUpdateFn = (moby: number) -> ()