@modlock/modlock 0.0.0-stage → 0.1.64

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Christian Stewart <christian@cjs.zip>
+Copyright (c) 2026 Daniel Kapadia <business@ddkesports.com>
+Copyright (c) 2026 Deadworks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,11 @@
-# Temporary Holding Version
+# modlock
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Build, test and publish mods for Deadlock. This package installs the
+`modlock` command line and the TypeScript library mods import:
+
+```sh
+npm install --save-dev @modlock/modlock
+npx modlock new my-mod
+```
+
+See https://github.com/paralin/modlock for the guide.

package/bin/modlock.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+// Runs the modlock command line that npm installed for this system, from the
+// optional dependency @modlock/<platform>-<arch>, with this process's
+// arguments, input and output, and exits as it exits.
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+const name = `@modlock/${process.platform}-${process.arch}`
+const file = process.platform === 'win32' ? 'modlock.exe' : 'modlock'
+
+let binary
+try {
+  binary = require.resolve(`${name}/bin/${file}`)
+} catch {
+  console.error(
+    `modlock has no build for ${process.platform} ${process.arch} installed; ` +
+      `install @modlock/modlock again without --omit=optional or --no-optional, ` +
+      `or download it from https://github.com/paralin/modlock/releases`,
+  )
+  process.exit(1)
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: 'inherit' })
+if (result.error) {
+  console.error(`modlock could not start ${binary}: ${result.error.message}`)
+  process.exit(1)
+}
+if (result.signal) {
+  process.kill(process.pid, result.signal)
+}
+process.exit(result.status ?? 1)

package/bits.d.ts

@@ -0,0 +1,52 @@
+/** Buttons names input bits for blockInput, watchInput and Player.press. */
+export declare const Buttons: {
+    /** attack is the primary fire button. */
+    readonly attack: 1n;
+    /**
+     * jump is the jump key, Space by default (IN_MANTLE). Blocking it stops the
+     * native jump and mantle; the jumping client still predicts the jump and is
+     * corrected.
+     */
+    readonly jump: bigint;
+    /** crouch is the crouch key, Ctrl by default. */
+    readonly crouch: bigint;
+    /** dash is the dash key, Shift by default. */
+    readonly dash: bigint;
+    /** use is the interact key. */
+    readonly use: bigint;
+    /** altFire is the zoom and alternate fire button, right mouse by default. */
+    readonly altFire: bigint;
+    /** reload is the reload key. */
+    readonly reload: bigint;
+    /** melee is the light melee key, Q by default. */
+    readonly melee: bigint;
+    /** ability1 to ability3 are the hero's first three ability keys. */
+    readonly ability1: bigint;
+    readonly ability2: bigint;
+    readonly ability3: bigint;
+    /** ultimate is the hero's ultimate ability key, the fourth. */
+    readonly ultimate: bigint;
+    /** parry is the melee parry button. */
+    readonly parry: bigint;
+};
+/** Layers names collision layers for trace, as bits. */
+export declare const Layers: {
+    /** solid is the world and solid objects. */
+    readonly solid: bigint;
+    /** hitbox is the hit boxes of heroes and units. */
+    readonly hitbox: bigint;
+    /** trigger is invisible volumes that react to touch. */
+    readonly trigger: bigint;
+    /** playerClip is walls that only stop heroes. */
+    readonly playerClip: bigint;
+    /** player is player-controlled heroes. */
+    readonly player: bigint;
+    /** npc is units that are not players. */
+    readonly npc: bigint;
+    /** staticLevel is the map's built geometry, foliage included. */
+    readonly staticLevel: bigint;
+    /** hero, trooper and building are those units' bodies. */
+    readonly hero: bigint;
+    readonly trooper: bigint;
+    readonly building: bigint;
+};

package/camera.d.ts

@@ -0,0 +1,101 @@
+import { type CameraCurve, type Ease } from './curve.js';
+import { type CameraParam, type CameraValue, type Player } from './host.gen.js';
+/**
+ * setOrbitCamera gives the player's hero the hideout's orbit camera, zoomed
+ * with the wheel, or returns the normal camera and drops the wheel's zoom.
+ * The hideout HUD replaces the game HUD while it is on. It returns false when
+ * the player has no hero or a call fails.
+ */
+export declare function setOrbitCamera(player: Player, enabled: boolean): boolean;
+/** CameraPlayOptions plays curves on a player's camera. */
+export interface CameraPlayOptions {
+    /**
+     * tracks holds a curve for each param that moves. All tracks start
+     * together, so a pull back and a wider view can share one timeline.
+     */
+    tracks: Partial<Record<CameraParam, CameraCurve>>;
+    /** relative adds the curves' values to each param's usual value. */
+    relative?: boolean;
+    /** delay starts the tracks after this many seconds. */
+    delay?: number;
+    /** loop plays the tracks again each time they end, until cancelled. */
+    loop?: boolean;
+    /**
+     * rate is how many lerps each second play a span the game's lerp cannot
+     * draw; omitted, 30. A straight or bias and gain span is always one lerp.
+     */
+    rate?: number;
+    /** context names the operations; omitted, a name of its own. */
+    context?: string;
+    /** priority decides between these tracks and another context's moves. */
+    priority?: number;
+    /** target is the entity handle of the hero whose camera moves. */
+    target?: number;
+}
+/** CameraMove is a set of curves playing on a player's camera. */
+export interface CameraMove {
+    /** context names the operations. */
+    readonly context: string;
+    /** duration is how long the move runs, in seconds; Infinity when it loops. */
+    readonly duration: number;
+    /** cancel ends the move at once and returns each param to its usual value. */
+    cancel(): boolean;
+}
+/**
+ * playCamera plays a curve for each param of the player's camera, sent at
+ * once as lerps queued in one context. Each param returns to its usual value
+ * after its curve ends, so a curve ends where the camera rests: at zero when
+ * relative. Moves in their own contexts take turns by priority. It returns
+ * undefined when the player has no hero or a call fails.
+ */
+export declare function playCamera(player: Player, options: CameraPlayOptions): CameraMove | undefined;
+/** CameraPulseOptions moves a param away, holds it and brings it back. */
+export interface CameraPulseOptions {
+    /** param is the camera value the pulse moves. */
+    param: CameraParam;
+    /** by is how far the param moves from its usual value. */
+    by: CameraValue;
+    /** in is how long the move out takes, in seconds. */
+    in: number;
+    /** hold is how long the param stays out, in seconds. */
+    hold: number;
+    /** out is how long the move back takes, in seconds. */
+    out: number;
+    /** ease shapes the move out; the move back is its mirror. Omitted, linear. */
+    ease?: Ease;
+    /** context names the pulse's operations; omitted, a name of its own. */
+    context?: string;
+    /** priority decides between this pulse and another context's moves. */
+    priority?: number;
+    /** target is the entity handle of the hero whose camera moves. */
+    target?: number;
+}
+/**
+ * cameraPulse moves one param of the player's camera by an amount, holds it
+ * there and brings it back, as an ability pulls the camera back while it
+ * charges. It returns undefined when the player has no hero or a call fails.
+ */
+export declare function cameraPulse(player: Player, options: CameraPulseOptions): CameraMove | undefined;
+/** CameraShakeOptions shakes a param around its usual value. */
+export interface CameraShakeOptions {
+    /** param is the camera value that shakes; omitted, horizontalOffset. */
+    param?: CameraParam;
+    /** amplitude is how far the first swing reaches. */
+    amplitude: number;
+    /** duration is how long the shake runs, in seconds. */
+    duration: number;
+    /** frequency is how many full swings it makes each second; omitted, 8. */
+    frequency?: number;
+    /** context names the shake's operations; omitted, a name of its own. */
+    context?: string;
+    /** priority decides between this shake and another context's moves. */
+    priority?: number;
+    /** target is the entity handle of the hero whose camera moves. */
+    target?: number;
+}
+/**
+ * cameraShake swings one param of the player's camera to either side of its
+ * usual value, smaller each time, and settles back. It returns undefined
+ * when the player has no hero or a call fails.
+ */
+export declare function cameraShake(player: Player, options: CameraShakeOptions): CameraMove | undefined;

package/cast.d.ts

@@ -0,0 +1,73 @@
+import { type Connection, type Pawn, type Player } from './host.gen.js';
+/** Want is what a member's hero should be; each field it leaves out is free. */
+export interface Want {
+    /**
+     * hero seats the member on a hero: its name, such as 'hero_atlas', its id,
+     * or 'any' for the hero they have or else a random one.
+     */
+    readonly hero?: string | number;
+    /**
+     * team is the team, 2 or 3, to seat the member on. Without one a member
+     * keeps their hero's team, or else joins the side with fewer members.
+     */
+    readonly team?: number;
+    /** respawn is the seconds a fallen hero waits before Cast asks for it back. */
+    readonly respawn?: number;
+}
+/** CastOptions are a mode's answers to its players coming and going. */
+export interface CastOptions<M> {
+    /** join makes the member for a human who finished joining. */
+    join(connection: Connection): M;
+    /** leave ends a member whose connection left the slot. */
+    leave?(member: M, connection: Connection): void;
+    /**
+     * want is what every member wants, or a function that returns what one
+     * member wants now. Cast calls it once per member each frame, so it should
+     * return a want it keeps rather than make a new one.
+     */
+    want?: Want | ((member: M) => Want);
+    /**
+     * bots says what to do with a bot: skip leaves it out of the cast, join
+     * makes it a member as a human is, and kick asks the server to remove it,
+     * once per connection. Skip is the default.
+     */
+    bots?: 'skip' | 'join' | 'kick';
+}
+/** Cast keeps one member of type M per human player. */
+export declare class Cast<M> {
+    private readonly options;
+    private readonly seats;
+    /** kicked holds the connection generation each kicked bot's slot had. */
+    private readonly kicked;
+    /** reported is the player list the host reported since the last frame. */
+    private reported;
+    constructor(options: CastOptions<M>);
+    /** size is the number of members. */
+    get size(): number;
+    /** members lists the members in the order they joined. */
+    members(): M[];
+    /** get returns the member in player's slot, if any. */
+    get(player: Player): M | undefined;
+    /** pawn returns the member's hero as Cast read it this frame. */
+    pawn(player: Player): Pawn | undefined;
+    /**
+     * frame settles the joins and leaves reported since the last frame, reads
+     * each member's hero, and asks the game once a second for any want it does
+     * not show yet. seconds is the game clock.
+     */
+    frame(seconds: number): void;
+    /** settle ends the members whose connection left and makes the new ones. */
+    private settle;
+    /** kick asks the server to remove a bot, once per connection. */
+    private kick;
+    /** reconcile reads a member's hero and asks for the part of the want it lacks. */
+    private reconcile;
+    /** wantOf is what the member in seat wants now. */
+    private wantOf;
+    /** seated reports whether the member's hero shows the hero and team they want. */
+    private seated;
+    /** seat asks the game to put the member on hero and their team. */
+    private seat;
+    /** side is the team a member joins: their hero's, or the one with fewer heroes. */
+    private side;
+}