Helicopter assault

The pack

heliAssault

function heliAssault(): Pack<{ heliAssault: typeof api }>

Install the helicopter assault API.

Helpers

battleshipBoss

function battleshipBoss(): HeliBoss

Stage 1 boss: the battleship at sea, flown over at a fixed height while its turrets and launchers fire.

bomberBoss

function bomberBoss(): HeliBoss

Stage 3 boss: the giant bomber below you, flying on: you need top speed to get ahead of it.

createHeliAssault

function createHeliAssault(config: HeliConfig): HeliAssault

Create a helicopter assault game from a configuration.

fortressBoss

function fortressBoss(): HeliBoss

Stage 4 boss: the fortress at a dead end, behind view: guns around its middle; then a cannon rises; destroy it and the tower.

harbourStrikeKinds

function harbourStrikeKinds(): Record<string, HeliKind>

Harbour Strike's extra roster: container stacks, cranes, a lighthouse, a destroyer, a sea fort and an airship.

harbourStrikePreset

function harbourStrikePreset(o: ThunderBladeOptions = {}): HeliConfig

Harbour Strike's configuration.

harbourStrikeStages

function harbourStrikeStages(): HeliStage[]

The three stages.

HELI_STEP

const HELI_STEP: number

Simulation step (seconds).

heliDifficulty

function heliDifficulty(d: HeliDifficulty): HeliTuning

Difficulty multipliers: Arcade is the original tables; Normal and Easy soften fire and the hit box.

mirrorHeliPath

function mirrorHeliPath(p: DepthPathSpec): DepthPathSpec

The mirrored copy of a path (x negated).

mobileHqBoss

function mobileHqBoss(): HeliBoss

Stage 2 boss: Mobile HQ, four sections of beam guns either side, launchers between and two guns at its front.

thunderBladeGrounds

function thunderBladeGrounds(): Record<string, DepthSurface>

The grounds of every section by terrain.

thunderBladeKinds

function thunderBladeKinds(): Record<string, HeliKind>

The roster: tanks, mobile artillery, anti-aircraft guns, trucks, helicopters, gunships, jets, boats, the scenery that kills on contact (towers, trees, canyon walls, cave pillars, pipes) and the four bosses' hulls and parts. Points are estimates calibrated to the scores in arcade frames; cannon for air, missiles for the ground.

thunderBladePreset

function thunderBladePreset(o: ThunderBladeOptions = {}): HeliConfig

Thunder Blade's arcade configuration.

thunderBladeProjectiles

function thunderBladeProjectiles(): Record<string, HeliProjectile>

Enemy fire. Speeds are estimates (no disassembly exists).

thunderBladeStages

function thunderBladeStages(): HeliStage[]

The four stages of the arcade game.

thunderBladeView

function thunderBladeView(): HeliView

The two views of Thunder Blade, measured from 320 x 224 arcade frames (see REFERENCES.md): overhead the camera looks straight down with its vanishing point at row 186, near the helicopter, whose hub sits at row 157 under a 90 px rotor; behind, the horizon is at row 140 and the helicopter (30-35 px body, 85-95 px rotor) flies about 30 px above it, so the camera rides 5.3 m under it, 4.4 m above the ground (which puts a tank 47 rows under the horizon at 13.5 m and the city blocks, whose bases stand 8 rows under it, at about 90 m).

validateHeli

function validateHeli(c: HeliConfig): void

Check a configuration and throw a clear error for anything unsupported.

Classes

HeliAssault

class HeliAssault

A Thunder Blade style helicopter assault (see the pack docs).

• readonly config: HeliConfig — The configuration the game was created with; it is not changed.
• readonly camera: DepthCamera — The camera: its pose (tilt included) is set every step; draw with it.
• readonly field: DepthField — Every object: the helicopter, rounds, missiles, enemies, enemy fire, scenery, boss hulls and parts.
• state: HeliState — The whole game state (plain data); snapshot() copies it.
• constructor(config: HeliConfig)
• get stageDef(): HeliStage — The stage being played.
• get sectionDef(): HeliSection — The section being flown.
• get ground(): DepthSurface — The ground surface now.
• get look(): Record<string, string> — Presentation colours now.
• get playerObject(): DepthObject — The helicopter's field object.
• kind(name: string): HeliKind | undefined — A kind's definition.
• get cameraBlend(): HeliCameraBlend — The camera settings now (a blend while the camera swings between the views).
• get altitudeRange(): [number, number] — The altitude range of the section now.
• pointerStick(sx: number, sy: number): { x: number; y: number } — A stick from a pointer on the screen: its offset from the helicopter's place on screen is the deflection (the arcade's analog stick). Overhead, up the screen is a climb; behind, the helicopter follows the pointer.
• get speedShare(): number — Forward speed as a share of the lever's range, for the SPEED gauge (0..1).
• get progress(): number — Progress through the stage (0..1) for the DIST. meter, by sections flown.
• start(stage = this.config.startStage ?? 0): void — Start a new game (from startStage unless given).
• tick(seconds: number, input: HeliInput = {}): void — Advance by seconds in whole 1/60 s steps (at most 10 per call).
• drain(): HeliEvent[] — Notifications since the last drain.
• snapshot(): HeliSnapshot — Plain copy of the game.
• restore(s: HeliSnapshot): void — Restore a snapshot taken from a game with the same configuration.
• step(input: HeliInput = {}): void — One fixed step.
• addScore(points: number): void — Add points (extra lives and the top score follow).

Types

HeliBehindView

interface HeliBehindView

The behind view: the level Super Scaler camera behind the helicopter.

• horizon: number — Screen row of the horizon.
• playerDepth: number — Depth of the helicopter's plane in front of the camera.
• drop: number — The camera sits this far above the helicopter (world units), so the helicopter is drawn under the eye line.
• followX: number — Share of the helicopter's lateral position and of its altitude the camera follows.
• followY: number — How much of the helicopter's altitude the camera follows (0: fixed at the start altitude, 1: locked on it).
• pitch: number — Horizon shift in pixels per unit of climb rate (a climbing helicopter tips the view).

HeliBoss

interface HeliBoss

A huge boss: an indestructible hull carrying parts destroyed one by one. pass: the section ends at its length whatever is left (Thunder Blade's battleship, Mobile HQ and bomber: blast what you can on the way over or past); destroy: the course stops at a dead end hold ahead of it until every core part is down (the fortress).

• name: string — Name announced with the boss-start event and carried in the later boss events.
• kind: string — The hull's kind (hp null).
• parts: HeliBossPart[] — The parts the hull carries.
• clear: "pass" | "destroy" — pass: the section ends at its length whatever is left; destroy: the course stops until every core part is down.
• ahead: number — Distance ahead of the helicopter where it appears when the section starts.
• y?: number — Height of the hull's base (a bomber flies below you; ships and tanks sit on the surface). Default 0.
• vz?: number — Its own forward speed over the ground (0: fixed; the bomber flies on and must be overtaken).
• hold?: number — Destroy: where the course stops, ahead of the helicopter.
• sway?: number — Lateral sway (units) and its period (seconds).
• swayPeriod?: number — Sway period in seconds; default 6.
• points: number — Bonus for destroying every core part.

HeliBossPart

interface HeliBossPart

One part of a boss: a turret, a launcher, a beam gun, a cannon, a tower.

• kind: string — Kind of the part (its hp, points, hitBy and fire come from the kind).
• x: number — Offset from the hull's centre (x right, z ahead) and its base height above the hull's base (y).
• y: number — Base height above the hull's base in world units.
• z: number — Offset ahead of the hull's centre in world units; negative is behind it.
• core?: boolean — Required to defeat the boss (default true).
• after?: number — It rises into place only after this many other parts are destroyed (the fortress's cannon). Default 0.

HeliBossState

interface HeliBossState

A boss in progress.

• name: string — Name of the boss, as in its definition.
• hull: string — Field object id of the hull.
• parts: string[] — Part object ids by part index ("" while a part has not risen yet).
• down: number — Parts destroyed so far.
• time: number — Seconds since the boss appeared.
• z: number — World z of the hull.
• defeated: boolean — Whether every core part is down or the boss has been passed.

HeliCameraBlend

interface HeliCameraBlend

The camera settings of a view, or a blend of the two during a swing (t: 0 overhead .. 1 behind).

• tilt: number — Look-down angle in radians; 0 is level, pi / 2 straight down.
• axisY: number — Screen row of the vanishing point in pixels.
• ahead: number — The helicopter's distance ahead of the camera (world z).
• rise: number — Camera height relative to the helicopter.
• followX: number — Share of the helicopter's lateral position the camera follows, 0..1.

HeliConfig

interface HeliConfig

A full game.

• seed: number — Seed of the game's random stream.
• lives: number — Lives at the start of a game, 1 to 99; tuning.lives is added.
• view: HeliView — The camera: screen size and both views.
• flight: HeliFlight — How the helicopter flies.
• gun: HeliGun — The nose cannon.
• missiles: HeliMissiles — The missiles.
• kinds: Record<string, HeliKind> — Every kind of enemy, building, obstacle and boss part, by id.
• projectiles: Record<string, HeliProjectile> — Every enemy projectile, by id.
• paths: Record<string, DepthPathSpec> — Camera-frame depth paths for path motions; each also exists mirrored as id~m.
• stages: HeliStage[] — The stages, in order; at least one, at most 999.
• startStage?: number — Index of the stage a game starts on, 0 based; default 0.
• ending: "end" | "loop" — After the last stage: end (mission complete) or loop.
• scoring: HeliScoring — Scoring and extra lives.
• timing: HeliTiming — Timings of the sequences between play.
• tuning: HeliTuning — Difficulty multipliers.

HeliDifficulty

type HeliDifficulty = "easy" | "normal" | "arcade"

Easy / Normal / Arcade (Arcade = the original tables).

HeliEvent

type HeliEvent = | { kind: "stage-start"; stage: number; number: number; name: string } | { kind: "section-start"; section: number; view: HeliViewKind; terrain: string } | { kind: "swing"; from: HeliViewKind; to: HeliViewKind } | { kind: "ready" } | { kind: "wave"; index: number; enemy: string } | { kind: "shot"; id: string } | { kind: "missile"; id: string } | { kind: "hit"; target: string; x: number; y: number; z: number } | { kind: "deflect"; target: string; x: number; y: number; z: number } | { kind: "destroyed"; id: string; target: string; points: number; x: number; y: number; z: number; by: HeliWeapon; boss: boolean } | { kind: "enemy-fire"; id: string; projectile: string } | { kind: "boss-start"; name: string } | { kind: "boss-defeated"; name: string; points: number; x: number; y: number; z: number } | { kind: "boss-passed"; name: string } | { kind: "part-rise"; id: string; target: string } | { kind: "player-hit"; cause: string; grace: boolean } | { kind: "respawn" } | { kind: "extra-life"; lives: number } | { kind: "stage-clear"; stage: number; name: string; hits: number; time: number; bonus: number } | { kind: "game-over"; score: number } | { kind: "complete"; score: number }

Notifications for presentation.

HeliFire

interface HeliFire

An enemy's firing schedule.

• projectile: string — Id of the projectile it fires, a key of HeliConfig.projectiles.
• every: number — Seconds between volleys; first before the first one (default every).
• first?: number — Seconds before the first volley; default every. Scaled by HeliTuning.fireEvery.
• jitter?: number — Random extra delay up to this many seconds per volley.
• burst?: number — Projectiles per volley and the gap between them.
• burstGap?: number — Seconds between the projectiles of a burst; default 0.12.
• minAhead?: number — Fires only while its distance ahead of the helicopter (world z) lies in [minAhead, maxAhead].
• maxAhead?: number — Largest distance ahead of the helicopter (world z) at which it fires; default 0.6 of HeliView.far.

HeliFlight

interface HeliFlight

How the helicopter flies.

• w: number — Hit box (width across the stub wings, height, length) in world units; presenters draw the rotor larger.
• h: number — Hit box height in world units.
• d: number — Hit box length along the course in world units.
• x: [number, number] — Lateral range of the helicopter about the course centre line (world x).
• altitude: { overhead: [number, number]; behind: [number, number] } — Altitude ranges (world y of its centre) in each view.
• startAltitude: { overhead: number; behind: number } — Altitude at the start of each view.
• lateral: number — Lateral and climb speed at full stick (units per second).
• climb: number — Climb speed at full stick (units per second).
• approach: number — Speed toward an absolute stick target (pointer), units per second.
• accel: number — Acceleration toward the stick's lateral and climb speed (units per second squared): the craft drifts.
• maxBank: number — Bank (radians) at full lateral stick, and how fast it follows.
• bankRate: number — How fast the bank follows its target (radians per second).
• speed: { min: number; max: number; start: number; rate: number; turbo: number } — Forward speed: the throttle lever sets it between min (0: a hover) and max; turbo is the top of the lever. start is the lever at the start of a game (the arcade takes off with the lever back); rate the acceleration.
• takeoff: number | null — Altitude at the start of a game: the take-off from the ground (null: start in the air).
• invulnerable: number — Seconds of invulnerability after a respawn.

HeliGun

interface HeliGun

The nose cannon: continuous fire straight ahead at the helicopter's own height while held.

• every: number — Seconds between rounds while held.
• speed: number — Round speed relative to the helicopter (units per second).
• range: number — Distance before a round is spent.
• max: number — Most rounds in flight.
• size: number — Round box: width and depth, and its height (generous: the round's reach above and below the helicopter's height).
• reach: number — Round height in world units, centred on the helicopter's height, so it reaches half this far above and below it.
• barrels: number — Rounds side by side (twin cannon) and their spacing.
• spread: number — Lateral spacing between barrels in world units.

HeliInput

interface HeliInput

Player input for one step.

• x?: number — Stick -1..1: x right, y up (climb).
• y?: number — Climb stick, -1..1 with up (climb) positive.
• target?: { x: number; y: number } — An absolute stick target (pointer): lateral world x and altitude; overrides x / y.
• fire?: boolean — Cannon held; missile held.
• missile?: boolean — Missile launcher held.
• throttle?: number — Throttle lever movement -1..1, or an absolute position 0..1 (overrides).
• throttleLevel?: number — Absolute throttle lever position 0..1; overrides throttle.

HeliKind

interface HeliKind

Anything that is not the helicopter: tanks, guns, enemy helicopters, jets, boats, buildings, obstacles, boss parts.

• w: number — Box (world units): width, height, depth.
• h: number — Box height in world units.
• d?: number — Box depth along the course in world units; default the smaller of width and height (a boss hull: its width).
• anchor?: "base" | "centre" — base: stands on the ground (y is its bottom); centre: flies.
• hp: number | null — Hits to destroy; null: indestructible (blocks rounds, a building, a pillar).
• points: number — Score for destroying it.
• hitBy?: HeliWeapon[] — Which weapons hurt it (default: gun for fliers, missile and gun for things on the ground).
• lethal: boolean — Touching it destroys the helicopter (a tower, a rock pillar, a pipe, a ramming jet).
• counts?: boolean — Counts toward HIT (default: true when it has hp and points).
• fire?: HeliFire — Its firing schedule; omitted: it never fires.
• family?: string — Free text for presentation (tank, heli, jet, gun, boat, tower, pillar, pipe, bridge ...).

HeliMissiles

interface HeliMissiles

The missiles: unlimited, launched in pairs with a slow reload; they drop to the surface ahead (the ground, or the deck of a boss under them) and run along it, bursting with a blast that hits every ground target near them.

• every: number — Seconds between launches while held (each launch is pair missiles).
• pair: number — Missiles per launch, side by side; at least 1.
• speed: number — Speed relative to the helicopter and the descent rate toward the ground (units per second).
• descent: number — Descent rate toward the surface below, in units per second.
• range: number — Distance before a missile is spent.
• max: number — Most missiles in flight.
• size: number — Missile box width and height in world units; its depth is three times this.
• spread: number — Lateral spacing of a pair.
• blast: number — Blast radius of a hit (world units).

HeliMotion

type HeliMotion = /** On the ground, fixed in the world (`ahead`: distance ahead where it appears); `vz` drives it along the course (tanks on a road: negative toward you). */ | { type: "ground"; ahead: number; vx?: number; vz?: number } /** Flies at the helicopter's height from ahead toward it at `speed` relative to the ground, breaking off sideways below `breakAt`. */ | { type: "head-on"; ahead: number; speed: number; breakAt?: number; breakX?: number } /** Overtakes from behind (jets in the overhead view streak up the screen past you). */ | { type: "overtake"; behind: number; speed: number } /** Comes in, keeps station `hold` ahead of the helicopter for `time` seconds while drifting toward its line, then leaves. */ | { type: "hover"; ahead: number; speed: number; hold: number; time: number; drift?: number } /** Crosses the course sideways `ahead` of the helicopter. */ | { type: "cross"; ahead: number; speed: number } /** Rises from the ground (or the water) `ahead` of the helicopter to its height at `climb`, closing at `speed` to ram it. */ | { type: "rise"; ahead: number; speed: number; climb: number } /** An authored camera-frame depth path (a path id in `HeliConfig.paths`; `~m` is its mirror). */ | { type: "path"; path: string; end?: "remove" | "hold" | "continue" }

How a wave moves. Positions are relative to the helicopter when the member spawns (x right, y up from the ground or the helicopter's height, z ahead); speeds are units per second over the ground.

HeliOverheadView

interface HeliOverheadView

The overhead camera: scaled-depth's camera tilted to look down, following the helicopter's altitude.

• tilt: number — Look-down angle (radians): pi / 2 is straight down.
• axisY: number — Screen row of the vanishing point (the camera's axis): the point the towers lean away from.
• above: number — Camera height above the helicopter (world units): the helicopter's own scale is focal / above.
• ahead: number — Where the helicopter sits ahead of the camera's spot (world z), which puts it on screen below or above the axis.
• followX: number — Share of the helicopter's lateral position the camera follows (0: fixed over the course, 1: locked on it).

HeliPlayerState

interface HeliPlayerState

The helicopter.

• x: number — World x and altitude (centre), and the drift velocity (units per second).
• y: number — Altitude of the helicopter's centre in world units.
• vx: number — Lateral drift velocity in units per second.
• vy: number — Climb drift velocity in units per second.
• drop: number — How far the wreck has fallen below y while dying (the camera holds its height).
• bank: number — Bank (radians, positive right side down) and climb rate share -1..1 (for the art and the behind view's pitch).
• climb: number — Climb rate as a share of full climb speed, -1..1.
• throttle: number — Throttle lever 0..1 and forward speed.
• speed: number — Forward speed in units per second.
• invulnerable: number — Seconds of invulnerability left; 0 when vulnerable.
• alive: boolean — Whether the helicopter is flying (false while it is falling after a hit).
• dying: number — Seconds since it was shot down; 0 while alive.
• cause: string — What brought it down (a kind or projectile id).

HeliProjectile

interface HeliProjectile

An enemy projectile.

• w: number — Box width in world units.
• h: number — Box height in world units.
• speed: number — Speed (units per second) toward where the helicopter was.
• homing?: number — Turn rate toward the helicopter (radians per second); 0: straight.
• shootable?: boolean — The cannon can shoot it down.
• points?: number — Score for shooting it down; used only when shootable; default 0.
• life?: number — Seconds before it fizzles (default 4).

HeliScoring

interface HeliScoring

Scoring and lives.

• extraLives: number[] — Scores that award an extra life, in order, and an interval after them (null: none).
• extraEvery: number | null — Points between extra lives once the extraLives list is used up; with an empty list the first comes at this score (null: none).
• topScore: number — The top score at the start of a game.
• flight: { points: number; per: number } — Points for distance flown: points every per units (0: none).
• clearBonus: { perHit: number; perSecond: number; par: number; flat: number } — Stage-clear bonus from enemies destroyed and the time taken: perHit per HIT this stage, plus perSecond for every second under par seconds, plus flat.
• grace: number — Seconds at the start of a game in which a crash costs no life (the arcade's Time DIP: 30 or 0).

HeliSection

interface HeliSection

One section of a stage: a stretch flown in one view, ending in a boss or at its length.

• view: HeliViewKind — The view this section is flown in.
• length: number — Distance flown to finish it (ignored while a boss is alive).
• terrain: string — Terrain name for presentation (city, sea, desert, canyon, cave, forest, river, refinery ...).
• ground: DepthSurface — Ground surface drawn and collided with in this section (a scaled-depth surface).
• look?: Record<string, string> — Presentation colours (sky0, sky1, haze, night ...).
• scenery?: Omit<SceneryOptions, "seed" | "name"> & { seed?: number } — Scenery streamed by distance: buildings, rock walls, pillars, trees, pipes (x about the course centre line).
• waves: HeliWave[] — Waves in order of their at distance.
• boss?: HeliBoss — A boss that appears when the section starts.
• altitude?: [number, number] — Altitude range override for this section (a cave; equal ends: the fixed height of a bombing run).

HeliShape

type HeliShape = JetShape

Named formation shapes (jet-combat's formation): members are spacing apart, x across, z along the course.

HeliSnapshot

interface HeliSnapshot

A snapshot of a running game.

• state: HeliState — The game state (plain data).
• field: DepthFieldSnapshot — The scaled-depth field's snapshot: every object in the world.

HeliStage

interface HeliStage

A stage: its sections in order.

• name: string — Stage name, announced with the stage-start and stage-clear events.
• sections: HeliSection[] — The stage's sections, flown in order; at least one.

HeliState

interface HeliState

The whole game state (plain data).

• status: HeliStatus — Where the game is in its sequence.
• statusTime: number — Seconds spent in the current status.
• stage: number — Index of the stage being played, 0 based.
• stageNumber: number — Stage number shown to the player, 1 based; it keeps counting when the stages loop.
• loop: number — Times the stage list has looped (0 on the first run through).
• section: number — Index of the section being flown within its stage, 0 based.
• view: HeliViewKind — The view now, and the camera's swing from the other one (0..1, 1 when settled).
• swing: number — Progress of the camera's swing from the other view, 0..1; 1 when settled.
• distance: number — Distance flown in this section and the camera's z; seconds in this stage.
• stageTime: number — Seconds spent in this stage.
• camZ: number — World z of the camera.
• sectionZ: number — World z of the camera when the current section began.
• time: number — Seconds since the game was created or started.
• score: number — Current score.
• topScore: number — Highest score seen, kept across games.
• lives: number — Lives left, counting the helicopter being flown: a crash costs one, and the game ends when none are left.
• nextExtra: number — Score at which the next extra life is awarded; Infinity when there are no more.
• extraIndex: number — How many entries of HeliScoring.extraLives have been awarded.
• gunClock: number — Seconds until the cannon can fire again.
• missileClock: number — Seconds until the missiles can launch again.
• flightClock: number — Distance flown since the last flight score was awarded, in world units.
• takeoff: boolean — Lifting off the pad at the start of a game (TAKE OFF).
• player: HeliPlayerState — The helicopter.
• hits: number — Enemies shot down this stage (HIT).
• wavesFired: number — Waves of this section triggered so far; also the index of the next one.
• pending: { at: number; wave: number; member: number; x: number; y: number }[] — Members of triggered waves still waiting to appear: at is the state time (seconds) they are due, wave the wave index in the section, member the member index, and x, y the helicopter's position when the wave was triggered.
• boss: HeliBossState | null — The boss being fought, or null.
• acc: number — Unspent simulation time (seconds) left over from tick, below one step.
• stats: { shots: number; missiles: number; kills: number; deaths: number } — Counts for the game: cannon volleys, missile launches, enemies destroyed and helicopters lost.
• rng: number[] — The seeded random stream's state: four words, from the kernel's rng.snapshot(). It advances in place and is saved with the state.

HeliStatus

type HeliStatus = "attract" | "ready" | "playing" | "swing" | "boss" | "dying" | "clear" | "over" | "complete"

Game status.

HeliTiming

interface HeliTiming

Sequence timings in seconds.

• ready: number — Seconds of READY (and the take-off) before play starts.
• dying: number — Seconds the wreck falls before the helicopter respawns or the game ends.
• clear: number — Seconds the stage-clear screen shows before the next stage begins.

HeliTuning

interface HeliTuning

Difficulty multipliers.

• fireEvery: number — Enemy fire interval multiplier (bigger: less fire).
• projectileSpeed: number — Enemy projectile speed multiplier.
• hitbox: number — Helicopter hit box multiplier.
• lives: number — Extra lives at the start.
• density: number — Share of each wave's members that appear (1: all).

HeliView

interface HeliView

Both views and how the camera swings between them.

• width: number — Screen width and height in pixels (the arcade's 320 x 224).
• height: number — Screen height in pixels.
• focal: number — Pixels per world unit at depth 1.
• overhead: HeliOverheadView — Camera settings of the overhead view.
• behind: HeliBehindView — Camera settings of the behind view.
• swing: number — Seconds the camera takes to swing from one view to the other (0: a cut).
• far: number — Farthest depth objects are drawn and enter; units behind the camera before they are dropped.
• behindDrop: number — Distance behind the camera (world z) at which objects are dropped.

HeliViewKind

type HeliViewKind = "overhead" | "behind"

The two views: overhead looks down on the world (Thunder Blade's vertical sections), behind follows the helicopter into the screen.

HeliWave

interface HeliWave

A wave: count members of kind, triggered at a section distance.

• at: number — Distance flown in the section (world units) at which the wave is triggered; waves are listed in increasing order.
• kind: string — Id of the kind of every member, a key of HeliConfig.kinds.
• count: number — Members in the wave, 1 to 64; HeliTuning.density may thin it (at least one member always appears).
• shape?: HeliShape — Formation shape of the members; default single. Ignored when offsets is given.
• offsets?: { x?: number; y?: number; z?: number }[] — Explicit member positions relative to the formation centre (x right, y up, z ahead, world units); member i uses entry i modulo the length. Overrides shape.
• spacing?: number — Distance between neighbouring members in a formation, in world units; default 8.
• x?: number — Formation centre relative to the course centre line (x) and to the helicopter's height (y; ground waves: above the ground).
• y?: number — Formation centre height (world units): relative to the helicopter's height for fliers, above the ground for ground waves; default 0.
• aim?: boolean — Take the helicopter's lateral position as the centre (default true for fliers, false on the ground).
• every?: number — Seconds between members appearing.
• mirror?: boolean — Flip the wave left to right (x offsets, lateral speed and an authored path are mirrored).
• motion: HeliMotion — How the members move.

HeliWeapon

type HeliWeapon = "gun" | "missile"

Which of the helicopter's weapons hurt a kind.

ThunderBladeOptions

interface ThunderBladeOptions

Options for thunderBladePreset.

• difficulty?: HeliDifficulty — Difficulty tuning: easy, normal or arcade (the original tables); default normal.
• lives?: number — Lives (the arcade's DIP: 2, 3, 4 or 5; default 3).
• startStage?: number — Stage to start on (1-based).
• seed?: number — Seed of the game's random stream; default 1987.
• grace?: number — The Time DIP: seconds at the start in which a crash costs no life (30 or 0; default 30).