@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.0

package/src/foundry/foundry.js/pixi/containers/canvasLayers/placeablesLayers/wallsLayer.d.ts

@@ -11,17 +11,16 @@ declare global {
     constructor();
 
     /**
-     * A graphics layer used to display chained Wall selection
-     * @defaultValue `null`
+     * An array of Wall objects which represent the boundaries of the canvas.
+     * @defaultValue `new Set()`
      */
-    chain: PIXI.Graphics | null;
+    boundaries: Set<Wall>;
 
     /**
-     * An array of all the unique perception-blocking endpoints which are present in the layer
-     * We keep this array cached for faster sight polygon computations
-     * @defaultValue `[]`
+     * A graphics layer used to display chained Wall selection
+     * @defaultValue `null`
      */
-    endpoints: PointArray[];
+    chain: PIXI.Graphics | null;
 
     /**
      * Track whether we are currently within a chained placement workflow
@@ -47,13 +46,11 @@ declare global {
      * @defaultValue
      * ```
      * {
-     *   id: null,
      *   point: null,
      * }
      * ```
      */
     protected last: {
-      id: string | null;
       point: PointArray | null;
     };
 
@@ -69,9 +66,6 @@ declare global {
      * mergeObject(super.layerOptions, {
      *  name: "walls"
      *  controllableObjects: true,
-     *  objectClass: Wall,
-     *  quadtree: true,
-     *  sheetClass: WallConfig,
      *  sortActiveTop: true,
      *  zIndex: 40
      * })
@@ -107,6 +101,12 @@ declare global {
      */
     initialize(): void;
 
+    /**
+     * Initialization to identify all intersections between walls.
+     * These intersections are cached and used later when computing point source polygons.
+     */
+    identifyWallIntersections(): void;
+
     /**
      * Identify walls which are treated as "interior" because they are contained fully within a roof tile.
      */
@@ -120,31 +120,21 @@ declare global {
      */
     static getClosestEndpoint(point: Point, wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>): PointArray;
 
-    /**
-     * Given an array of Wall instances, identify the unique endpoints across all walls.
-     * @param walls   - An array of Wall instances
-     * @param options - Additional options which modify the set of endpoints identified
-     *                  (defaultValue: `{}`)
-     * @returns An array of endpoints
-     */
-    static getUniqueEndpoints(
-      walls:
-        | InstanceType<ConfiguredObjectClassForName<'Wall'>>[]
-        | Set<InstanceType<ConfiguredObjectClassForName<'Wall'>>>,
-      options?: EndpointOptions
-    ): PointArray[];
-
     /**
      * Test whether movement along a given Ray collides with a Wall.
      * @param ray     - The attempted movement
      * @param options - Options which customize how collision is tested
-     * @returns Does a collision occur?
+     * @returns False if there are no Walls
+     *          True if the Ray is outside the Canvas
+     *          Whether any collision occurred if mode is "any"
+     *          An array of collisions, if mode is "all"
+     *          The closest collision, if mode is "closest"
      */
-    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'all' }): boolean | RayIntersection[];
-    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'closest' }): boolean | RayIntersection | null;
+    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'all' }): boolean | PolygonVertex[];
+    checkCollision(ray: Ray, options: CollisionOptions & { mode: 'closest' }): boolean | PolygonVertex;
     checkCollision(ray: Ray, options: CollisionOptions & { mode: 'any' }): boolean;
     checkCollision(ray: Ray, options: Omit<CollisionOptions, 'mode'>): boolean;
-    checkCollision(ray: Ray, options: CollisionOptions): boolean | RayIntersection | null;
+    checkCollision(ray: Ray, options: CollisionOptions): boolean | PolygonVertex;
     checkCollision(ray: Ray, options?: CollisionOptions): boolean;
 
     /**
@@ -164,6 +154,12 @@ declare global {
       options?: PasteOptions
     ): Promise<InstanceType<ConfiguredDocumentClass<typeof foundry.documents.BaseWall>>[]>;
 
+    /**
+     * Create temporary WallDocument instances which represent the rectangular boundaries of the canvas.
+     * @internal
+     */
+    protected _createBoundaries(): void;
+
     /**
      * Pan the canvas view when the cursor position gets close to the edge of the frame
      * @param event - The originating mouse movement event
@@ -189,8 +185,10 @@ declare global {
      */
     protected _getWallDataFromActiveTool(tool: string):
       | {
-          move: foundry.CONST.WALL_MOVEMENT_TYPES;
-          sense: foundry.CONST.WALL_SENSE_TYPES;
+          light: foundry.CONST.WALL_SENSE_TYPES;
+          sight: foundry.CONST.WALL_SENSE_TYPES;
+          sound: foundry.CONST.WALL_SENSE_TYPES;
+          move: foundry.CONST.WALL_SENSE_TYPES;
           door?: foundry.CONST.WALL_DOOR_TYPES;
         }
       | this['_cloneType'];
@@ -210,32 +208,14 @@ declare global {
     /** @override */
     protected _onClickRight(event: PIXI.InteractionEvent): void;
 
-    /**
-     * Compute source polygons of a requested type for a given origin position and maximum radius.
-     * This method returns two polygons, one which is unrestricted by the provided radius, and one that is constrained
-     * by the maximum radius.
-     *
-     * @param origin  - An point with coordinates x and y representing the origin of the test
-     * @param radius  - A distance in canvas pixels which reflects the visible range
-     * @param options - Additional options which modify the sight computation
-     *                  (default: `{}`)
-     * @returns The computed rays and polygons
-     */
+    /** @deprecated since v9 */
     computePolygon(
       origin: Point,
       radius: number,
       options?: ComputePolygonOptions
     ): { rays: Ray[]; los: PIXI.Polygon; fov: PIXI.Polygon };
 
-    /**
-     * Get the set of wall collisions for a given Ray
-     * @param ray     - The Ray being tested
-     * @param options - Options which customize how collision is tested
-     *                  (default: `{}`)
-     * @returns An array of collisions, if mode is "all"
-     *          The closest collision, if mode is "closest"
-     *          Whether any collision occurred if mode is "any"
-     */
+    /** @deprecated since v9 */
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'all' }): RayIntersection[];
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'closest' }): RayIntersection | null;
     getRayCollisions(ray: Ray, options: RayCollisionsOptions & { mode: 'any' }): boolean;
@@ -243,77 +223,26 @@ declare global {
     getRayCollisions(ray: Ray, options?: RayCollisionsOptions): RayIntersection[] | RayIntersection | boolean | null;
 
     /**
-     * A helper method responsible for casting rays at wall endpoints.
-     * Rays are restricted by limiting angles.
-     *
-     * @param x          - The origin x-coordinate
-     * @param y          - The origin y-coordinate
-     * @param distance   - The ray distance
-     * @param density    - The desired radial density
-     *                     (default: `4`)
-     * @param endpoints  - An array of endpoints to target
-     * @param limitAngle - Whether the rays should be cast subject to a limited angle of emission
-     *                     (default: `false`)
-     * @param aMin       - The minimum bounding angle
-     * @param aMax       - The maximum bounding angle
-     *
-     * @returns An array of Ray objects
-     */
-    static castRays(
-      x: number,
-      y: number,
-      distance: number,
-      {
-        density,
-        endpoints,
-        limitAngle,
-        aMin,
-        aMax
-      }?: { density?: number; endpoints?: PointArray[]; limitAngle?: boolean; aMin?: number; aMax?: number }
-    ): Ray[];
-
-    /**
-     * Test a single Ray against a single Wall
-     * @param ray  - The Ray being tested
-     * @param wall - The Wall against which to test
-     * @returns A RayIntersection if a collision occurred, or null
-     */
-    static testWall(ray: Ray, wall: InstanceType<ConfiguredObjectClassForName<'Wall'>>): RayIntersection | null;
-
-    /**
-     * Identify the closest collision point from an array of collisions
-     * @param collisions - An array of intersection points
-     * @returns The closest blocking intersection or null if no collision occurred
-     */
-    static getClosestCollision(collisions: RayIntersection[]): RayIntersection | null;
-
-    /**
-     * Normalize an angle to ensure it is baselined to be the smallest angle that is greater than a minimum.
-     * @param aMin  - The lower-bound minimum angle
-     * @param angle - The angle to adjust
-     * @returns The adjusted angle which is greater than or equal to aMin.
-     */
-    protected static _normalizeAngle(aMin: number, angle: number): number;
-
-    /**
-     * Map source types to wall collision types
-     * @param type - The source polygon type
-     * @returns The wall collision attribute
-     */
-    protected static _mapCollisionType(type: 'movement'): 'move';
-    protected static _mapCollisionType(type: 'light'): 'sense';
-    protected static _mapCollisionType(type: 'sight'): 'sense';
-    protected static _mapCollisionType(type: 'sound'): 'sound';
-
-    /**
-     * @deprecated since 0.8.0
+     * An array of all the unique perception-blocking endpoints which are present in the layer
+     * We keep this array cached for faster sight polygon computations
+     * @deprecated since v9
      */
-    get blockVision(): InstanceType<ConfiguredObjectClassForName<'Wall'>>[];
+    get endpoints(): PointArray[];
 
     /**
-     * @deprecated since 0.8.0
+     * Given an array of Wall instances, identify the unique endpoints across all walls.
+     * @param walls   - An array of Wall instances
+     * @param options - Additional options which modify the set of endpoints identified
+     *                  (defaultValue: `{}`)
+     * @returns An array of endpoints
+     * @deprecated since v9
      */
-    get blockMovement(): InstanceType<ConfiguredObjectClassForName<'Wall'>>[];
+    static getUniqueEndpoints(
+      walls:
+        | InstanceType<ConfiguredObjectClassForName<'Wall'>>[]
+        | Set<InstanceType<ConfiguredObjectClassForName<'Wall'>>>,
+      options?: EndpointOptions
+    ): PointArray[];
   }
 
   namespace WallsLayer {
@@ -345,9 +274,9 @@ interface EndpointOptions {
 interface CollisionOptions {
   /**
    * Which collision type to check: movement, sight, sound
-   * @defaultValue `'movement'`
+   * @defaultValue `'move'`
    */
-  type?: 'movement' | 'sight' | 'sound';
+  type?: 'move' | 'sight' | 'sound';
 
   /**
    * Which type of collisions are returned: any, closest, all

package/src/foundry/foundry.js/pixi/containers/canvasLayers/sightLayer.d.ts

@@ -4,18 +4,17 @@
  * @see PointSource
  *
  * The container structure of this layer is as follows:
- * sight: SightLayer              The SightLayer itself
- *   msk: PIXI.Graphics           A masking rectangle that restricts exploration to the scene background
- *   unexplored: PIXI.Graphics    An unexplored background that spans the entire scene canvas
- *   explored: PIXI.Container     The exploration container
- *      revealed: PIXI.Container  The container of areas which have been previously revealed
- *        saved: PIXI.Sprite      The saved FOW exploration texture from the database
- *        pending: PIXI.Container A container of pending exploration polygons that have not yet been saved
- *        roofs: PIXI.Container   A container of occluded roof sprites which should not be marked as explored
- *      current: PIXI.Container   The current vision container
- *        los: PIXI.Graphics      The current line-of-sight polygon
- *        fov: PIXI.Graphics      The current filed-of-view polygon
- *      msk: PIXI.Graphics        The masking rectangle that limits exploration to the Scene background
+ *
+ * unexplored   The unexplored background which spans the entire canvas
+ * explored     The exploration container which tracks exploration progress
+ * revealed       A container of regions which have previously been revealed
+ * saved          The saved fog exploration texture
+ * pending        Pending exploration which has not yet been committed to the texture
+ * vision         The container of current vision exploration
+ * vision.base      Baseline provided vision
+ * vision.fov       Current light source field-of-view polygons
+ * vision.los       Current vision source line-of-sight polygons
+ * vision.roofs     Roof textures which should temporarily be revealed
  *
  * @example <caption>The sightRefresh hook</caption>
  * ```typescript
@@ -26,6 +25,21 @@ import { ConfiguredDocumentClass } from '../../../../../types/helperTypes';
 
 declare global {
   class SightLayer extends CanvasLayer<SightLayer.LayerOptions> {
+    /** The unexplored background which spans the entire canvas */
+    unexplored?: PIXI.Graphics;
+
+    /** The exploration container which tracks exploration progress */
+    explored?: PIXI.Container;
+
+    /** A container of regions which have previously been revealed */
+    revealed?: PIXI.Container;
+
+    /** The saved fog exploration texture */
+    saved?: PIXI.Sprite;
+
+    /** Pending exploration which has not yet been committed to the texture */
+    pending?: PIXI.Container;
+
     constructor();
 
     /**
@@ -39,46 +53,78 @@ declare global {
      */
     sources: foundry.utils.Collection<PointSource>;
 
-    /**
-     * The canonical line-of-sight polygon which defines current Token visibility.
-     */
-    los: PIXI.Graphics;
-
     /**
      * A status flag for whether the layer initialization workflow has succeeded
      * @defaultValue `false`
+     * @internal
      */
     protected _initialized: boolean;
 
     /**
-     * A pool of fog of war exploration containers that can be recycled
-     * @defaultValue `[]`
+     * A debounced function to save fog of war exploration once a stream of updates have stopped
      */
-    protected _visionPool: PIXI.Container[];
+    debounceSaveFog: (...args: Parameters<this['saveFog']>) => void;
 
     /**
-     * Track whether fog of war exploration has been updated and required saving
-     * @defaultValue `false`
+     * The current vision container which provides line-of-sight for vision sources and field-of-view of light sources.
+     * @defaultValue `undefined`
      */
-    protected _fogUpdated: boolean;
+    vision:
+      | (PIXI.Container & {
+          /** Baseline provided vision */
+          base: PIXI.Graphics;
+
+          /** Current light source field-of-view polygons */
+          fov: PIXI.Container;
+
+          /** Current vision source line-of-sight polygons */
+          los: PIXI.Graphics;
+
+          /** Roof textures which should temporarily be revealed */
+          roofs: PIXI.Container;
+        })
+      | undefined;
 
     /**
-     * Track the number of moves which have updated fog of war
-     * @defaultValue `0`
+     * The canonical line-of-sight polygon which defines current Token visibility.
+     * @defaultValue `undefined`
      */
-    protected _fogUpdates: number;
+    los: PIXI.Graphics | undefined;
 
     /**
-     * A debounced function to save fog of war exploration once a stream of updates have stopped
+     * A cached container which creates a render texture used for the LOS mask.
+     * @defaultValue `undefined`
      */
-    debounceSaveFog: (...args: Parameters<this['saveFog']>) => void;
+    losCache: CachedContainer | undefined;
+
+    /**
+     * Track whether we have pending fog updates which have not yet been saved to the database
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _fogUpdated: boolean;
 
     /**
      * The configured resolution used for the saved fog-of-war texture
      * @defaultValue `undefined`
+     * @internal
      */
     protected _fogResolution: { resolution: number; width: number; height: number } | undefined;
 
+    /**
+     * A pool of RenderTexture objects which can be cycled through to save fog exploration progress.
+     * @defaultValue `[]`
+     * @internal
+     */
+    protected _fogTextures: PIXI.RenderTexture[];
+
+    /**
+     * Track whether there is a source of vision within the buffer region outside the primary scene canvas
+     * @defaultValue `false`
+     * @internal
+     */
+    protected _inBuffer: boolean;
+
     /**
      * Define the threshold value for the number of distinct Wall endpoints.
      * Below this threshold, exact vision computation is used by casting a Ray at every endpoint.
@@ -93,6 +139,12 @@ declare global {
      */
     static FOG_COMMIT_THRESHOLD: number;
 
+    /**
+     * The maximum allowable fog of war texture size.
+     * @defaultValue `4096`
+     */
+    static MAXIMUM_FOW_TEXTURE_SIZE: number;
+
     /**
      * @remarks This is not overridden in foundry but reflects the real behavior.
      */
@@ -123,18 +175,6 @@ declare global {
     /** @override */
     tearDown(): Promise<this>;
 
-    /**
-     * Initialize the Sight Layer. Initialization has the following hierarchical workflow:
-     *
-     * Initialize Layer (reset entire layer)
-     *  InitializeLights (used to reset all lights)
-     *    UpdateLight (update a single light)
-     *  InitializeTokens (reset all tokens)
-     *    UpdateToken (update a single token)
-     *  Initialize Fog (reset FOW state)
-     */
-    initialize(): Promise<void>;
-
     /**
      * Initialize fog of war - resetting it when switching scenes or re-drawing the canvas
      */
@@ -145,42 +185,45 @@ declare global {
      */
     initializeSources(): Promise<void>;
 
-    /** @override */
-    draw(): Promise<this>;
-
     /**
-     * Construct a vision container that is used to render a single view position.
-     * These containers are placed into the _visionPool and recycled as needed.
+     * Update FoW unexplored and explored colors
      */
-    protected _createVisionContainer(): PIXI.Container;
+    updateFogExplorationColors(): void;
+
+    /** @override */
+    draw(): Promise<this>;
 
     /**
-     * Obtain a vision container from the recycling pool, or create one if no container exists.
-     * Assign the container as the current fog exploration and the current LOS polygon.
+     * Create the cached container and sprite used to provide a LOS mask
+     * @internal
      */
-    protected _getVisionContainer(): PIXI.Container;
+    protected _createCachedMask(): void;
 
     /**
-     * Return a vision container back to the pool, recycling it for future use.
-     * @param c - The container to recycle
+     * Construct a vision container that is used to render a single view position.
+     * @internal
      */
-    protected _recycleVisionContainer(c: PIXI.Container): void;
+    protected _createVisionContainer(): PIXI.Container;
 
     /**
      * Update the display of the sight layer.
      * Organize sources into rendering queues and draw lighting containers for each source
-     *
-     * @param forceUpdateFog - Always update the Fog exploration progress for this update
-     *                         (default: `false`)
-     * @param noUpdateFog    - Never update the Fog exploration progress for this update
-     *                         (default: `false`)
      */
     refresh({
       forceUpdateFog,
-      noUpdateFog
+      skipUpdateFog
     }?: {
+      /**
+       * Always update the Fog exploration progress for this update
+       * (default: `false`)
+       */
       forceUpdateFog?: boolean;
-      noUpdateFog?: boolean;
+
+      /**
+       * Never update the Fog exploration progress for this update
+       * (default: `false`)
+       */
+      skipUpdateFog?: boolean;
     }): void | ReturnType<this['restrictVisibility']>;
 
     /**
@@ -192,21 +235,34 @@ declare global {
     /**
      * Test whether a point on the Canvas is visible based on the current vision and LOS polygons
      *
-     * @param point     - The point in space to test, an object with coordinates x and y.
-     * @param tolerance - A numeric radial offset which allows for a non-exact match. For example, if
-     *                    tolerance is 2 then the test will pass if the point is within 2px of a vision
-     *                    polygon.
-     *                    (defaultValue: `2`)
-     * @param object    - An optional reference to the object whose visibility is being tested
-     *                    (defaultValue: `null`)
-     *
+     * @param point - The point in space to test, an object with coordinates x and y.
      * @returns Whether the point is currently visible.
      */
     testVisibility(
       point: Point,
-      { tolerance, object }?: { tolerance?: number; object?: PIXI.DisplayObject | null }
+      {
+        tolerance,
+        object
+      }?: {
+        /**
+         * A numeric radial offset which allows for a non-exact match. For example, if
+         * tolerance is 2 then the test will pass if the point is within 2px of a vision
+         * polygon.
+         * (defaultValue: `2`)
+         */
+        tolerance?: number;
+
+        /**
+         * An optional reference to the object whose visibility is being tested
+         * (defaultValue: `null`)
+         */
+        object?: PIXI.DisplayObject | null;
+      }
     ): boolean;
 
+    /** @internal */
+    protected _getFogTexture(): PIXI.RenderTexture;
+
     /**
      * Once a new Fog of War location is explored, composite the explored container with the current staging sprite
      * Save that staging Sprite as the rendered fog exploration and swap it out for a fresh staging texture
@@ -242,6 +298,7 @@ declare global {
     /**
      * Choose an adaptive fog rendering resolution which downscales the saved fog textures for larger dimension Scenes.
      * It is important that the width and height of the fog texture is evenly divisible by the downscaling resolution.
+     * @internal
      */
     protected _configureFogResolution(): { resolution: number; width: number; height: number };
 
@@ -249,50 +306,11 @@ declare global {
      * If fog of war data is reset from the server, re-draw the canvas
      */
     protected _handleResetFog(): Promise<void>;
-
-    /**
-     * Visualize the sight layer to understand algorithm performance.
-     * @param bounds    - The initial rectangular bounds of the vision check
-     * @param endpoints - The wall endpoints being tested
-     * @param rays      - The array of cast vision Rays
-     * @param los       - The resulting line-of-sight polygon
-     * @param fov       - The resulting field-of-vision polygon
-     */
-    protected static _visualizeSight(
-      bounds: Rectangle,
-      endpoints: PointArray[],
-      rays: Ray[],
-      los: PIXI.Polygon,
-      fov: PIXI.Polygon
-    ): void;
-
-    /**
-     * @deprecated since 0.8.2
-     * @see WallsLayer#computePolygon
-     * Compute line-of-sight and field-of-vision polygons for a given origin position and visibility radius.
-     * The line-of-sight polygon defines the unrestricted area of visibility for the source.
-     * The field-of-vision polygon defines the restricted area of visibility for the source.
-     * @param angle        - (default: `360`)
-     * @param density      - (default: `6`)
-     * @param rotation     - (default: `0`)
-     * @param unrestricted - (default: `false`)
-     */
-    static computeSight(
-      origin: Point,
-      radius: number,
-      {
-        angle,
-        density,
-        rotation,
-        unrestricted
-      }?: { angle?: number; density?: number; rotation?: number; unrestricted?: boolean }
-    ): { rays: Ray[]; los: PIXI.Polygon; fov: PIXI.Polygon };
   }
 
   namespace SightLayer {
     interface LayerOptions extends CanvasLayer.LayerOptions {
       name: 'sight';
-      zIndex: 400;
     }
   }
 }

package/src/foundry/foundry.js/pixi/containers/controlIcon.d.ts

@@ -27,6 +27,9 @@ declare class ControlIcon extends PIXI.Container {
 
   borderColor: number;
 
+  /**
+   * The color of the icon tint, if any
+   */
   tintColor: number | null;
 
   /**

package/src/foundry/foundry.js/pixi/containers/placeableObjects/tile.d.ts

@@ -70,6 +70,12 @@ declare global {
      */
     occluded: boolean;
 
+    /**
+     * A flag which tracks if the Tile is currently playing
+     * @defaultValue `false`
+     */
+    playing: boolean;
+
     /** @override */
     static embeddedName: 'Tile';
 
@@ -96,6 +102,11 @@ declare global {
      */
     get isRoof(): boolean;
 
+    /**
+     * The effective volume at which this Tile should be playing, including the global ambient volume modifier
+     */
+    get volume(): number;
+
     /** @override */
     draw(): Promise<this>;