⬡ SWRegularPolygon Class Reference

/*
File:    swRegularPolygon.js
Date:    2026-02-28
Author:  klp + GitHub Copilot
App:     SketchWaveTNT2026-02-28-Stg6
Purpose: SWRegularPolygon — a regular n-sided polygon with optional rounded
         corners, breathing, and rotation animation.

  A regular polygon is defined by a center SWPoint, a circumradius (the distance
  from the center to any vertex), and a number of sides (>= 3).  Vertices are
  computed on the fly from these three values plus the current animation state —
  no stored vertex array is needed between frames.

  Two drawing modes are supported:
    sharp   (cornerRadius = 0) — uses beginShape / vertex / endShape(CLOSE)
    rounded (cornerRadius > 0) — uses curveVertex for a closed Catmull-Rom spline

  Breathing scales the circumradius uniformly via a single SWSinusoid (_scaleR).
  Rotation accumulates in _animRotDeg (degrees CCW).

  Dependencies: p5.js, SWColor, SWPoint, SWGrid, SWSinusoid
*/

console.log("[swRegularPolygon.js] SWRegularPolygon class loaded.");

class SWRegularPolygon {

    constructor(center, radius, numSides, fillColor, options = {}) {
        this.center       = center;
        this.radius       = radius;
        this.numSides     = Math.max(3, Math.round(numSides));
        this.fillColor    = fillColor;
        this.cornerRadius = options.cornerRadius  !== undefined ? options.cornerRadius  : 0;
        this.strokeColor  = options.strokeColor   || undefined;
        this.strokeWeight = options.strokeWeight  !== undefined ? options.strokeWeight  : 2;
        this.showCenter   = options.showCenter    !== undefined ? options.showCenter    : false;
        this.showVertices = options.showVertices  !== undefined ? options.showVertices  : false;
        this.rotation     = options.rotation      || 0;

        const cwt = this.strokeWeight > 0 ? this.strokeWeight : 4;
        const cc  = (this.strokeColor && this.strokeColor.col)
                        ? this.strokeColor
                        : (typeof swBlack !== 'undefined' ? swBlack : new SWColor(0, 0, 0, 100, "black"));
        this.center.strokeWeight = cwt;
        this.center.strokeColor  = cc;

        this._scaleR     = 1;
        this._animRotDeg = 0;
        this.originalRadius = radius;
        this.originalCenter = new SWPoint(center.x, center.y, undefined, cwt, cc);
    }

    get currentRadius() { return this.radius * this._scaleR; }
    get sideLength()    { return 2 * this.currentRadius * Math.sin(Math.PI / this.numSides); }
    get apothem()       { return this.currentRadius * Math.cos(Math.PI / this.numSides); }
    get area()          { const r = this.currentRadius; return 0.5 * this.numSides * r * r * Math.sin(2 * Math.PI / this.numSides); }
    get perimeter()     { return this.numSides * this.sideLength; }
    get interiorAngle() { return ((this.numSides - 2) * 180) / this.numSides; }
    get exteriorAngle() { return 360 / this.numSides; }

    _computeUserVertices() {
        const r = this.currentRadius;
        const totalRad  = (this.rotation + this._animRotDeg) * Math.PI / 180;
        const baseAngle = -Math.PI / 2;
        return Array.from({ length: this.numSides }, (_, i) => {
            const angle = baseAngle + totalRad + (2 * Math.PI * i / this.numSides);
            return { x: this.center.x + r * Math.cos(angle),
                     y: this.center.y + r * Math.sin(angle) };
        });
    }

    _applyFillStroke() {
        if (this.fillColor   && this.fillColor.col)   { fill(this.fillColor.col);   } else { noFill();   }
        if (this.strokeColor && this.strokeColor.col) {
            stroke(this.strokeColor.col); strokeWeight(this.strokeWeight);
        } else { noStroke(); }
    }

    _drawSharp(pts) {
        beginShape();
        for (const p of pts) vertex(p.x, p.y);
        endShape(CLOSE);
    }

    _drawRounded(pts) {
        const n = pts.length;
        beginShape();
        curveVertex(pts[n - 1].x, pts[n - 1].y);
        for (const p of pts) curveVertex(p.x, p.y);
        curveVertex(pts[0].x, pts[0].y);
        curveVertex(pts[Math.min(1, n - 1)].x, pts[Math.min(1, n - 1)].y);
        endShape();
    }

    draw() {
        const r = this.currentRadius;
        const totalRad = (this.rotation + this._animRotDeg) * Math.PI / 180;
        const pts = Array.from({ length: this.numSides }, (_, i) => {
            const angle = -Math.PI / 2 + totalRad + (2 * Math.PI * i / this.numSides);
            return { x: this.center.x + r * Math.cos(angle),
                     y: this.center.y + r * Math.sin(angle) };
        });
        this._applyFillStroke();
        if (this.cornerRadius > 0) this._drawRounded(pts); else this._drawSharp(pts);
        noStroke(); noFill(); strokeWeight(1);
        if (this.showCenter && this.center && this.center.draw) this.center.draw();
    }

    drawOnGrid(grid) {
        const pts = this._computeUserVertices().map(v => grid.userToScreen(v.x, v.y));
        this._applyFillStroke();
        if (this.cornerRadius > 0) this._drawRounded(pts); else this._drawSharp(pts);
        noStroke(); noFill(); strokeWeight(1);
        if (this.showVertices) {
            const dotFill = (this.strokeColor && this.strokeColor.col)
                                ? this.strokeColor.col : color(40, 100, 100);
            fill(dotFill); noStroke();
            for (const p of pts) ellipse(p.x, p.y, 8, 8);
            noFill();
        }
        if (this.showCenter && this.center && this.center.drawOnGrid) this.center.drawOnGrid(grid);
    }

    breathe(sinusoid, t) {
        this._scaleR = sinusoid ? Math.max(0.1, sinusoid.getValue(t)) : 1;
    }

    rotateAboutCenter(degPerSec, t) {
        this._animRotDeg = degPerSec * t;
    }

    transform({ sinusoid = null, t = 0, degPerSec = null } = {}) {
        this._scaleR     = sinusoid ? Math.max(0.1, sinusoid.getValue(t)) : 1;
        this._animRotDeg = degPerSec !== null ? degPerSec * t : 0;
    }

    reset() {
        this.radius      = this.originalRadius;
        this._scaleR     = 1;
        this._animRotDeg = 0;
        this.center.x    = this.originalCenter.x;
        this.center.y    = this.originalCenter.y;
    }

    getVerticesUserCoords() { return this._computeUserVertices(); }

    drawVerticesOnGrid(grid, dotSize = 8, dotColor = undefined) {
        const fillCol = (dotColor && dotColor.col) ? dotColor.col
                      : (this.strokeColor && this.strokeColor.col) ? this.strokeColor.col
                      : color(40, 100, 100);
        fill(fillCol); noStroke();
        for (const v of this._computeUserVertices()) {
            const s = grid.userToScreen(v.x, v.y);
            ellipse(s.x, s.y, dotSize, dotSize);
        }
        noFill();
    }

    centerContainsPoint(px, py, grid, tolerance = 12) {
        const { x: cx, y: cy } = grid.userToScreen(this.center.x, this.center.y);
        const dx = px - cx, dy = py - cy;
        return (dx * dx + dy * dy) <= tolerance * tolerance;
    }

    toString() {
        const totalDeg = this.rotation + this._animRotDeg;
        return `SWRegularPolygon(center: (${this.center.x.toFixed(2)}, ${this.center.y.toFixed(2)}), ` +
               `radius: ${this.radius.toFixed(2)}, sides: ${this.numSides}, ` +
               `sideLength: ${this.sideLength.toFixed(2)}, area: ${this.area.toFixed(2)}, ` +
               `rotation: ${totalDeg.toFixed(1)}\u00b0)`;
    }

}//end class SWRegularPolygon