★ SWStar Class Reference

/*
File:    swStar.js
Date:    2026-02-28
Author:  klp + GitHub Copilot
App:     SketchWaveTNT2026-02-28-Stg6
Purpose: SWStar — a regular n-pointed star with independently-breathing
         outer and inner radii, optional tip rounding, and rotation animation.

  Breathing design (mirrors SWRectangle's independent X/Y breathing):
    outerRadius × _scaleOuter — controls how far tips reach
    innerRadius × _scaleInner — controls how deep the valleys are

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

console.log("[swStar.js] SWStar class loaded.");

class SWStar {

    constructor(center, outerRadius, innerRadius, numPoints, fillColor, options = {}) {
        this.center      = center;
        this.outerRadius = outerRadius;
        this.innerRadius = innerRadius;
        this.numPoints   = Math.max(2, Math.round(numPoints));
        this.fillColor   = fillColor;

        this.tipRadius    = options.tipRadius    !== undefined ? options.tipRadius    : 0;
        this.strokeColor  = options.strokeColor  || undefined;
        this.strokeWeight = options.strokeWeight !== undefined ? options.strokeWeight : 2;
        this.showCenter   = options.showCenter   !== undefined ? options.showCenter   : false;
        this.showTips     = options.showTips     !== undefined ? options.showTips     : false;
        this.showInner    = options.showInner    !== undefined ? options.showInner    : 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._scaleOuter = 1;
        this._scaleInner = 1;
        this._animRotDeg = 0;
        this.originalOuterRadius = outerRadius;
        this.originalInnerRadius = innerRadius;
        this.originalCenter = new SWPoint(center.x, center.y, undefined, cwt, cc);
    }

    get currentOuterRadius() { return this.outerRadius * this._scaleOuter; }
    get currentInnerRadius() { return this.innerRadius * this._scaleInner; }
    get tipLength()          { return this.currentOuterRadius - this.currentInnerRadius; }

    get area() {
        const verts = this._computeUserVertices();
        const n2    = verts.length;
        let   sum   = 0;
        for (let i = 0; i < n2; i++) {
            const j = (i + 1) % n2;
            sum += verts[i].x * verts[j].y - verts[j].x * verts[i].y;
        }
        return Math.abs(sum) / 2;
    }

    get perimeter() {
        const R   = this.currentOuterRadius;
        const r   = this.currentInnerRadius;
        const arm = Math.sqrt(R*R + r*r - 2*R*r*Math.cos(Math.PI / this.numPoints));
        return 2 * this.numPoints * arm;
    }

    _computeUserVertices() {
        const Ro       = this.currentOuterRadius;
        const Ri       = this.currentInnerRadius;
        const totalRad = (this.rotation + this._animRotDeg) * Math.PI / 180;
        const base     = -Math.PI / 2;
        const n        = this.numPoints;
        const pts      = [];
        for (let i = 0; i < n; i++) {
            const outerAngle = base + totalRad + (2 * Math.PI * i / n);
            const innerAngle = outerAngle + (Math.PI / n);
            pts.push({ x: this.center.x + Ro * Math.cos(outerAngle),
                       y: this.center.y + Ro * Math.sin(outerAngle), isOuter: true });
            pts.push({ x: this.center.x + Ri * Math.cos(innerAngle),
                       y: this.center.y + Ri * Math.sin(innerAngle), isOuter: false });
        }
        return pts;
    }

    _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(); }
    }

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

    _drawRoundedTips(pts, pixelRadius) {
        const n2 = pts.length;
        beginShape();
        for (let i = 0; i < n2; i++) {
            const curr = pts[i];
            if (!curr.isOuter) {
                vertex(curr.x, curr.y);
            } else {
                const prev = pts[(i - 1 + n2) % n2];
                const next = pts[(i + 1) % n2];
                const dx1 = prev.x - curr.x, dy1 = prev.y - curr.y;
                const len1 = Math.sqrt(dx1*dx1 + dy1*dy1);
                const dx2 = next.x - curr.x, dy2 = next.y - curr.y;
                const len2 = Math.sqrt(dx2*dx2 + dy2*dy2);
                const r1 = Math.min(pixelRadius, len1 * 0.45);
                const r2 = Math.min(pixelRadius, len2 * 0.45);
                const p1 = { x: curr.x + (dx1/len1)*r1, y: curr.y + (dy1/len1)*r1 };
                const p2 = { x: curr.x + (dx2/len2)*r2, y: curr.y + (dy2/len2)*r2 };
                vertex(p1.x, p1.y);
                quadraticVertex(curr.x, curr.y, p2.x, p2.y);
            }
        }
        endShape(CLOSE);
    }

    draw() {
        const pts = this._computeUserVertices();
        this._applyFillStroke();
        if (this.tipRadius > 0) this._drawRoundedTips(pts, this.tipRadius);
        else                     this._drawStar(pts);
        noStroke(); noFill(); strokeWeight(1);
        if (this.showCenter && this.center && this.center.draw) this.center.draw();
    }

    drawOnGrid(grid) {
        const userVerts = this._computeUserVertices();
        const pts = userVerts.map(v => ({
            x: grid.userToScreen(v.x, v.y).x,
            y: grid.userToScreen(v.x, v.y).y,
            isOuter: v.isOuter
        }));
        this._applyFillStroke();
        if (this.tipRadius > 0) this._drawRoundedTips(pts, this.tipRadius * grid.xScale);
        else                     this._drawStar(pts);
        noStroke(); noFill(); strokeWeight(1);
        if (this.showTips || this.showInner) {
            const outerFill = (this.strokeColor && this.strokeColor.col)
                                  ? this.strokeColor.col : color(40, 100, 100);
            const innerFill = color(50, 80, 100);
            noStroke();
            for (const p of pts) {
                if (p.isOuter && this.showTips)  { fill(outerFill); ellipse(p.x, p.y, 9, 9); }
                else if (!p.isOuter && this.showInner) { fill(innerFill); ellipse(p.x, p.y, 7, 7); }
            }
            noFill();
        }
        if (this.showCenter && this.center && this.center.drawOnGrid) this.center.drawOnGrid(grid);
    }

    breathe(sinusoidOuter, sinusoidInner, t) {
        this._scaleOuter = sinusoidOuter ? Math.max(0.1, sinusoidOuter.getValue(t)) : 1;
        this._scaleInner = sinusoidInner ? Math.max(0.1, sinusoidInner.getValue(t)) : 1;
    }

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

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

    reset() {
        this.outerRadius = this.originalOuterRadius;
        this.innerRadius = this.originalInnerRadius;
        this._scaleOuter = 1;
        this._scaleInner = 1;
        this._animRotDeg = 0;
        this.center.x    = this.originalCenter.x;
        this.center.y    = this.originalCenter.y;
    }

    getOuterVerticesUserCoords() { return this._computeUserVertices().filter(v => v.isOuter); }
    getInnerVerticesUserCoords() { return this._computeUserVertices().filter(v => !v.isOuter); }

    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 `SWStar(center: (${this.center.x.toFixed(2)}, ${this.center.y.toFixed(2)}), ` +
               `outerR: ${this.currentOuterRadius.toFixed(2)}, ` +
               `innerR: ${this.currentInnerRadius.toFixed(2)}, ` +
               `points: ${this.numPoints}, area: ${this.area.toFixed(2)}, ` +
               `rotation: ${totalDeg.toFixed(1)}\u00b0)`;
    }

}//end class SWStar