@kingdomsconnected/types 1.6.5 → 1.6.7

package/generated/client-api.d.ts

@@ -794,6 +794,11 @@ declare global {
      */
     readonly disguise: string | null;
 
+    /**
+     * Whether this player's body is drawn at all -- itself, what it wears and what it carries. True for everybody until something hides them. Published by their own client, so it follows `setVisible` once they have actually stopped drawing. A hidden player is only invisible: they still stand where they stand, still collide, can still be hit, and NPCs still see them.
+     */
+    readonly visible: boolean;
+
     /**
      * Whether this player's body has both a pose and a soul, which is what everyone else waits for before spawning a puppet for them. False for the first moments of a connection.
      */
@@ -3615,6 +3620,19 @@ declare global {
      * @returns Control names, in a fixed order.
      */
     keys(): string[];
+
+    /**
+     * Whether the HUD is drawing a hint on that control right now, the game's own hints and interaction prompts included, whoever put it up. Lets a script keep its own UI off a key a hint is waiting on.
+     * @param key A control, such as `use` or `jump`; any of the game's, not only `keys()`.
+     * @returns True while a drawn hint is on the control, as of the game's last hint refresh, at most a frame old.
+     */
+    isKeyInUse(key: string): boolean;
+
+    /**
+     * Every control a drawn hint is on right now, interaction prompts included, whoever put it up.
+     * @returns Control names, each once; empty while no hints are drawn.
+     */
+    shownKeys(): string[];
   };
 
   /**

package/generated/server-api.d.ts

@@ -261,6 +261,26 @@ declare global {
      */
     playerPickpocketCaught: [thief: Player, victim: Player];
 
+    /**
+     * A new turn begins, including turns after automatic busts.
+     */
+    diceTurnStart: [event: DiceProgressEvent];
+
+    /**
+     * The server dealt a roll. Includes all six face values and the mask rolled this time.
+     */
+    diceRoll: [event: DiceProgressEvent];
+
+    /**
+     * The server accepted Continue or Pass. Invalid or repeated requests emit nothing.
+     */
+    diceMove: [event: DiceProgressEvent];
+
+    /**
+     * A turn ended by banking, busting, winning, or a match ending. A round means one player's turn.
+     */
+    diceTurnEnd: [event: DiceProgressEvent];
+
     /**
      * Dispatched once a match has started and both players have been sent to the table. Which of them throws first is drawn at random.
      */
@@ -2916,6 +2936,86 @@ declare global {
      * The score that wins, banked at the end of a turn. 2000 when omitted, at most 100000.
      */
     targetScore?: number | undefined;
+
+    /**
+     * First seat's scoreboard label, up to 64 UTF-8 bytes without control characters. Empty or omitted uses the native label.
+     */
+    firstName?: string | undefined;
+
+    /**
+     * Second seat's scoreboard label. Each client maps the seat to its local or opponent column.
+     */
+    secondName?: string | undefined;
+  }
+
+  /**
+   * An accepted server dice action. Notifications describe server decisions, which can precede the native animation. Seats and die-mask bits start at zero; turns and rolls start at one.
+   */
+  interface DiceProgressEvent {
+    /**
+     * Match ID.
+     */
+    match: number;
+
+    /**
+     * Network ID of the acting player.
+     */
+    player: number;
+
+    /**
+     * Acting seat: 0 for first, 1 for second.
+     */
+    seat: number;
+
+    /**
+     * Turn number across both seats, starting at 1.
+     */
+    turn: number;
+
+    /**
+     * Roll within the turn; 0 before its first roll.
+     */
+    roll: number;
+
+    /**
+     * Number of accepted moves so far.
+     */
+    moveIndex: number;
+
+    /**
+     * Unbanked points in this turn, before they are lost on a bust or banked on a pass.
+     */
+    turnScore: number;
+
+    /**
+     * This seat's banked score.
+     */
+    totalScore: number;
+
+    /**
+     * Six pip values (1 through 6) in die-index order on diceRoll; empty on other events. rolledMask identifies the dice rolled this time.
+     */
+    faces: number[];
+
+    /**
+     * Bit mask of dice rolled, on diceRoll; zero otherwise.
+     */
+    rolledMask: number;
+
+    /**
+     * Bit mask of dice selected in the accepted move; zero otherwise.
+     */
+    heldMask: number;
+
+    /**
+     * Points added by diceMove or banked by a passed diceTurnEnd; zero otherwise.
+     */
+    points: number;
+
+    /**
+     * continue or pass on diceMove; bust or rolled on diceRoll; pass, bust, won, gaveUp, left, timedOut, failed, or stopped on diceTurnEnd; empty on diceTurnStart.
+     */
+    reason: string;
   }
 
   /**
@@ -2939,6 +3039,15 @@ declare global {
      */
     start(first: number, second: number, options?: DiceMatchOptions): number;
 
+    /**
+     * Changes both scoreboard labels on the next native scoreboard refresh. Empty restores a native label. Names allow at most 64 UTF-8 bytes and no control characters.
+     * @param match Match ID.
+     * @param first First seat label.
+     * @param second Second seat label.
+     * @returns False if the match has ended.
+     */
+    setNames(match: number, first: string, second: string): boolean;
+
     /**
      * Ends a match with nobody winning; both tables close.
      * @param match The match to end.
@@ -6172,6 +6281,11 @@ declare global {
      */
     virtualWorld?: number | undefined;
 
+    /**
+     * Invisible boundary collision from both sides; false when omitted. Polygons need a simple outline and positive height. Walls are 0.2 m thick; spheres use a tessellated boundary.
+     */
+    collision?: boolean | undefined;
+
     /**
      * Whether it starts enabled; true when omitted.
      */
@@ -6246,6 +6360,11 @@ declare global {
      */
     metadata: Record<string, unknown>;
 
+    /**
+     * Invisible boundary walls block both directions while enabled, leaving the interior empty. Authored areas only; invalid collision shapes throw.
+     */
+    collision: boolean;
+
     /**
      * Whether crossings are raised and the lookups find it. Switching it off raises `areaExit` for everyone inside on the next tick; switching it on, `areaEnter`. Works on level areas too.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kingdomsconnected/types",
-  "version": "1.6.5",
+  "version": "1.6.7",
   "description": "TypeScript declarations for the Kingdoms Connected scripting API, one entry per side: @kingdomsconnected/types/server and @kingdomsconnected/types/client",
   "license": "UNLICENSED",
   "keywords": [