Initial

resources/app/client-esm/canvas/edges/edge.mjs

@@ -0,0 +1,285 @@
+/**
+ * @typedef {import("../../../common/types.mjs").Point} Point
+ */
+
+/**
+ * @typedef {"wall"|"darkness"|"innerBounds"|"outerBounds"} EdgeTypes
+ */
+
+/**
+ * A data structure used to represent potential edges used by the ClockwiseSweepPolygon.
+ * Edges are not polygon-specific, meaning they can be reused across many polygon instances.
+ */
+export default class Edge {
+  /**
+   * Construct an Edge by providing the following information.
+   * @param {Point} a                     The first endpoint of the edge
+   * @param {Point} b                     The second endpoint of the edge
+   * @param {object} [options]            Additional options which describe the edge
+   * @param {string} [options.id]               A string used to uniquely identify this edge
+   * @param {PlaceableObject} [options.object]  A PlaceableObject that is responsible for this edge, if any
+   * @param {EdgeTypes} [options.type]          The type of edge
+   * @param {WALL_SENSE_TYPES} [options.light]  How this edge restricts light
+   * @param {WALL_SENSE_TYPES} [options.move]   How this edge restricts movement
+   * @param {WALL_SENSE_TYPES} [options.sight]  How this edge restricts sight
+   * @param {WALL_SENSE_TYPES} [options.sound]  How this edge restricts sound
+   * @param {WALL_DIRECTIONS} [options.direction=0] A direction of effect for the edge
+   * @param {WallThresholdData} [options.threshold] Configuration of threshold data for this edge
+   */
+  constructor(a, b, {id, object, direction, type, light, move, sight, sound, threshold}={}) {
+    this.a = new PIXI.Point(a.x, a.y);
+    this.b = new PIXI.Point(b.x, b.y);
+    this.id = id ?? object?.id ?? undefined;
+    this.object = object;
+    this.type = type || "wall";
+    this.direction = direction ?? CONST.WALL_DIRECTIONS.BOTH;
+    this.light = light ?? CONST.WALL_SENSE_TYPES.NONE;
+    this.move = move ?? CONST.WALL_SENSE_TYPES.NONE;
+    this.sight = sight ?? CONST.WALL_SENSE_TYPES.NONE;
+    this.sound = sound ?? CONST.WALL_SENSE_TYPES.NONE;
+    this.threshold = threshold;
+
+    // Record the edge orientation arranged from top-left to bottom-right
+    const isSE = b.x === a.x ? b.y > a.y : b.x > a.x;
+    if ( isSE ) {
+      this.nw = a;
+      this.se = b;
+    }
+    else {
+      this.nw = b;
+      this.se = a;
+    }
+    this.bounds = new PIXI.Rectangle(this.nw.x, this.nw.y, this.se.x - this.nw.x, this.se.y - this.nw.y);
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * The first endpoint of the edge.
+   * @type {PIXI.Point}
+   */
+  a;
+
+  /**
+   * The second endpoint of the edge.
+   * @type {PIXI.Point}
+   */
+  b;
+
+  /**
+   * The endpoint of the edge which is oriented towards the top-left.
+   */
+  nw;
+
+  /**
+   * The endpoint of the edge which is oriented towards the bottom-right.
+   */
+  se;
+
+  /**
+   * The rectangular bounds of the edge. Used by the quadtree.
+   * @type {PIXI.Rectangle}
+   */
+  bounds;
+
+  /**
+   * The direction of effect for the edge.
+   * @type {WALL_DIRECTIONS}
+   */
+  direction;
+
+  /**
+   * A string used to uniquely identify this edge.
+   * @type {string}
+   */
+  id;
+
+  /**
+   * How this edge restricts light.
+   * @type {WALL_SENSE_TYPES}
+   */
+  light;
+
+  /**
+   * How this edge restricts movement.
+   * @type {WALL_SENSE_TYPES}
+   */
+  move;
+
+  /**
+   * How this edge restricts sight.
+   * @type {WALL_SENSE_TYPES}
+   */
+  sight;
+
+  /**
+   * How this edge restricts sound.
+   * @type {WALL_SENSE_TYPES}
+   */
+  sound;
+
+  /**
+   * Specialized threshold data for this edge.
+   * @type {WallThresholdData}
+   */
+  threshold;
+
+  /**
+   * Record other edges which this one intersects with.
+   * @type {{edge: Edge, intersection: LineIntersection}[]}
+   */
+  intersections = [];
+
+  /**
+   * A PolygonVertex instance.
+   * Used as part of ClockwiseSweepPolygon computation.
+   * @type {PolygonVertex}
+   */
+  vertexA;
+
+  /**
+   * A PolygonVertex instance.
+   * Used as part of ClockwiseSweepPolygon computation.
+   * @type {PolygonVertex}
+   */
+  vertexB;
+
+  /* -------------------------------------------- */
+
+  /**
+   * Is this edge limited for a particular type?
+   * @returns {boolean}
+   */
+  isLimited(type) {
+    return this[type] === CONST.WALL_SENSE_TYPES.LIMITED;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Create a copy of the Edge which can be safely mutated.
+   * @returns {Edge}
+   */
+  clone() {
+    const clone = new this.constructor(this.a, this.b, this);
+    clone.intersections = [...this.intersections];
+    clone.vertexA = this.vertexA;
+    clone.vertexB = this.vertexB;
+    return clone;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Get an intersection point between this Edge and another.
+   * @param {Edge} other
+   * @returns {LineIntersection|void}
+   */
+  getIntersection(other) {
+    if ( this === other ) return;
+    const {a: a0, b: b0} = this;
+    const {a: a1, b: b1} = other;
+
+    // Ignore edges which share an endpoint
+    if ( a0.equals(a1) || a0.equals(b1) || b0.equals(a1) || b0.equals(b1) ) return;
+
+    // Initial fast CCW test for intersection
+    if ( !foundry.utils.lineSegmentIntersects(a0, b0, a1, b1) ) return;
+
+    // Slower computation of intersection point
+    const i = foundry.utils.lineLineIntersection(a0, b0, a1, b1, {t1: true});
+    if ( !i ) return;  // Eliminates co-linear lines, theoretically should not be necessary but just in case
+    return i;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Test whether to apply a proximity threshold to this edge.
+   * If the proximity threshold is met, this edge excluded from perception calculations.
+   * @param {string} sourceType     Sense type for the source
+   * @param {Point} sourceOrigin    The origin or position of the source on the canvas
+   * @param {number} [externalRadius=0] The external radius of the source
+   * @returns {boolean}             True if the edge has a threshold greater than 0 for the source type,
+   *                                and the source type is within that distance.
+   */
+  applyThreshold(sourceType, sourceOrigin, externalRadius=0) {
+    const d = this.threshold?.[sourceType];
+    const t = this[sourceType];
+    if ( !d || (t < CONST.WALL_SENSE_TYPES.PROXIMITY) ) return false; // Threshold behavior does not apply
+    const proximity = t === CONST.WALL_SENSE_TYPES.PROXIMITY;
+    const pt = foundry.utils.closestPointToSegment(sourceOrigin, this.a, this.b);
+    const sourceDistance = Math.hypot(pt.x - sourceOrigin.x, pt.y - sourceOrigin.y);
+    return proximity ? Math.max(sourceDistance - externalRadius, 0) < d : (sourceDistance + externalRadius) > d;
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Determine the orientation of this Edge with respect to a reference point.
+   * @param {Point} point       Some reference point, relative to which orientation is determined
+   * @returns {number}          An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left,
+   *                            right, or collinear (both) with the Edge
+   */
+  orientPoint(point) {
+    const orientation = foundry.utils.orient2dFast(this.a, this.b, point);
+    if ( orientation === 0 ) return CONST.WALL_DIRECTIONS.BOTH;
+    return orientation < 0 ? CONST.WALL_DIRECTIONS.LEFT : CONST.WALL_DIRECTIONS.RIGHT;
+  }
+
+  /* -------------------------------------------- */
+  /*  Intersection Management                     */
+  /* -------------------------------------------- */
+
+  /**
+   * Identify intersections between a provided iterable of edges.
+   * @param {Iterable<Edge>} edges    An iterable of edges
+   */
+  static identifyEdgeIntersections(edges) {
+
+    // Sort edges by their north-west x value, breaking ties with the south-east x value
+    const sorted = [];
+    for ( const edge of edges ) {
+      edge.intersections.length = 0; // Clear prior intersections
+      sorted.push(edge);
+    }
+    sorted.sort((e1, e2) => (e1.nw.x - e2.nw.x) || (e1.se.x - e2.se.x));
+
+    // Iterate over all known edges, identifying intersections
+    const ln = sorted.length;
+    for ( let i=0; i<ln; i++ ) {
+      const e1 = sorted[i];
+      for ( let j=i+1; j<ln; j++ ) {
+        const e2 = sorted[j];
+        if ( e2.nw.x > e1.se.x ) break; // Segment e2 is entirely right of segment e1
+        e1.recordIntersections(e2);
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Record the intersections between two edges.
+   * @param {Edge} other          Another edge to test and record
+   */
+  recordIntersections(other) {
+    if ( other === this ) return;
+    const i = this.getIntersection(other);
+    if ( !i ) return;
+    this.intersections.push({edge: other, intersection: i});
+    other.intersections.push({edge: this, intersection: {x: i.x, y: i.y, t0: i.t1, t1: i.t0}});
+  }
+
+  /* -------------------------------------------- */
+
+  /**
+   * Remove intersections of this edge with all other edges.
+   */
+  removeIntersections() {
+    for ( const {edge: other} of this.intersections ) {
+      other.intersections.findSplice(e => e.edge === this);
+    }
+    this.intersections.length = 0;
+  }
+}