@modlock/modlock 0.0.0-stage → 0.1.64

package/console.js

@@ -0,0 +1,40 @@
+/*! Includes protobuf-es-lite under the Apache License 2.0: https://www.apache.org/licenses/LICENSE-2.0 */
+
+// js/src/console.ts
+import { serverCommand } from "modlock";
+function set(name, value) {
+  return serverCommand(`${name} ${format(value)}`);
+}
+function format(value) {
+  if (typeof value === "boolean") {
+    return value ? "1" : "0";
+  }
+  return typeof value === "string" ? `"${value}"` : String(value);
+}
+function run(name, ...args) {
+  return serverCommand([name, ...args].join(" "));
+}
+function apply(settings) {
+  const refused = [];
+  for (const [name, value] of Object.entries(settings)) {
+    if (value !== void 0 && !serverCommand(name + " " + format(value))) {
+      refused.push(name);
+    }
+  }
+  return refused;
+}
+var arena = {
+  sv_hibernate_when_empty: false,
+  citadel_solo_bot_match: false,
+  citadel_koth_enabled: false,
+  citadel_trooper_spawn_enabled: false,
+  citadel_neutral_spawn_enabled: false,
+  citadel_spawn_practice_bots: false,
+  citadel_start_players_on_zipline: false
+};
+export {
+  apply,
+  arena,
+  run,
+  set
+};

package/curve.d.ts

@@ -0,0 +1,149 @@
+import type { CameraValue, Vector } from './host.gen.js';
+/**
+ * LerpShape is the shape the game's own lerp gives a move: Valve's bias and
+ * gain curves, each linear at 0.5. An omitted value is linear.
+ */
+export interface LerpShape {
+    /** bias below 0.5 starts slow and speeds up; above, starts fast. */
+    readonly bias?: number;
+    /** gain above 0.5 starts and ends slow; below, fast at both ends. */
+    readonly gain?: number;
+}
+/**
+ * Ease maps the fraction of a span played, 0 to 1, to the fraction moved. An
+ * ease with a lerp shape is one the game draws itself, so a move with it
+ * plays as one lerp.
+ */
+export interface Ease {
+    (t: number): number;
+    readonly lerp?: LerpShape;
+}
+/** ease holds the common easing curves. */
+export declare const ease: {
+    /** linear moves at an even pace. */
+    readonly linear: Ease;
+    /** bias is the game's bias curve; see LerpShape. */
+    readonly bias: (b: number) => Ease;
+    /** gain is the game's gain curve; see LerpShape. */
+    readonly gain: (g: number) => Ease;
+    /** in starts slow and speeds up. */
+    readonly in: (t: number) => number;
+    /** out starts fast and slows to a stop. */
+    readonly out: (t: number) => number;
+    /** inOut starts and ends slow. */
+    readonly inOut: (t: number) => number;
+    /** sine starts and ends slow, more gently than inOut. */
+    readonly sine: (t: number) => number;
+    /** back passes its end a little and settles back onto it. */
+    readonly back: (t: number) => number;
+    /** elastic overshoots its end and rings down onto it. */
+    readonly elastic: (t: number) => number;
+    /** bounce drops onto its end and bounces to rest. */
+    readonly bounce: (t: number) => number;
+};
+/** CameraSpan is one piece of a curve. */
+export interface CameraSpan {
+    /** duration is how long the span plays, in seconds. */
+    readonly duration: number;
+    /** at returns the value a fraction u of the way through, 0 to 1. */
+    readonly at: (u: number) => CameraValue;
+    /**
+     * lerp marks a span the game plays as one lerp from at(0) to at(1) with this
+     * shape; a span without it is sampled.
+     */
+    readonly lerp?: LerpShape;
+}
+/** CameraCurve is a list of spans played in order. */
+export type CameraCurve = readonly CameraSpan[];
+/** CameraKey is one point of a keyframed curve. */
+export interface CameraKey {
+    /** at is the time of the key, in seconds after the curve starts. */
+    at: number;
+    /** value is the param's value at the key. */
+    value: CameraValue;
+    /** ease shapes the move from the key before this one; omitted, linear. */
+    ease?: Ease;
+}
+/** KeyframeOptions shapes the curve between keys. */
+export interface KeyframeOptions {
+    /**
+     * smooth passes through the keys on a curve, without corners, instead of a
+     * straight line from each to the next.
+     */
+    smooth?: boolean;
+}
+/** line moves from one value to another over a duration. */
+export declare function line(from: CameraValue, to: CameraValue, duration: number, shape?: Ease): CameraCurve;
+/** hold keeps a value for a duration. */
+export declare function hold(value: CameraValue, duration: number): CameraCurve;
+/**
+ * keyframes passes through keys in time order. A key's ease shapes the move
+ * into it; two keys at one time make a jump, and two with one value a hold.
+ * The curve starts at the first key, so a first key after zero waits there.
+ */
+export declare function keyframes(keys: readonly CameraKey[], options?: KeyframeOptions): CameraCurve;
+/** ThroughOptions times a curve through points by its speed. */
+export interface ThroughOptions extends KeyframeOptions {
+    /** speed is how far the param moves each second. */
+    speed: number;
+    /** ease shapes each move between two points; omitted, linear. */
+    ease?: Ease;
+}
+/**
+ * through moves through points at a speed, so each move takes as long as its
+ * distance needs.
+ */
+export declare function through(points: readonly CameraValue[], options: ThroughOptions): CameraCurve;
+/** OrbitOptions circles a point. */
+export interface OrbitOptions {
+    /** center is the point the circle goes around. */
+    center: Vector;
+    /** radius is the circle's radius. */
+    radius: number;
+    /** duration is how long the orbit takes, in seconds. */
+    duration: number;
+    /** turns is how many times it goes around; omitted, 1. Negative turns clockwise. */
+    turns?: number;
+    /** start is the angle it starts at, in degrees from the x axis; omitted, 0. */
+    start?: number;
+    /** rise is how far it climbs over the whole orbit; omitted, 0. */
+    rise?: number;
+    /** ease shapes the pace around the circle; omitted, linear. */
+    ease?: Ease;
+}
+/** orbit circles a point, for the target param, as a spiral when it rises. */
+export declare function orbit(options: OrbitOptions): CameraCurve;
+/** WaveOptions swings a number around zero. */
+export interface WaveOptions {
+    /** amplitude is how far the first swing reaches. */
+    amplitude: number;
+    /** frequency is how many full swings it makes each second. */
+    frequency: number;
+    /** duration is how long it swings, in seconds. */
+    duration: number;
+    /**
+     * decay shrinks the swings to nothing by the end when true, as a shake
+     * settles; omitted, they keep their size.
+     */
+    decay?: boolean;
+}
+/** wave swings a number to either side of zero and ends at zero. */
+export declare function wave(options: WaveOptions): CameraCurve;
+/** chain plays curves one after another. */
+export declare function chain(...curves: readonly CameraCurve[]): CameraCurve;
+/**
+ * reverse plays a curve backward. A gain curve is its own mirror and stays one
+ * lerp; a biased span backward is no bias curve, so it is sampled.
+ */
+export declare function reverse(curve: CameraCurve): CameraCurve;
+/** repeat plays a curve a number of times. */
+export declare function repeat(curve: CameraCurve, times: number): CameraCurve;
+/** pingPong plays a curve forward and then backward. */
+export declare function pingPong(curve: CameraCurve): CameraCurve;
+/** durationOf returns how long a curve plays, in seconds. */
+export declare function durationOf(curve: CameraCurve): number;
+/**
+ * valueAt returns a curve's value a number of seconds in, or its last value
+ * once it has ended. An empty curve has no value.
+ */
+export declare function valueAt(curve: CameraCurve, seconds: number): CameraValue | undefined;

package/dropper.d.ts

@@ -0,0 +1,69 @@
+import { type MovementSample, type Player } from './host.gen.js';
+import { type LoadedSpot, type Spot } from './spot.js';
+/** CatalogEntry is one object builders can drop. */
+export interface CatalogEntry {
+    /** name is what builders read in the catalog. */
+    readonly name: string;
+    /** category groups entries in the catalog, such as Crates. */
+    readonly category: string;
+    /** model is the model's path, which the mode precached. */
+    readonly model: string;
+    /** scale multiplies the model's size; the default is 1. */
+    readonly scale?: number;
+    /** bounce makes the object launch heroes upward at this speed. */
+    readonly bounce?: number;
+}
+/**
+ * dropperButtons are the keys a builder uses, which the mode includes in
+ * watchInput: fire drops, melee picks up or puts back, parry deletes, reload
+ * turns, the first two abilities page the catalog and the third undoes.
+ */
+export declare const dropperButtons: bigint;
+/** Dropper is in-game building for one mode's spot. */
+export declare class Dropper {
+    private readonly catalog;
+    spot: LoadedSpot;
+    /** changed is called with the spot after every drop, move and delete. */
+    changed?: (spot: Spot) => void;
+    /** capacity bounds how many objects the spot holds. */
+    capacity: number;
+    private builders;
+    constructor(catalog: readonly CatalogEntry[], spot: LoadedSpot);
+    /** building reports whether player is building. */
+    building(player: Player): boolean;
+    /** toggle starts or stops building for player. */
+    toggle(player: Player): void;
+    /** stop ends building for player, putting back an object they held. */
+    stop(player: Player): void;
+    /** replace swaps the spot builders drop into, as when a saved spot loads. */
+    replace(spot: LoadedSpot): void;
+    /**
+     * frame moves each builder's preview to their aim, drops builders who
+     * left, and launches heroes standing on bouncing objects.
+     */
+    frame(movement: readonly MovementSample[]): void;
+    /** input applies a builder's key presses. */
+    input(player: Player, pressed: bigint): void;
+    /** select shows the catalog entry at index, wrapping at either end. */
+    select(player: Player, index: number): void;
+    /** turn turns player's preview by degrees. */
+    turn(player: Player, degrees: number): void;
+    /** face sets player's preview to face degrees, and shows it on the panel's slider. */
+    face(player: Player, degrees: number): void;
+    /** undo removes player's newest drop that still stands. */
+    undo(player: Player): void;
+    /** object returns what the builder's preview stands for. */
+    private object;
+    /** aim places the builder's preview where they look. */
+    private aim;
+    /** preview draws the builder's preview at their aim, or hides it. */
+    private preview;
+    /** drop places the preview as a solid object. */
+    private drop;
+    /** pickUp lifts the aimed object to move it, or puts a held one back. */
+    private pickUp;
+    /** delete removes the aimed object. */
+    private delete;
+    /** draw shows the builder the catalog and their keys. */
+    private draw;
+}