@league-of-foundry-developers/foundry-vtt-types 0.8.9-8 → 9.242.0

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

@@ -0,0 +1,29 @@
+/**
+ * A container group which contains visual effects rendered above the primary group.
+ */
+declare class EffectsCanvasGroup extends PIXI.Container {
+  constructor();
+
+  walls: WallsLayer;
+
+  lighting: LightingLayer;
+
+  weather: WeatherLayer;
+
+  sight: SightLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"effects"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}

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

@@ -1,11 +1,14 @@
 import './baseGrid';
 import './baseGrids';
 import './cachedContainer';
+import './cachedContainers';
 import './canvasLayer';
 import './canvasLayers';
 import './controlIcon';
 import './cursor';
 import './doorControl';
+import './effectsCanvasGroup';
+import './interfaceCanvasGroup';
 import './placeableObject';
 import './placeableObjects';
 import './ruler';

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

@@ -0,0 +1,27 @@
+/**
+ * A container group which displays interface elements rendered above other canvas groups.
+ */
+declare class InterfaceCanvasGroup extends PIXI.Container {
+  constructor();
+
+  sounds: SoundsLayer;
+
+  notes: NotesLayer;
+
+  controls: ControlsLayer;
+
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @defaultValue `"interface"`
+   */
+  static groupName: string;
+
+  /**
+   * Create the member layers of the scene container
+   * @internal
+   */
+  protected _createLayers(): void;
+}

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

@@ -445,13 +445,13 @@ interface Vision {
    * @remarks
    * This is required but has been set to optional because of PointSource
    */
-  fov?: PIXI.Polygon | null;
+  fov?: PIXI.Circle | undefined;
 
   /**
    * @remarks
    * This is required but has been set to optional because of PointSource
    */
-  los?: PIXI.Polygon | null;
+  los?: PointSourcePolygon | undefined;
 }
 
 interface RotationOptions {

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

@@ -32,12 +32,12 @@ declare global {
     /**
      * A reference to the PointSource object which defines this vision source area of effect
      */
-    vision: PointSource;
+    vision: VisionSource;
 
     /**
      * A reference to the PointSource object which defines this light source area of effect
      */
-    light: PointSource;
+    light: LightSource;
 
     /** @override */
     static get embeddedName(): 'Token';
@@ -258,7 +258,7 @@ declare global {
      * @param mode - The mode from CONST.TOKEN_DISPLAY_MODES
      * @returns Is the attribute viewable?
      */
-    protected _canViewMode(mode: foundry.CONST.TokenDisplayMode): boolean;
+    protected _canViewMode(mode: foundry.CONST.TOKEN_DISPLAY_MODES): boolean;
 
     /**
      * Animate Token movement along a certain path which is defined by a Ray object

package/src/foundry/foundry.js/pixi/index.d.ts

@@ -2,6 +2,7 @@ import './blendModes';
 import './containers';
 import './filters';
 import './graphics';
+import './points';
 import './polygons';
 import './rectangles';
 import './shaders';

package/src/foundry/foundry.js/pixi/points/index.d.ts

@@ -0,0 +1 @@
+import './wallEndpoint';

package/src/foundry/foundry.js/pixi/points/wallEndpoint.d.ts

@@ -0,0 +1,92 @@
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes.js';
+
+declare global {
+  /**
+   * A special subclass of PIXI.Point which is used for modeling Wall endpoints.
+   * A wall endpoint must have integer coordinates.
+   *
+   * This was used for the RadialSweepPolygon but can now be deleted once that is
+   * @deprecated since v9d2
+   */
+  class WallEndpoint extends PIXI.Point {
+    /**
+     * @param x - The integer x-coordinate
+     * @param y - The integer y-coordinate
+     */
+    constructor(x: number, y: number);
+
+    /**
+     * Express the point as a 32-bit integer with 16 bits allocated to x and 16 bits allocated to y
+     */
+    key: number;
+
+    /**
+     * The angle between this point and the polygon origin
+     * @defaultValue `undefined`
+     */
+    angle: number | undefined;
+
+    /**
+     * Record the set of walls which connect to this Endpoint
+     */
+    walls: Set<ConfiguredObjectClassForName<'Wall'>>;
+
+    /**
+     * Record whether this point is the endpoint of any Wall
+     * @defaultValue `false`
+     */
+    isEndpoint: boolean;
+
+    /**
+     * Record whether this point is a midpoint of any wall?
+     * @defaultValue `false`
+     */
+    isMidpoint: boolean;
+
+    /**
+     * Record whether this point is the termination of the Ray
+     * @defaultValue `false`
+     */
+    isTerminal: boolean;
+
+    /**
+     * Aggregate the maximum of each wall restriction type
+     */
+    types: Record<foundry.CONST.WALL_RESTRICTION_TYPES, number>;
+
+    /**
+     * An intermediate variable used to store the proportional distance of this point from a SightRay origin
+     * @defaultValue `undefined`
+     */
+    protected _r: number | undefined;
+
+    /**
+     * An intermediate variable used to cache the continuation attributes for a certain point
+     * @defaultValue `undefined`
+     */
+    protected _c: { left: boolean; right: boolean } | undefined;
+
+    attachWall(wall: ConfiguredObjectClassForName<'Wall'>): this;
+
+    /**
+     * Does this endpoint equal some other endpoint?
+     * @param other - Some other point with x and y coordinates
+     * @returns Are the points equal?
+     */
+    equals(other: Point): boolean;
+
+    /**
+     * Is this point one that provides only limited perspective?
+     * @param type - The perspective type being tested
+     * @returns Is perspective limited?
+     */
+    isLimited(type: foundry.CONST.WALL_RESTRICTION_TYPES): boolean;
+
+    /**
+     * Encode a x/y coordinate as a 32-bit integer
+     * @param x - The x-coordinate
+     * @param y - The y-coordinate
+     */
+    static getKey(x: number, y: number): number;
+  }
+}

package/src/foundry/foundry.js/pixi/polygons/index.d.ts

@@ -1 +1,2 @@
-import './sourcePolygon';
+import './pointSourcePolygon';
+import './pointSourcePolygons';

package/src/foundry/foundry.js/pixi/polygons/pointSourcePolygon.d.ts

@@ -0,0 +1,98 @@
+interface PointSourcePolygonConfig {
+  /** The type of polygon being computed */
+  type?: foundry.CONST.WALL_RESTRICTION_TYPES;
+
+  /** The angle of emission, if limited */
+  angle?: number;
+
+  /** The desired density of padding rays, a number per PI */
+  density?: number;
+
+  /** A limited radius of the resulting polygon */
+  radius?: number;
+
+  /** The direction of facing, required if the angle is limited */
+  rotation?: number;
+
+  /** Display debugging visualization and logging for the polygon */
+  debug?: boolean;
+
+  /** Is this polygon constrained by any walls? */
+  walls?: boolean;
+
+  /** The object (if any) that spawned this polygon. */
+  source?: PointSource;
+}
+
+/**
+ * An extension of the default PIXI.Polygon which is used to represent the line of sight for a point source.
+ */
+declare abstract class PointSourcePolygon extends PIXI.Polygon {
+  /**
+   * The origin point of the source polygon.
+   */
+  origin: Point;
+
+  /**
+   * The configuration of this polygon.
+   * @defaultValue `{}`
+   */
+  config: PointSourcePolygonConfig;
+
+  /**
+   * A cached array of SightRay objects used to compute the polygon.
+   * @defaultValue `[]`
+   */
+  rays: SightRay[];
+
+  /**
+   * Compute the rectangular bounds for the Polygon.
+   * @param points - The initially provided array of coordinates
+   * @returns The computed Rectangular bounds
+   */
+  protected _getBounds(points: number[]): PIXI.Rectangle;
+
+  /**
+   * Benchmark the performance of polygon computation for this source
+   * @param iterations - The number of test iterations to perform
+   * @param args       - Arguments passed to the compute method
+   */
+  static benchmark(
+    iterations: number,
+    ...args: Parameters<typeof PointSourcePolygon['create']>
+  ): ReturnType<typeof foundry.utils.benchmark>;
+
+  /**
+   * Compute the polygon given a point origin and radius
+   * @param origin - The origin source point
+   * @param config - Configuration options which customize the polygon computation
+   * @returns The computed polygon instance
+   */
+  static create(
+    origin: Point,
+    config: Parameters<PointSourcePolygon['initialize']>[1]
+  ): ReturnType<PointSourcePolygon['compute']>;
+
+  /**
+   * Compute the polygon using the origin and configuration options.
+   * @returns The computed polygon
+   */
+  compute(): this;
+
+  /**
+   * Perform the implementation-specific computation
+   */
+  protected abstract _compute(): void;
+
+  /**
+   * Customize the provided configuration object for this polygon type.
+   * @param origin - The provided polygon origin
+   * @param config - The provided configuration object
+   */
+  initialize(origin: Point, config: PointSourcePolygonConfig): void;
+
+  /**
+   * Visualize the polygon, displaying its computed area, rays, and collision points
+   */
+  visualize(): void;
+}