@clunkyard/sdk 0.0.0-stage → 2.0.0

package/words.js

@@ -0,0 +1,265 @@
+'use strict';
+// Generated from protocol/v2/api.json by protocol/v2/codegen/dsl.js; do not edit. Run `make api`.
+//
+// The DSL words, as the core gives them: one f64 a word in the record
+// cy_dsl_words_v1 (776 bytes), which cy_dsl_fill_v1 fills once a
+// turn, outside the DSL budget. read() turns it into the interpreter's words;
+// booleans are booleans and enums their protocol 2 names, except where the
+// DSL keeps an older spelling (control-model reads "targets" for direct).
+// Older names (ALIASES) read the same slot. CONTROLS maps each DSL action
+// keyword to the core setter for its act field; the core clamps and writes
+// the act.
+
+const API_VERSION = '2.0.0';
+const RECORD = 'cy_dsl_words_v1';
+const SIZE = 776;
+// The Tracker keeps a passive cue this many ticks.
+const CUE_TICKS = 60;
+// What a distance reads when the thing it measures to is absent.
+const FAR = 1000000000000;
+
+const RULESET = Object.freeze([null, "classic", "inertial-2d", "gravity-flat", "gravity-hills", "zero-g"]);
+const CONTROL = Object.freeze([null, "targets", "forces"]);
+const TERRAIN_KIND = Object.freeze([null, "none", "flat", "hills"]);
+
+const WORDS = Object.freeze([
+  { name: "ruleset", index: 0, type: 'text', enum: 'ruleset' },
+  { name: "physics-mode", index: 1, type: 'boolean' },
+  { name: "zero-g", index: 2, type: 'boolean' },
+  { name: "control-model", index: 3, type: 'text', enum: 'control' },
+  { name: "inertial", index: 4, type: 'boolean' },
+  { name: "mode3", index: 5, type: 'boolean' },
+  { name: "tick", index: 6, type: 'number' },
+  { name: "time", index: 7, type: 'number' },
+  { name: "remaining", index: 8, type: 'number' },
+  { name: "width", index: 9, type: 'number' },
+  { name: "height", index: 10, type: 'number' },
+  { name: "depth", index: 11, type: 'number' },
+  { name: "gravity-x", index: 12, type: 'number' },
+  { name: "gravity-y", index: 13, type: 'number' },
+  { name: "gravity-z", index: 14, type: 'number' },
+  { name: "terrain-kind", index: 15, type: 'text', enum: 'terrain_kind' },
+  { name: "hills", index: 16, type: 'boolean' },
+  { name: "health", index: 17, type: 'number' },
+  { name: "x", index: 18, type: 'number' },
+  { name: "y", index: 19, type: 'number' },
+  { name: "z", index: 20, type: 'number' },
+  { name: "vx", index: 21, type: 'number' },
+  { name: "vy", index: 22, type: 'number' },
+  { name: "vz", index: 23, type: 'number' },
+  { name: "heading", index: 24, type: 'number' },
+  { name: "pitch", index: 25, type: 'number' },
+  { name: "yaw-rate", index: 26, type: 'number' },
+  { name: "pitch-rate", index: 27, type: 'number' },
+  { name: "roll-rate", index: 28, type: 'number' },
+  { name: "forward-x", index: 29, type: 'number' },
+  { name: "forward-y", index: 30, type: 'number' },
+  { name: "forward-z", index: 31, type: 'number' },
+  { name: "right-x", index: 32, type: 'number' },
+  { name: "right-y", index: 33, type: 'number' },
+  { name: "right-z", index: 34, type: 'number' },
+  { name: "up-x", index: 35, type: 'number' },
+  { name: "up-y", index: 36, type: 'number' },
+  { name: "up-z", index: 37, type: 'number' },
+  { name: "grounded", index: 38, type: 'boolean' },
+  { name: "altitude", index: 39, type: 'number' },
+  { name: "battery", index: 40, type: 'number' },
+  { name: "battery-capacity", index: 41, type: 'number' },
+  { name: "aim", index: 42, type: 'number' },
+  { name: "aim-pitch", index: 43, type: 'number' },
+  { name: "cooldown", index: 44, type: 'number' },
+  { name: "scan-heading", index: 45, type: 'number' },
+  { name: "scan-pitch", index: 46, type: 'number' },
+  { name: "scan-arc", index: 47, type: 'number' },
+  { name: "scan-range", index: 48, type: 'number' },
+  { name: "contact", index: 49, type: 'boolean' },
+  { name: "range", index: 50, type: 'number' },
+  { name: "bearing", index: 51, type: 'number' },
+  { name: "elevation", index: 52, type: 'number' },
+  { name: "cue-present", index: 53, type: 'boolean' },
+  { name: "cue-error", index: 54, type: 'number' },
+  { name: "bearing-rate", index: 55, type: 'number' },
+  { name: "zone-active", index: 56, type: 'boolean' },
+  { name: "zone-radius", index: 57, type: 'number' },
+  { name: "storm-active", index: 58, type: 'boolean' },
+  { name: "storm-radius", index: 59, type: 'number' },
+  { name: "hill-active", index: 60, type: 'boolean' },
+  { name: "hill-radius", index: 61, type: 'number' },
+  { name: "score", index: 62, type: 'number' },
+  { name: "score-best", index: 63, type: 'number' },
+  { name: "speed", index: 64, type: 'number' },
+  { name: "gravity", index: 65, type: 'boolean' },
+  { name: "terrain-height", index: 66, type: 'number' },
+  { name: "battery-fraction", index: 67, type: 'number' },
+  { name: "aim-error", index: 68, type: 'number' },
+  { name: "power-min", index: 69, type: 'number' },
+  { name: "power-max", index: 70, type: 'number' },
+  { name: "shot-speed-base", index: 71, type: 'number' },
+  { name: "shot-speed-per-power", index: 72, type: 'number' },
+  { name: "shot-cost-base", index: 73, type: 'number' },
+  { name: "shot-cost-per-power", index: 74, type: 'number' },
+  { name: "zone-distance", index: 75, type: 'number' },
+  { name: "zone-bearing", index: 76, type: 'number' },
+  { name: "zone-elevation", index: 77, type: 'number' },
+  { name: "storm-distance", index: 78, type: 'number' },
+  { name: "storm-bearing", index: 79, type: 'number' },
+  { name: "storm-heading", index: 80, type: 'number' },
+  { name: "cue-muzzle", index: 81, type: 'boolean' },
+  { name: "cue-bearing", index: 82, type: 'number' },
+  { name: "cue-elevation", index: 83, type: 'number' },
+  { name: "cue-range", index: 84, type: 'number' },
+  { name: "cue-age", index: 85, type: 'number' },
+  { name: "pickup-present", index: 86, type: 'boolean' },
+  { name: "pickup-bearing", index: 87, type: 'number' },
+  { name: "pickup-elevation", index: 88, type: 'number' },
+  { name: "pickup-range", index: 89, type: 'number' },
+  { name: "on-hill", index: 90, type: 'boolean' },
+  { name: "hill-held", index: 91, type: 'boolean' },
+  { name: "hill-bearing", index: 92, type: 'number' },
+  { name: "hill-elevation", index: 93, type: 'number' },
+  { name: "hill-range", index: 94, type: 'number' },
+  { name: "hill-time", index: 95, type: 'number' },
+  { name: "hill-to-win", index: 96, type: 'number' },
+]);
+
+const ALIASES = Object.freeze({
+  energy: "battery",
+  "max-energy": "battery-capacity",
+  "energy-fraction": "battery-fraction",
+  "fire-base": "shot-cost-base",
+  "fire-per-power": "shot-cost-per-power",
+});
+
+const CONTROLS = Object.freeze({
+  drive: { symbol: 'cy_drive_throttle', act: ["drive","throttle"], type: 'number', glyph: "drive!" },
+  turn: { symbol: 'cy_drive_turn', act: ["drive","turn"], type: 'number', glyph: "turn!" },
+  pitch: { symbol: 'cy_drive_pitch_turn', act: ["drive","pitchTurn"], type: 'number', glyph: "pitch-turn!" },
+  thrust: { symbol: 'cy_drive_thrust', act: ["forces","thrust"], type: 'number', glyph: "thrust!" },
+  strafe: { symbol: 'cy_drive_strafe', act: ["forces","strafe"], type: 'number', glyph: "strafe!" },
+  lift: { symbol: 'cy_drive_lift', act: ["forces","lift"], type: 'number', glyph: "lift!" },
+  "yaw-torque": { symbol: 'cy_drive_yaw_torque', act: ["forces","yawTorque"], type: 'number', glyph: "yaw-torque!" },
+  "pitch-torque": { symbol: 'cy_drive_pitch_torque', act: ["forces","pitchTorque"], type: 'number', glyph: "pitch-torque!" },
+  "roll-torque": { symbol: 'cy_drive_roll_torque', act: ["forces","rollTorque"], type: 'number', glyph: "roll-torque!" },
+  brake: { symbol: 'cy_drive_brake', act: ["forces","brake"], type: 'number', glyph: "brake!" },
+  "aim-heading": { symbol: 'cy_gun_aim_heading', act: ["aim","heading"], type: 'number', glyph: "aim!" },
+  "aim-pitch": { symbol: 'cy_gun_aim_pitch', act: ["aim","pitch"], type: 'number', glyph: "aim-pitch!" },
+  fire: { symbol: 'cy_gun_fire', act: ["fire",null], type: 'flag', glyph: "fire!" },
+  power: { symbol: 'cy_gun_power', act: ["fire","power"], type: 'number', glyph: "power!" },
+  "scan-heading": { symbol: 'cy_scanner_heading', act: ["scan","heading"], type: 'number', glyph: "scan-heading!" },
+  "scan-arc": { symbol: 'cy_scanner_arc', act: ["scan","arc"], type: 'number', glyph: "scan-arc!" },
+  "scan-pitch": { symbol: 'cy_scanner_pitch', act: ["scan","pitch"], type: 'number', glyph: "scan-pitch!" },
+  "status-text": { symbol: 'cy_status_text', act: ["status","text"], type: 'text', glyph: "status-text!" },
+  "status-value": { symbol: 'cy_status_value', act: ["status","value"], type: 'number', glyph: "status-value!" },
+});
+
+// The words from the record: w is a Float64Array (or an array of numbers)
+// holding it at element base.
+function read(w, base = 0) {
+  const words = {
+    ruleset: RULESET[w[base + 0]] ?? null,
+    "physics-mode": w[base + 1] !== 0,
+    "zero-g": w[base + 2] !== 0,
+    "control-model": CONTROL[w[base + 3]] ?? null,
+    inertial: w[base + 4] !== 0,
+    mode3: w[base + 5] !== 0,
+    tick: w[base + 6],
+    time: w[base + 7],
+    remaining: w[base + 8],
+    width: w[base + 9],
+    height: w[base + 10],
+    depth: w[base + 11],
+    "gravity-x": w[base + 12],
+    "gravity-y": w[base + 13],
+    "gravity-z": w[base + 14],
+    "terrain-kind": TERRAIN_KIND[w[base + 15]] ?? null,
+    hills: w[base + 16] !== 0,
+    health: w[base + 17],
+    x: w[base + 18],
+    y: w[base + 19],
+    z: w[base + 20],
+    vx: w[base + 21],
+    vy: w[base + 22],
+    vz: w[base + 23],
+    heading: w[base + 24],
+    pitch: w[base + 25],
+    "yaw-rate": w[base + 26],
+    "pitch-rate": w[base + 27],
+    "roll-rate": w[base + 28],
+    "forward-x": w[base + 29],
+    "forward-y": w[base + 30],
+    "forward-z": w[base + 31],
+    "right-x": w[base + 32],
+    "right-y": w[base + 33],
+    "right-z": w[base + 34],
+    "up-x": w[base + 35],
+    "up-y": w[base + 36],
+    "up-z": w[base + 37],
+    grounded: w[base + 38] !== 0,
+    altitude: w[base + 39],
+    battery: w[base + 40],
+    "battery-capacity": w[base + 41],
+    aim: w[base + 42],
+    "aim-pitch": w[base + 43],
+    cooldown: w[base + 44],
+    "scan-heading": w[base + 45],
+    "scan-pitch": w[base + 46],
+    "scan-arc": w[base + 47],
+    "scan-range": w[base + 48],
+    contact: w[base + 49] !== 0,
+    range: w[base + 50],
+    bearing: w[base + 51],
+    elevation: w[base + 52],
+    "cue-present": w[base + 53] !== 0,
+    "cue-error": w[base + 54],
+    "bearing-rate": w[base + 55],
+    "zone-active": w[base + 56] !== 0,
+    "zone-radius": w[base + 57],
+    "storm-active": w[base + 58] !== 0,
+    "storm-radius": w[base + 59],
+    "hill-active": w[base + 60] !== 0,
+    "hill-radius": w[base + 61],
+    score: w[base + 62],
+    "score-best": w[base + 63],
+    speed: w[base + 64],
+    gravity: w[base + 65] !== 0,
+    "terrain-height": w[base + 66],
+    "battery-fraction": w[base + 67],
+    "aim-error": w[base + 68],
+    "power-min": w[base + 69],
+    "power-max": w[base + 70],
+    "shot-speed-base": w[base + 71],
+    "shot-speed-per-power": w[base + 72],
+    "shot-cost-base": w[base + 73],
+    "shot-cost-per-power": w[base + 74],
+    "zone-distance": w[base + 75],
+    "zone-bearing": w[base + 76],
+    "zone-elevation": w[base + 77],
+    "storm-distance": w[base + 78],
+    "storm-bearing": w[base + 79],
+    "storm-heading": w[base + 80],
+    "cue-muzzle": w[base + 81] !== 0,
+    "cue-bearing": w[base + 82],
+    "cue-elevation": w[base + 83],
+    "cue-range": w[base + 84],
+    "cue-age": w[base + 85],
+    "pickup-present": w[base + 86] !== 0,
+    "pickup-bearing": w[base + 87],
+    "pickup-elevation": w[base + 88],
+    "pickup-range": w[base + 89],
+    "on-hill": w[base + 90] !== 0,
+    "hill-held": w[base + 91] !== 0,
+    "hill-bearing": w[base + 92],
+    "hill-elevation": w[base + 93],
+    "hill-range": w[base + 94],
+    "hill-time": w[base + 95],
+    "hill-to-win": w[base + 96],
+  };
+  words["energy"] = words["battery"];
+  words["max-energy"] = words["battery-capacity"];
+  words["energy-fraction"] = words["battery-fraction"];
+  words["fire-base"] = words["shot-cost-base"];
+  words["fire-per-power"] = words["shot-cost-per-power"];
+  return words;
+}
+
+module.exports = { API_VERSION, RECORD, SIZE, CUE_TICKS, FAR, WORDS, ALIASES, CONTROLS, read, RULESET, CONTROL, TERRAIN_KIND };