@modlock/modlock 0.0.0-stage → 0.1.64

package/hud.d.ts

@@ -0,0 +1,168 @@
+import { type PipShape, type TextRole, type Tone } from './theme.js';
+import type { Player } from './host.gen.js';
+import type { Child, Style, UiElement } from './ui.js';
+/** TextProps set one label in a type role and tone. */
+export interface TextProps {
+    role: TextRole;
+    /** tone colors the text; a label is muted and the rest are text. */
+    tone?: Tone;
+    /**
+     * plated marks text on a plate or pill, which takes no shadow: on the dark
+     * plate a shadow only smears the glyphs.
+     */
+    plated?: boolean;
+    style?: Style;
+    children?: Child;
+}
+/** Text is one label in a type role, over the soft shadow unless plated. */
+export declare function Text(props: TextProps): UiElement;
+/** BoxProps lay out a plate's or pill's children. */
+export interface BoxProps {
+    flow?: 'down' | 'right';
+    style?: Style;
+    children?: Child;
+}
+/** Plate is the dark plate under HUD text, readable over a bright sky. */
+export declare function Plate(props: BoxProps): UiElement;
+/**
+ * Pill is the plate rounded into a capsule with a faint
+ * parchment edge, flowing right: the counter under a top strip's heading.
+ */
+export declare function Pill(props: BoxProps): UiElement;
+/** PipsProps show a count out of a fixed total. */
+export interface PipsProps {
+    filled: number;
+    total: number;
+    tone: Tone;
+    /** shape is a round point, as the stock round counter, or a narrow tick. */
+    shape?: PipShape;
+    /** mirror fills from the right, for the far side of a counter. */
+    mirror?: boolean;
+    style?: Style;
+}
+/** Pips shows a count as filled and empty pips, as the stock round counter. */
+export declare function Pips(props: PipsProps): UiElement;
+/** TagProps name a status or a result in small capitals. */
+export interface TagProps {
+    tone: Tone;
+    /** fill outlines a status read in a list, or fills a result. */
+    fill?: 'outline' | 'filled';
+    style?: Style;
+    children?: Child;
+}
+/** Tag is small heading capitals in a 1px border of its tone. */
+export declare function Tag(props: TagProps): UiElement;
+/** BannerProps announce a moment: a title and a detail under it. */
+export interface BannerProps {
+    title: string;
+    detail?: string;
+    tone?: Tone;
+    style?: Style;
+}
+/**
+ * Banner is a centered title in the heading face with a muted detail. It
+ * grows in as it appears and fades as it goes.
+ */
+export declare function Banner(props: BannerProps): UiElement;
+/** TopStripProps fill the top block of an arena HUD. */
+export interface TopStripProps {
+    /** heading names the mode or round and the lane, over the counter. */
+    heading?: string;
+    /** line is a short line under the counter, such as a clock or the news. */
+    line?: string;
+    lineTone?: Tone;
+    /**
+     * keepTeamBar seats the strip under the stock team bar, which keeps its
+     * clock, heroes and player slots; unset, it takes the bar's place.
+     */
+    keepTeamBar?: boolean;
+    /** children are the counter's content, such as Score and Pips. */
+    children?: Child;
+}
+/**
+ * TopStrip is the top block of an arena HUD: a heading in spaced capitals, the
+ * counter pill, and a line under it. Under the kept team bar, the heading and
+ * pill fit above the stock objective bar and the line goes below that bar.
+ */
+export declare function TopStrip(props: TopStripProps): UiElement;
+/** ScoreProps are each side's points, the near side first. */
+export interface ScoreProps {
+    points: readonly [number, number];
+    /** tones color each side; unset, the near side is the accent. */
+    tones?: readonly [Tone, Tone];
+}
+/**
+ * Score is a counter's points, each side in its tone, in the title face. It
+ * sits in a pill, so its text is plated.
+ */
+export declare function Score(props: ScoreProps): UiElement;
+/** RosterRow is one player as the roster shows them. */
+export interface RosterRow {
+    name: string;
+    /** self marks the viewing player's own row. */
+    self?: boolean;
+    /** hero is the player's hero as Pawn.hero gives it, or 0 without one. */
+    hero: number;
+    /** activity is the line under the name, such as "Free roam". */
+    activity: string;
+    /** steamId badges the portrait's corner with the player's Steam avatar. */
+    steamId?: bigint;
+    /**
+     * onPress makes the row a button the viewer presses while they have a
+     * cursor, such as to open a card about that player.
+     */
+    onPress?: (player: Player) => void;
+    /** selected edges the portrait in the accent, as for the row a card shows. */
+    selected?: boolean;
+}
+/** rosterRows is the most players the roster shows, above the minimap. */
+export declare const rosterRows = 6;
+/** rosterKey is what the roster shows, to redraw only when it changes. */
+export declare function rosterKey(rows: readonly RosterRow[]): string;
+/** RosterProps list the players and where the roster starts. */
+export interface RosterProps {
+    rows: readonly RosterRow[];
+    /** top is the roster's top margin, under the FPS readout unless set. */
+    top?: number;
+}
+/**
+ * Roster stacks up to rosterRows players down the top right corner, each
+ * one's hero portrait at the edge with their name and a line, such as what
+ * they are doing or their score, to its left. It shows nothing without rows.
+ * A mode that hides the stock scoreboard's heroes shows who else is here with
+ * it.
+ */
+export declare function Roster(props: RosterProps): UiElement | null;
+/** ActionProps make a button in the game's menu look. */
+export interface ActionProps {
+    /**
+     * kind is 'primary' for the one action a screen leads with, 'secondary' for
+     * the rest, and 'quiet' for an action that should not draw the eye.
+     */
+    kind?: 'primary' | 'secondary' | 'quiet';
+    /** disabled dims the action and takes no presses. */
+    disabled?: boolean;
+    onPress?: (player: Player) => void;
+    style?: Style;
+    children?: Child;
+}
+/**
+ * Action is a button in the game's menu look: capitals on a fill that lights
+ * as the pointer enters, with the main menu's hover and press sounds.
+ */
+export declare function Action(props: ActionProps): UiElement;
+/** MeterProps show how full something is. */
+export interface MeterProps {
+    /** value is how full the meter is, from 0 to 1. */
+    value: number;
+    tone?: Tone;
+    /** width and height size the meter, in pixels; 160 by 8 unless set. */
+    width?: number;
+    height?: number;
+    style?: Style;
+}
+/**
+ * Meter is a bar that fills from the left toward its value, easing to each new
+ * value: a charge, a capture or a timer.
+ */
+export declare function Meter(props: MeterProps): UiElement;

package/index.d.ts

@@ -0,0 +1,121 @@
+/// <reference path="./globals.d.ts" />
+import { type DamageEvent, type ChatEvent, type DamagedEvent, type DamageResult, type FrameEvent, type ImpactEvent, type LandedEvent, type LaunchEvent, Player } from './host.gen.js';
+export * as vector from './vector.js';
+export { Buttons, Layers } from './bits.js';
+export { after, every, sequence, type Timer } from './timer.js';
+export { type CameraMove, type CameraPlayOptions, cameraPulse, type CameraPulseOptions, cameraShake, type CameraShakeOptions, playCamera, setOrbitCamera, } from './camera.js';
+export * as curve from './curve.js';
+export * as format from './format.js';
+export { findHero, findTitled, type Hero, heroes, type Titled, } from './heroes.js';
+export { Hook, type HookAbility, hookAbility, type HookPlayer, type HookRead, hookUpgrades, type ReadHandle, } from './hook.js';
+export { Banner, type BannerProps, type BoxProps, Pill, Pips, type PipsProps, Plate, Roster, type RosterProps, type RosterRow, rosterKey, rosterRows, Score, type ScoreProps, Tag, type TagProps, Text, type TextProps, TopStrip, type TopStripProps, Action, type ActionProps, Meter, type MeterProps, } from './hud.js';
+export * as theme from './theme.js';
+export type { Face, PipShape, TextRole, Tone } from './theme.js';
+export * from './host.gen.js';
+export { Cast, type CastOptions, type Want } from './cast.js';
+export { frameClock } from './frameclock.js';
+export { ground, type GroundOptions } from './ground.js';
+export { players } from './players.js';
+export { type Check, ProbeRun } from './probe.js';
+export { poseAt, type Pose, Puppet, type PuppetOptions, type PuppetState, ghostStates, ticksPerSecond, type Track, trackTicks, } from './puppet.js';
+export { type HeroSnapshot, restoreHero } from './restore.js';
+export { type ReplayedHit, replayDamage } from './replayed-damage.js';
+export { type CatalogEntry, Dropper, dropperButtons } from './dropper.js';
+export { decodeSpot, encodeSpot, LoadedSpot, loadSpot, type Placed, type Spot, type SpotObject, triggers, } from './spot.js';
+export { type ButtonProps, type Child, type Component, type Edges, type ElementProps, Fragment, type Gradient, type HeroLookName, type HeroProps, hide, hideHud, type HudPart, type ImageProps, type JSX, jsx, jsxs, type LabelProps, type LayoutProps, type Length, type Overflow, type PanelProps, route, type Scaling, type Shadow, sheet, show, type Style, toast, type Transition, type UiElement, } from './ui.js';
+/** LogPart is a value log writes as text. */
+export type LogPart = string | number | bigint | boolean | null | undefined;
+/**
+ * log writes one line to the server log under the mod's name: its parts as
+ * text, separated by spaces.
+ */
+export declare function log(...parts: LogPart[]): void;
+/**
+ * Service answers the host's calls to one service the mod serves: the
+ * method's name and payload in, the answer out. A thrown error becomes the
+ * call's error.
+ */
+export type Service = (method: string, payload: Uint8Array) => Uint8Array;
+/** serve answers the host's calls to service with handler, replacing its earlier handler. */
+export declare function serve(service: string, handler: Service): void;
+/**
+ * command calls handler when a player types /name in chat or their client
+ * sends the console command name to the server. The handler runs with the
+ * next server frame, before the frame handlers, and receives the text after
+ * the name, trimmed of surrounding spaces. Registering a name again replaces
+ * its handler.
+ */
+export declare function command(name: string, handler: (player: Player, args: string) => void): void;
+/**
+ * onStart calls handler once when the server starts the mod, with the
+ * arguments that follow -- on the modlock-host command line. The mod starts
+ * before any world loads, so find the map's entities in onWorld.
+ */
+export declare function onStart(handler: (args: readonly string[]) => void): void;
+/**
+ * onChat calls handler with each chat line a player writes, commands
+ * included, on the next server frame.
+ */
+export declare function onChat(handler: (line: ChatEvent) => void): void;
+/** onFrame calls handler once per server frame. */
+export declare function onFrame(handler: (frame: FrameEvent) => void): void;
+/**
+ * onWorld calls handler with the map's name each time a world loads, and at
+ * start when one already has. Objects and bots from an earlier world are
+ * gone by then.
+ */
+export declare function onWorld(handler: (map: string) => void): void;
+/**
+ * onInput calls handler with the watched buttons a player pressed and
+ * released, as Buttons bits, before the next frame. A button is held from its
+ * press until its release.
+ */
+export declare function onInput(handler: (player: Player, pressed: bigint, released: bigint) => void): void;
+/**
+ * onRestored calls handler when a player's Player.restoreHero ends: error is
+ * undefined once the target held for a second, or says why it did not.
+ */
+export declare function onRestored(handler: (player: Player, error: string | undefined) => void): void;
+/**
+ * onNpcsRestored calls handler when restoreNpcs ends: error is undefined once
+ * the map holds every target, or says why it does not.
+ */
+export declare function onNpcsRestored(handler: (error: string | undefined) => void): void;
+/**
+ * onDamage calls handler before each hit lands, so it can block the hit or
+ * change its damage. Later handlers see the earlier ones' amount.
+ */
+export declare function onDamage(handler: (hit: DamageEvent) => DamageResult | void): void;
+/** onDamaged calls handler on the frame after each hit lands. */
+export declare function onDamaged(handler: (hit: DamagedEvent) => void): void;
+/**
+ * onLaunch calls handler with each watched projectile's first frame, before
+ * the next frame. watchProjectiles names the projectiles.
+ */
+export declare function onLaunch(handler: (projectile: LaunchEvent) => void): void;
+/**
+ * onImpact calls handler when a watched projectile strikes something, inside
+ * the game's impact: its calls apply before the game continues.
+ */
+export declare function onImpact(handler: (impact: ImpactEvent) => void): void;
+/**
+ * onLanded calls handler when a hero lands under the manifest's QuakeWorld
+ * movement, before the next frame.
+ */
+export declare function onLanded(handler: (landing: LandedEvent) => void): void;
+/**
+ * onSettingChanged calls handler when a player's setting changes outside the
+ * mod, such as on the player's profile. The mod's own player.setSetting calls
+ * do not reach it.
+ */
+export declare function onSettingChanged(handler: (player: Player, key: string, value: string) => void): void;
+/**
+ * settingOn returns the player's value of a switch setting the manifest
+ * declares, or undefined when the host refuses the read.
+ */
+export declare function settingOn(player: Player, key: string): boolean | undefined;
+/**
+ * settingNumber returns the player's value of a number setting the manifest
+ * declares, or undefined when the host refuses the read.
+ */
+export declare function settingNumber(player: Player, key: string): number | undefined;