brick-engine-js 1.0.21 → 1.0.23

package/dist/types/core/module/grid/engines/GridLineEngine.d.ts

@@ -1,56 +1,94 @@
 import { Grid } from '../../../types/modules';
 /**
- * Handles line-based operations (rows and columns) on the grid.
+ * Engineering sub-module handling comprehensive shifting row operations and grid clearance.
+ *
+ * Implements the {@link Grid} structural line shifts. It drives heavy multi-cell displacement,
+ * manipulating memory locations explicitly when the engine demands sweeping block changes
+ * to simulate gravity or clean completely occupied board bounds.
  */
 export default class GridLineEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Checks if every cell in a specific row is active.
+     * Executes horizontal sweeping verifying no static empty elements disrupt a physical row footprint.
+     *
+     * @param {number} y - The integer declaring the horizontal map layer mapped to height.
+     * @returns {boolean} A boolean true if density confirms completely loaded limits.
      */
     isRowFull(y: number): boolean;
     /**
-     * Checks if every cell in a specific row is inactive.
+     * Executes horizontal sweeping verifying no active elements exist across a physical row footprint.
+     *
+     * @param {number} y - The integer declaring the horizontal map layer mapped to height.
+     * @returns {boolean} A boolean true if all limits check out completely zeroed out.
      */
     isRowEmpty(y: number): boolean;
     /**
-     * Resets all cells in a specific row to their default empty state.
+     * Purges specific memory instances mapping empty metadata objects identically across a row length.
+     *
+     * @param {number} y - The integer mapped horizontally mapping height to wipe.
+     * @returns {void} Returns nothing.
      */
     clearRow(y: number): void;
     /**
-     * Shifts all rows above a certain index down by one position.
+     * Transplants memory contents shifting row sequences securely down one numerical grid measure.
+     *
+     * @param {number} fromY - The explicit target line evaluating continuous transfers upwards.
+     * @returns {void} Returns nothing.
      */
     shiftRowsDown(fromY: number): void;
     /**
-     * Shifts all rows below a certain index up by one position.
+     * Transplants memory contents shifting row sequences securely up one numerical grid measure.
+     *
+     * @param {number} fromY - The explicit target line evaluating continuous transfers downwards.
+     * @returns {void} Returns nothing.
      */
     shiftRowsUp(fromY: number): void;
     /**
-     * Scans for full rows, clears them, and shifts remaining rows down.
+     * Orchestrates comprehensive cascading block removal across multiple overlapping frame steps.
+     *
+     * @returns {number} The integer metric mapping strictly deleted physical bounds.
      */
     clearFullRows(): number;
     /**
-     * Checks if every cell in a specific column is active.
+     * Executes vertical sweeping verifying no static empty elements disrupt a physical column footprint.
+     *
+     * @param {number} x - The integer declaring the vertical map layer mapped to width.
+     * @returns {boolean} A boolean true if density confirms completely loaded limits.
      */
     isColumnFull(x: number): boolean;
     /**
-     * Checks if every cell in a specific column is inactive.
+     * Executes vertical sweeping verifying no active elements exist across a physical column footprint.
+     *
+     * @param {number} x - The integer declaring the vertical map layer mapped to width.
+     * @returns {boolean} A boolean true if all limits check out completely zeroed out.
      */
     isColumnEmpty(x: number): boolean;
     /**
-     * Resets all cells in a specific column to their default empty state.
+     * Purges specific memory instances mapping empty metadata objects identically across a column length.
+     *
+     * @param {number} x - The integer mapped vertically mapping width to wipe.
+     * @returns {void} Returns nothing.
      */
     clearColumn(x: number): void;
     /**
-     * Shifts all columns to the left of a certain index one position to the right.
+     * Transplants memory contents shifting column sequences securely right one numerical grid measure.
+     *
+     * @param {number} fromX - The explicit target line evaluating continuous transfers.
+     * @returns {void} Returns nothing.
      */
     shiftColumnsRight(fromX: number): void;
     /**
-     * Shifts all columns to the right of a certain index one position to the left.
+     * Transplants memory contents shifting column sequences securely left one numerical grid measure.
+     *
+     * @param {number} fromX - The explicit target line evaluating continuous transfers.
+     * @returns {void} Returns nothing.
      */
     shiftColumnsLeft(fromX: number): void;
     /**
-     * Scans for full columns, clears them, and shifts remaining columns right.
+     * Orchestrates comprehensive cascading block removal across multiple overlapping frame steps on columns.
+     *
+     * @returns {number} The integer metric mapping strictly deleted physical bounds.
      */
     clearFullColumns(): number;
 }

package/dist/types/core/module/grid/engines/GridMovementEngine.d.ts

@@ -1,29 +1,113 @@
 import { Cell, Vector, Piece } from '../../../types/Types';
 import { Grid } from '../../../types/modules';
 /**
- * Handles movement and projection logic for the game grid.
+ * Engineering sub-module providing single and multi-cell velocity behaviors.
+ *
+ * Implements the {@link Grid} physical positioning operations. It resolves vector translations
+ * against the static cell board, mapping out exact placement steps or rejecting invalid logic
+ * before game states have a chance to falsely render overlaps.
  */
 export default class GridMovementEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Attempts to shift a collection of cells (a piece) in a given direction.
+     * Modifies the piece footprint iterating all target cells mathematically towards a given offset.
+     *
+     * @param {Piece} piece - The original collection of dynamically bound target cells.
+     * @param {Vector} direction - The spatial translation array declaring x/y offset integers.
+     * @returns {Piece} A new piece copy reflecting changes, or the old identical piece if restricted.
      */
-    movePiece(piece: Piece, direction: Vector): Piece | null;
-    movePieceLeft(piece: Piece): Piece | null;
-    movePieceRight(piece: Piece): Piece | null;
-    movePieceUp(piece: Piece): Piece | null;
-    movePieceDown(piece: Piece): Piece | null;
+    movePiece(piece: Piece, direction: Vector): Piece;
     /**
-     * Attempts to shift a single cell in a given direction.
+     * Alias for {@link movePiece} shifting one unit left continuously.
+     *
+     * @param {Piece} piece - The specific piece payload shifting.
+     * @returns {Piece} The new valid piece output.
+     */
+    movePieceLeft(piece: Piece): Piece;
+    /**
+     * Alias for {@link movePiece} shifting one unit right continuously.
+     *
+     * @param {Piece} piece - The specific piece payload shifting.
+     * @returns {Piece} The new valid piece output.
+     */
+    movePieceRight(piece: Piece): Piece;
+    /**
+     * Alias for {@link movePiece} shifting one unit up continuously.
+     *
+     * @param {Piece} piece - The specific piece payload shifting.
+     * @returns {Piece} The new valid piece output.
+     */
+    movePieceUp(piece: Piece): Piece;
+    /**
+     * Alias for {@link movePiece} shifting one unit down continuously.
+     *
+     * @param {Piece} piece - The specific piece payload shifting.
+     * @returns {Piece} The new valid piece output.
+     */
+    movePieceDown(piece: Piece): Piece;
+    /**
+     * Modifies a single cell footprint moving it mathematically towards a given offset.
+     *
+     * @param {Cell} cell - The original single target cell.
+     * @param {Vector} direction - The spatial translation array declaring x/y offset integers.
+     * @returns {Cell} A new cell copy reflecting changes, or the old identical cell if restricted.
+     */
+    moveCell(cell: Cell, direction: Vector): Cell;
+    /**
+     * Alias for {@link moveCell} shifting one unit left continuously.
+     *
+     * @param {Cell} cell - The specific cell shifting.
+     * @returns {Cell} The new valid cell output.
+     */
+    moveCellLeft(cell: Cell): Cell;
+    /**
+     * Alias for {@link moveCell} shifting one unit right continuously.
+     *
+     * @param {Cell} cell - The specific cell shifting.
+     * @returns {Cell} The new valid cell output.
+     */
+    moveCellRight(cell: Cell): Cell;
+    /**
+     * Alias for {@link moveCell} shifting one unit up continuously.
+     *
+     * @param {Cell} cell - The specific cell shifting.
+     * @returns {Cell} The new valid cell output.
+     */
+    moveCellUp(cell: Cell): Cell;
+    /**
+     * Alias for {@link moveCell} shifting one unit down continuously.
+     *
+     * @param {Cell} cell - The specific cell shifting.
+     * @returns {Cell} The new valid cell output.
+     */
+    moveCellDown(cell: Cell): Cell;
+    /**
+     * Implements a while-loop simulation repeatedly pushing a piece down until a collision is recorded.
+     *
+     * @param {Piece} piece - The piece footprint to analyze.
+     * @returns {Piece} A modified piece reflecting the absolute lowest valid coordinate alignment.
      */
-    moveCell(cell: Cell, direction: Vector): Cell | null;
-    moveCellLeft(cell: Cell): Cell | null;
-    moveCellRight(cell: Cell): Cell | null;
-    moveCellUp(cell: Cell): Cell | null;
-    moveCellDown(cell: Cell): Cell | null;
     getDropPath(piece: Piece): Piece;
+    /**
+     * Implements a while-loop simulation repeatedly pushing a piece up until a collision is recorded.
+     *
+     * @param {Piece} piece - The piece footprint to analyze.
+     * @returns {Piece} A modified piece reflecting the absolute highest valid coordinate alignment.
+     */
     getRisePath(piece: Piece): Piece;
+    /**
+     * Implements a while-loop simulation repeatedly pushing a piece left until a collision is recorded.
+     *
+     * @param {Piece} piece - The piece footprint to analyze.
+     * @returns {Piece} A modified piece reflecting the absolute furthest left valid coordinate alignment.
+     */
     getReachPathLeft(piece: Piece): Piece;
+    /**
+     * Implements a while-loop simulation repeatedly pushing a piece right until a collision is recorded.
+     *
+     * @param {Piece} piece - The piece footprint to analyze.
+     * @returns {Piece} A modified piece reflecting the absolute furthest right valid coordinate alignment.
+     */
     getReachPathRight(piece: Piece): Piece;
 }

package/dist/types/core/module/grid/engines/GridRegionEngine.d.ts

@@ -2,25 +2,44 @@ import { Color } from '../../../types/enums';
 import { Cell, Coordinate, Piece } from '../../../types/Types';
 import { Grid } from '../../../types/modules';
 /**
- * Handles region-based operations (areas, stamps, and occupancy) on the grid.
+ * Engineering sub-module strictly handling multi-cell batch operations and bounding interactions.
+ *
+ * Implements the {@link Grid} region processing logic. It aggregates simple cell iterations
+ * into unified area bounds to execute high-level game instructions, such as bulk stamping
+ * piece shapes or checking broad space availabilities.
  */
 export default class GridRegionEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Checks if any of the provided coordinates are already occupied or out of bounds.
+     * Extends basic coordinate validation across a multiple-point piece footprint.
+     *
+     * @param {Coordinate[]} coordinates - The list of point mappings defining the desired area.
+     * @returns {boolean} A boolean true if any single piece chunk strikes a grid-wall or populated floor.
      */
     isAreaOccupied(coordinates: Coordinate[]): boolean;
     /**
-     * Fills a rectangular region defined by two corners with a specific value and color.
+     * Implements a generic box-shape overwrite mechanism across given 2D diagonal endpoints.
+     *
+     * @param {Coordinate} start - The initial boundary corner dictating iteration limits.
+     * @param {Coordinate} end - The terminating boundary corner closing the drawn box.
+     * @param {number} value - The numeric status assigning logical engine density.
+     * @param {Color} color - The specific UI token mapping the region aesthetic details.
+     * @returns {void} Returns nothing.
      */
     fillArea(start: Coordinate, end: Coordinate, value: number, color: Color): void;
     /**
-     * Updates multiple coordinates simultaneously with their specific values and colors.
+     * Converts a transient piece's logical blocks fully into permanently anchored static grid spaces.
+     *
+     * @param {Piece} piece - The collection of logically associated cells ready for injection.
+     * @returns {void} Returns nothing.
      */
     stampPiece(piece: Piece): void;
     /**
-     * Updates a single coordinate with a specific value and color from a Cell.
+     * Translates a single transient logical brick strictly into the grid's memory buffer.
+     *
+     * @param {Cell} cell - The complex type combining grid location, metadata value, and color payload.
+     * @returns {void} Returns nothing.
      */
     stampCell(cell: Cell): void;
 }

package/dist/types/core/module/grid/engines/GridTransformEngine.d.ts

@@ -1,21 +1,37 @@
 import { Coordinate, Axis, Piece } from '../../../types/Types';
 import { Grid } from '../../../types/modules';
 /**
- * Handles geometric transformations for pieces on the grid.
+ * Engineering sub-module handling geometric boundary manipulations and complex piece translations.
+ *
+ * Implements the {@link Grid} transformation behaviors. It acts as an isolated stateless evaluator
+ * providing mathematical projections (like rotation or mirroring) independently from the live game
+ * state, guaranteeing original piece blocks are unsullied if an attempted projection intersects a wall.
  */
 export default class GridTransformEngine {
     private grid;
     constructor(grid: Grid);
     /**
-     * Attempts to rotate a piece 90 degrees around a specific origin.
+     * Attempts to calculate a 90-degree radial offset around a defined center point.
+     *
+     * @param {Piece} piece - The specific layout array of logical cell metrics.
+     * @param {Coordinate} origin - The mathematical center point for the rotational pivot.
+     * @param {boolean} [clockwise=true] - The directional toggle controlling coordinate adjustments.
+     * @returns {Piece} The modified Piece array or the original Piece if collisions occurred.
      */
-    rotatePiece(piece: Piece, origin: Coordinate, clockwise?: boolean): Piece | null;
+    rotatePiece(piece: Piece, origin: Coordinate, clockwise?: boolean): Piece;
     /**
-     * Mirrors a piece across a specific axis relative to its bounding box.
+     * Mirrors a piece mapping its internal locations reversely across a specific median axis.
+     *
+     * @param {Piece} piece - The specific layout array of logical cells to invert.
+     * @param {Axis} axis - The 'x' or 'y' string declaring the geometric flip line.
+     * @returns {Piece} The newly formatted piece instance with updated mirrored values.
      */
     mirrorPiece(piece: Piece, axis: Axis): Piece;
     /**
-     * Calculates the bounding box of a piece.
+     * Iterates all block chunks discovering maximum absolute spatial corners to establish a rect-box boundary.
+     *
+     * @param {Piece} piece - The piece containing scattered cell coordinates.
+     * @returns {{min: Coordinate, max: Coordinate}} An object exposing corner extreme bounds.
      */
     getPieceBounds(piece: Piece): {
         min: Coordinate;

package/dist/types/core/module/renderer/DisplayRenderer.d.ts

@@ -1,43 +1,55 @@
 import { Cell, GameModules, RendererMetrics } from '../../types/Types';
 import { Renderer, State } from '../../types/modules';
 /**
- * Responsible for rendering the main game field (the grid where the game is played).
- * Handles cell rendering, background drawing, and optimizes static elements using an off-screen buffer.
+ * Dedicated visual presentation component isolating grid drawing loops.
+ *
+ * It decouples the performance-intensive grid enumeration from general game loops.
+ * Through pre-compilation (off-screen buffer for background elements) and heavy caching
+ * of explicit geometry boundaries (inner offset, padding, strokes), it minimizes real-time
+ * calculation depth, effectively stabilizing engine framerate limits.
  */
 export default class DisplayRenderer implements Renderer {
     private _rendererMetrics;
     private _cellPreCalculatedGeometry;
     private _staticGraphics;
     /**
-     * Initializes the renderer with the calculated metrics.
-     * Pre-calculates cell geometry for faster rendering.
+     * Implements specific internal matrix caches consuming injected absolute layout metrics.
      *
-     * @param {RendererMetrics} rendererMetrics - The shared renderer metrics.
+     * @param {RendererMetrics} rendererMetrics - The shared pre-compiled dimension dictionaries.
+     * @returns {void} Returns nothing.
      */
     setup(rendererMetrics: RendererMetrics): void;
     /**
-     * Renders the game grid.
-     * Draws the static background first, then iterates over the grid to draw cells.
+     * The continuous execution sequence re-painting the primary logical bounds on-screen.
      *
-     * @param {Cell[][]} grid - The current grid state.
+     * It efficiently pastes the off-screen cached background texture before procedurally computing
+     * transient piece overlay graphics.
+     *
+     * @param {Cell[][]} grid - The 2D target matrix identifying block coordinates.
+     * @param {GameModules} modules - Dynamic context properties passed directly by the Engine.
+     * @returns {void} Returns nothing.
      */
     render(grid: Cell[][], modules: GameModules): void;
     /**
-     * Renders static elements (background and borders) to an off-screen buffer.
-     * This improves performance by avoiding re-drawing static shapes every frame.
+     * Executes the initial setup closure defining fixed off-screen graphics buffer textures.
+     *
+     * @returns {void} Returns nothing.
      */
     private _renderStaticElements;
     /**
-     * Renders a single brick at grid coordinates.
-     * Uses translation matrices to keep drawing logic clean.
+     * Processes individual cell geometric construction dynamically translating matrices to prevent nested complex mathematics.
      *
-     * @param {Cell} cell - The cell data to render.
+     * @param {Cell} cell - The structured data representing logical bounds and status coloring.
+     * @param {State} state - Actively running environment configuration (like color schemes or game over logic).
+     * @returns {void} Returns nothing.
      */
     protected renderCell({ coordinate, color, value }: Cell, state: State): void;
     /**
-     * Iterates through the grid and renders each cell.
+     * Executes the rapid sequence loop covering the active logic matrix.
      *
-     * @param {Cell[][]} grid - The grid to render.
+     * @param {Cell[][]} grid - The logical target state collection.
+     * @param {State} state - Active environment flags modifying visual styling.
+     * @returns {void} Returns nothing.
      */
     protected renderGrid(grid: Cell[][], state: State): void;
 }

package/dist/types/core/module/renderer/GameRenderer.d.ts

@@ -3,9 +3,12 @@ import { Debuggable } from '../../types/Interfaces';
 import { Renderer } from '../../types/modules';
 import { RendererComposite } from '../../types/modules';
 /**
- * Composite renderer that manages multiple sub-renderers.
- * Orchestrates the rendering of the main display and the HUD.
- * Handles the calculation of shared rendering metrics (sizes, positions) to ensure consistency.
+ * Orchestrating composite module acting as the visual context manager.
+ *
+ * Implements the {@link RendererComposite} pattern to aggregate the specific display and HUD
+ * pipeline. It bridges the mathematical constraints (e.g. converting a relative 0.0-1.0
+ * grid position into strict P5 canvas pixels) and ensures layout recalculations happen exactly
+ * once during initialization to avoid expensive bounds-checking inside the main draw loops.
  */
 export default class GameRenderer implements RendererComposite, Debuggable {
     private _renderers;
@@ -13,27 +16,31 @@ export default class GameRenderer implements RendererComposite, Debuggable {
     private _hudRenderer;
     private _rendererMetrics;
     /**
-     * Adds a sub-renderer to the composition.
+     * Injects a sub-renderer routine into the core pipeline queue.
      *
-     * @param {Renderer} renderer - The renderer to add.
+     * @param {Renderer} renderer - The specific layer or boundary drawer.
+     * @returns {void} Returns nothing.
      */
     addRenderer(renderer: Renderer): void;
     /**
-     * Initializes all sub-renderers and calculates layout metrics.
-     * This method must be called before rendering begins.
+     * Instantiates system geometries and pushes strict calculated metrics down the pipeline.
+     * Must be invoked prior to the first rendering frame trigger.
+     *
+     * @returns {void} Returns nothing.
      */
     setup(): void;
     /**
-     * Calculates the layout dimensions for the display and HUD.
-     * Based on screen configuration and relative values.
+     * Pre-compiles absolute geometric values resolving relative design layouts against the physical hardware space.
+     *
+     * @returns {void} Returns nothing.
      */
     private _calculateMetrics;
     /**
-     * Delegating render method.
-     * Calls render on all registered sub-renderers.
+     * Exposes the single dispatch drawing sequence forwarding contexts down the entire renderer queue.
      *
-     * @param {Cell[][]} grid - The main game grid.
-     * @param {GameModules} modules - The game modules collection.
+     * @param {Cell[][]} grid - The logical playfield state matrix.
+     * @param {GameModules} modules - The active state containers injected dynamically.
+     * @returns {void} Returns nothing.
      */
     render(grid: Cell[][], modules: GameModules): void;
     /**

package/dist/types/core/module/renderer/HudRenderer.d.ts

@@ -1,48 +1,56 @@
 import { Renderer } from '../../types/modules';
 import { Cell, GameModules, RendererMetrics } from '../../types/Types';
 /**
- * Responsible for rendering the Heads-Up Display (HUD).
- * Displays game information like Score, High Score, Level, and the Next Piece Preview.
+ * Dedicated visual presentation component isolating Heads-Up Display (HUD) mechanics.
+ *
+ * Implements the {@link Renderer} interface to decouple metadata logic (level, scores, Next Piece
+ * visuals) away from core game physics. By translating absolute space constraints mapped in
+ * `configs.screenLayout`, it creates responsive graphical UI outputs without expensive real-time
+ * geometry processing on each execution tick.
  */
 export default class HudRenderer implements Renderer {
     private _gridOrigin;
     private _cellSize;
     private _hudBorderRect;
     /**
-     * Initializes the HUD with calculated metrics.
-     * Sets up the grid origin and border rectangle for the "next piece" preview area.
+     * Binds strictly defined initial layouts mapping dynamically sized objects over absolute space.
      *
-     * @param {RendererMetrics} rendererMetrics - The shared renderer metrics.
+     * @param {RendererMetrics} rendererMetrics - Pre-calculated scale components established globally.
+     * @returns {void} Returns nothing.
      */
     setup(rendererMetrics: RendererMetrics): void;
     /**
-     * Renders all HUD elements.
+     * Orchestrates the active frame-tick UI compilation logic sequences.
      *
-     * @param {Cell[][]} grid - The main game grid (unused in HUD, but required by interface).
-     * @param {GameModules} modules - The game modules for retrieving state and score.
+     * @param {Cell[][]} grid - A standard mapping hook currently unused by this context explicitly.
+     * @param {GameModules} modules - The active registry exposing GameScore and GameState values.
+     * @returns {void} Returns nothing.
      */
     render(grid: Cell[][], modules: GameModules): void;
     /**
-     * Renders the text-based HUD elements (Score, Level, Status).
+     * Compiles dynamic string payloads over absolute canvas locations tracking user data metrics.
      *
-     * @param {GameModules} modules - The game modules.
+     * @param {GameModules} modules - Global registry resolving access to the Score system.
+     * @returns {void} Returns nothing.
      */
     private _renderHud;
     /**
-     * Renders the preview grid for the next piece.
+     * Maps the static inner-HUD coordinate box defining where piece previews exist natively.
      *
-     * @param {GameModules} modules - The game modules.
+     * @param {GameModules} modules - Engine registry exposing the `GameHudGrid` explicitly.
+     * @returns {void} Returns nothing.
      */
     private _drawHudGrid;
     /**
-     * Helper method to draw a single cell on the HUD.
-     * Identical in logic to DisplayRenderer's cell drawing but localized for HUD.
+     * Optimized internal draw operation processing graphical offsets for the sub-grid layer.
      *
-     * @param {object} params - The drawing parameters.
-     * @param {number} params.w - Width of the cell.
-     * @param {number} params.posX - Absolute X position.
-     * @param {number} params.posY - Absolute Y position.
-     * @param {Color} params.color - Color of the cell.
+     * @param {object} params - Explicit physical boundary configuration dictionary.
+     * @param {number} params.w - The scale cell width footprint constraint.
+     * @param {number} params.h - The scale cell height footprint constraint.
+     * @param {number} params.posX - Translating X absolute starting point coordinate limit.
+     * @param {number} params.posY - Translating Y absolute starting point coordinate limit.
+     * @param {Color} params.color - The specific string enum resolving rendering palette strokes.
+     * @returns {void} Returns nothing.
      */
     private drawCellElement;
 }

package/dist/types/core/module/score/GameScore.d.ts

@@ -2,9 +2,12 @@ import { Debuggable } from '../../types/Interfaces';
 import { Score } from '../../types/modules';
 import { Serializable } from '../../types/Interfaces';
 /**
- * Manages game scoring, levels, and high score tracking.
- * Acts as the authority for the game's `highScore`, persisting it directly to `LocalStorage`.
- * Handles multipliers and supports Session serialization out of the box.
+ * Stateful module dedicated to tracking real-time player performance metrics.
+ *
+ * Implements the {@link Score} and {@link Serializable} interfaces to provide
+ * a centralized authority for maintaining score lines, difficulty levels, and
+ * multiplier bonuses. It uniquely tracks the global `highScore` by saving it
+ * directly to `LocalStorage` under an isolated `gameId` namespace.
  */
 export default class GameScore implements Score, Debuggable, Serializable {
     private _score;
@@ -15,37 +18,44 @@ export default class GameScore implements Score, Debuggable, Serializable {
     private _gameId;
     serialId: string;
     /**
-     * Sets up the game high score.
+     * Initializes the High Score context using a distinct installation prefix.
      *
-     * @param {string} id - The game ID.
+     * @param {string} id - The explicit game UUID or namespace string to prevent record collisions.
+     * @returns {void} Returns nothing.
      */
     setupGameHighScore(id: string): void;
     /**
-     * Increases the score by the given amount, applying the current multiplier.
-     * Automatically checks for high score updates.
+     * Increases the score by the given base amount after calculating active multipliers.
+     * Automatically assesses if the new score surpasses and replaces the persistent High Score.
      *
-     * @param {number} amount - The base amount to increase by.
+     * @param {number} amount - The integer base points to add before multipliers.
+     * @returns {void} Returns nothing.
      */
     increaseScore(amount: number): void;
     /**
-     * Resets the current score to 0.
+     * Zeroes out the active tracking score.
+     *
+     * @returns {void} Returns nothing.
      */
     resetScore(): void;
     /**
-     * Formats the current score as a string with leading zeros.
+     * Exports the raw session score as a physically padded string sequence.
      *
-     * @param {number} [digits=6] - The total number of digits to display.
-     * @returns {string} The formatted score string (e.g., "000150").
+     * @param {number} [digits=6] - The optional total number of sequence places to output (e.g. 6).
+     * @returns {string} The formatted string payload displaying leading zeros (e.g., "000150").
      */
     getFormattedScore(digits?: number): string;
     /**
-     * Increases the game level by a specific amount.
+     * Steps up the active engine difficulty level scaling.
      *
-     * @param {number} amount - The number of levels to add.
+     * @param {number} amount - The integer step of new levels to jump.
+     * @returns {void} Returns nothing.
      */
     increaseLevel(amount: number): void;
     /**
-     * Resets the game level back to 1.
+     * Resets the active difficulty level baseline back to initial 1.
+     *
+     * @returns {void} Returns nothing.
      */
     resetLevel(): void;
     /**
@@ -110,10 +120,11 @@ export default class GameScore implements Score, Debuggable, Serializable {
      */
     serialize(): string;
     /**
-     * Restores score and level progress from a serialized JSON string.
-     * Used by the SessionManager when recovering an active session.
+     * Modifies the running variables based on an injected serialized payload.
+     * Instructed dynamically by the `SessionManager` during initialization recovery.
      *
-     * @param {string} data - The JSON string containing the saved session data.
+     * @param {string} data - The packed string blob enclosing the structured saved session.
+     * @returns {void} Returns nothing.
      */
     deserialize(data: string): void;
 }