BuildingPathState.ts

import { IPathMakerState } from "./IPathMakerState";
import { UI } from "../UI";
import { Conversions } from "../Conversions";
import { PathBuilder } from "../PathBuilder";
import { LensInitializer } from "../LensInitializer";
import { PlayerPaceCalculator } from "../PlayerPaceCalculator";
import { PaintOnFloorBehavior } from "../PathPrevewBehaviors/PaintOnFloorBehavior";
import { LookAtFloorBehavior } from "../PathPrevewBehaviors/LookAtFloorBehavior";
import { LinearAlgebra } from "../Helpers/LinearAlgebra";
import { HermiteSpline } from "../Helpers/HermiteSpline";
import { GetVectorsFromQuaternion } from "../Helpers/GetVectorsFromQuaternion";
import { EasingFunctions } from "../Helpers/EasingFunctions";
import { ResampleCurve } from "../Helpers/ResampleCurve";
import { Colors } from "../Helpers/Colors";
import { PathmakingPlayerFeedback } from "../PathmakingPlayerFeedback";
import { FinishSmoothPath } from "../Helpers/FinishSmoothPath";
import { LineController } from "../LineController";

export class BuildingPathState implements IPathMakerState {

    constructor(
        protected ownerScript: ScriptComponent,
        protected cameraTransform: Transform,
        protected cameraOffsetTransform: Transform,
        protected pathRmv: RenderMeshVisual,
        protected pathDistanceText: Text,
        protected startPosition: vec3,
        protected startRotation: quat,
        protected startObject: SceneObject,
        protected ui: UI,
        protected paceCalculator: PlayerPaceCalculator,
        protected pathmakingPlayerFeedback: PathmakingPlayerFeedback,
        protected bigMoveDistanceThreshold: number,
        protected hermiteResolution: number,
        protected resampleResoluton: number,
        protected onFinishAsSprint: (startPosition: vec3,
            startRotation: quat,
            startObject: SceneObject,
            pathPoints: vec3[],
            lastVisualPoints: vec3[]) => void,
        protected onFinishAsLoop: (startPosition: vec3,
            startRotation: quat,
            startObject: SceneObject,
            splinePoints: { position: vec3, rotation: quat}[]) => void) {
        this.startTransform = this.startObject.getTransform();
    }

    protected previewZOffset = 300;
    protected static distanceToMakeLoopXZ = 200;
    protected static distanceToMakeLoopY = 50;
    protected startTransform: Transform;

    // To clear on stop()
    protected finishClickedRemover: (() => void) | undefined;
    protected loopClickedRemover: (() => void) | undefined;
    protected resetClickedRemover: (() => void) | undefined;
    protected updateEvent: SceneEvent | undefined;
    protected trailHeadTransform: Transform | undefined;

    // To clear on start()
    protected prevCameraPositionForVisual: vec3 | undefined;
    protected prevCameraPositionForPath: vec3 | undefined;
    protected prevTrailHeadPos: vec3 | undefined;
    protected prevTrailHeadRot: quat | undefined;
    protected previewLookPoints: vec3[] = [];
    protected paintPts: vec3[] = [];
    protected lookPts: vec3[] = [];
    protected previewPoints: vec3[] = [];
    protected pathPoints: vec3[] = [];
    protected pathLength: number = 0;
    protected visualTargetCrossedStartLine = false;
    protected cameraCrossedStartLine = false;
    protected cameraMovedFromStartLine = false;

    protected isUiShown: boolean = false;
    protected isLoop: boolean = false;

    protected paintPreview: PaintOnFloorBehavior;
    protected lookPreview: LookAtFloorBehavior;

    private smallMoveDistanceThreshold = 3;

    start() {
        this.visualTargetCrossedStartLine = false;
        this.prevCameraPositionForVisual = this.startPosition.uniformScale(1);
        this.prevCameraPositionForPath = LensInitializer.getInstance().getPlayerGroundPos();
        this.prevTrailHeadPos = undefined;
        this.prevTrailHeadRot = undefined;
        this.previewLookPoints = [];
        this.paintPts = [];
        this.lookPts = [];
        this.previewPoints = [];
        this.pathPoints = [];
        this.pathLength = 0;
        this.isLoop = false;
        this.isUiShown = false;
        const lineCtrl = this.startObject.getComponent(LineController.getTypeName());
        if (!lineCtrl) {
            throw new Error(`StartFinishLine cannot be found on object with name ${this.startObject.name}`);
        }
        lineCtrl.setRealVisual();
        this.ui.hideUi();
        this.ui.initLoopUi(this.startTransform);

        this.finishClickedRemover = this.ui.finishPathClicked.add(() => {
            this.onFinishAsSprint(this.startPosition, this.startRotation, this.startObject, this.pathPoints, this.previewPoints);
        });
        this.loopClickedRemover = this.ui.loopPathClicked.add(() => {
            let smoothPoints = FinishSmoothPath.finishSmoothPath(
                this.pathPoints,
                this.startTransform,
                this.cameraTransform,
                this.bigMoveDistanceThreshold,
                this.hermiteResolution,
                this.resampleResoluton
            );
            this.pathPoints = smoothPoints.pathPoints;
            const splinePoints = smoothPoints.splinePoints;
    
            this.pathRmv.enabled = false;
            this.onFinishAsLoop(
                this.startPosition,
                this.startRotation,
                this.startObject,
                splinePoints)
        })

        this.addStartPointToPath();
        this.addStartPointToVisual();
        this.paintPreview = new PaintOnFloorBehavior(
            this.previewZOffset,
            this.cameraTransform
        )
        this.lookPreview = new LookAtFloorBehavior(
            this.previewZOffset,
            this.cameraTransform
        )
        this.paintPreview.start(this.displaceForward(this.prevCameraPositionForPath));
        this.lookPreview.start();
        this.paceCalculator.start(this.prevCameraPositionForPath);

        this.resetClickedRemover = this.ui.resetPathClicked.add(() => {
            this.reset();
        })

        this.pathmakingPlayerFeedback.start([this.startPosition.add(this.startTransform.forward.uniformScale(50)), this.startPosition]);
        this.updateEvent = this.ownerScript.createEvent("UpdateEvent");
        this.updateEvent.bind(() => {
            this.onUpdate();
        });
    }

    reset() {
        this.pathRmv.enabled = false;
        this.startObject.destroy();
        this.pathmakingPlayerFeedback.stop();
    }

    stop() {
        this.finishClickedRemover?.();
        this.finishClickedRemover = undefined;
        this.loopClickedRemover?.();
        this.loopClickedRemover = undefined;
        this.resetClickedRemover?.();
        this.resetClickedRemover = undefined;
        if (this.updateEvent) {
            this.ownerScript.removeEvent(this.updateEvent);
            this.updateEvent = undefined;
        }
        if (this.trailHeadTransform) {
            this.trailHeadTransform.getSceneObject().destroy();
            this.trailHeadTransform = undefined;
        }
        this.paintPreview.stop();
        this.lookPreview.stop();
        this.pathmakingPlayerFeedback.stop();
    }

    private onUpdate() {
        if (getDeltaTime() < .00000000001) {
            // we're in a capture loop
            return;
        }

        // Check pace
        let nPos = LensInitializer.getInstance().getPlayerGroundPos();
        let stats = this.paceCalculator.getPace(nPos);
        if (stats.pace < 13 && this.pathPoints.length > 4) {
            this.ensureUiShown();
        } else {
            this.ensureUiHidden();
        }

        // Make the high density visual ahead of us
        let smallMoved = nPos.sub(this.prevCameraPositionForVisual);
        let smallDistanceMoved = smallMoved.length;
        let nPosVisual = this.displaceForward(nPos);

        this.setPreviewPoints(nPos, nPosVisual);

        if (smallDistanceMoved > this.smallMoveDistanceThreshold
            && this.checkVisualTargetCrossedStartLine(nPosVisual)) {
            // Make flat and vertical distance checks for loop viability
            let toStart = this.startPosition.sub(nPosVisual);
            let toStartY = toStart.y;
            toStart.y = 0;
            let toStartXZ = toStart.length;

            if (toStartXZ < BuildingPathState.distanceToMakeLoopXZ
                && Math.abs(toStartY) < BuildingPathState.distanceToMakeLoopY
            ) {
                if (this.pathPoints.length > 4) {
                    this.ensureLoopUiShown();
                } else {
                    this.ensureLoopUiHidden();
                }
            } else {
                this.ensureLoopUiHidden();
            }

            // Update old positions
            this.prevCameraPositionForVisual = nPos;
        }

        // Make the low density path behind us
        // Because the start transform is the first point, start drawing once we've moved from start
        let bigMoved = nPos.sub(this.prevCameraPositionForPath);
        let bigDistanceMoved = bigMoved.length;

        if (bigDistanceMoved > this.bigMoveDistanceThreshold
            && this.checkCameraCrossedStartLine(nPos, 0)
            && this.checkCameraMovedFromStartLine(nPos, this.bigMoveDistanceThreshold)) {

            // Update our path distance
            this.pathLength += bigDistanceMoved;
            let pathDistFt = Conversions.cmToFeet(this.pathLength);
            this.pathDistanceText.text = pathDistFt.toFixed(1) + "'";

            // Push a subset of points to the path array
            this.pathPoints.push(nPos);

            // Early on, cleanup the start points to curve smoothly from the center of the start line
            if (this.pathPoints.length == 7) {
                this.cleanupStartPointsToPath();
            }

            if (this.pathPoints.length > 2) {
                this.pathRmv.enabled = true;
                this.pathRmv.mesh = PathBuilder.buildFromPoints(this.pathPoints, 60);
            }

            this.prevCameraPositionForPath = nPos;
        }
    }

    setPreviewPoints(nPos: vec3, nPosVisual: vec3) {
        // To prevent visual from drawing from start back to player,
        // While cam has not yet passed start,
        // Ensure visual is really passed start, otherwise don't update
        let updatePreviewPoints = this.checkCameraCrossedStartLine(nPos, 0) ? true : this.checkCrossedStart(nPosVisual, 0);
        if (!updatePreviewPoints) {
            return;
        }

        // If camera has not crossed start, but visual has
        // Adjust object count to our distance from start to visual 
        let objCount = 6;
        if (!this.checkCameraCrossedStartLine(nPos, 0) && this.checkCrossedStart(nPosVisual, 0)) {
            let distancePerObj = this.previewZOffset / objCount;
            let availableDistance = nPosVisual.distance(this.startPosition);
            objCount = Math.floor(availableDistance / distancePerObj);
            objCount = Math.max(objCount, 2);
        }

        let startPos = this.checkCameraCrossedStartLine(nPos, 0) ? nPos : this.startPosition;

        let lookBehavior = this.lookPreview.getBehavior();
        if (lookBehavior && lookBehavior.pos && lookBehavior.rot && lookBehavior.vel) {
            this.lookPts = this.drawCurveFromBehavior(startPos, lookBehavior);
        }

        let paintBehavior = this.paintPreview.getBehavior(nPosVisual);
        if (paintBehavior) {
            if (paintBehavior.pos) {
                this.paintPts.unshift(paintBehavior.pos);
                // Pop the points that are behind the camera
                for (let i = this.paintPts.length - 1; i >= 0; i--) {
                    let camToPt = this.paintPts[i].sub(nPos).normalize();
                    let camFwd = LinearAlgebra.flatNor(this.cameraTransform.back);

                    // Snap all points to our current ground
                    this.paintPts[i].y = nPos.y;

                    let dot = camToPt.dot(camFwd);
                    if (dot < 0) {
                        this.paintPts.pop();
                    }
                }
            }
        }

        this.previewPoints = [];
        let size = Math.min(this.lookPts.length, this.paintPts.length);
        if (size > 2) {
            // Array goes from head (index 0) to start position (index size-1)
            for (let i = 0; i < size; i++) {
                let t = 1 - i / (size - 1);
                let paintWeight = EasingFunctions.easeOutQuart(t);
                let lookWeight = 1 - paintWeight;

                let pos = this.lookPts[i].uniformScale(lookWeight).add(this.paintPts[i].uniformScale(paintWeight));
                this.previewPoints.push(pos);
            }

            // Re-emphasize start position prior to resampling
            this.previewPoints.push(startPos);

            // Resample
            this.previewPoints = ResampleCurve.resampleCurve(this.previewPoints, objCount);

            this.pathmakingPlayerFeedback.update(this.previewPoints);
        }
    }

    // This draws a curve from the look point to us
    drawCurveFromBehavior(startPos: vec3, behavior: { pos: vec3, rot: quat, vel: number }) {
        let posA = behavior.pos;
        let fwdA = LinearAlgebra.flatNor(GetVectorsFromQuaternion.getInstance().getVectorsFromQuaternion(behavior.rot).forward);

        let posB = startPos;
        let fwdB = LinearAlgebra.flatNor(this.cameraTransform.forward);

        let dir = posA.sub(posB);
        let mag = dir.length;

        let resolution = Math.floor(mag / 15);
        let curveScale = Math.max(50, Math.min(resolution * 50, behavior.vel / 2));

        let curvePoints: vec3[] = HermiteSpline.interpolateHermite(
            posA,
            fwdA,
            posB,
            fwdB,
            resolution,
            curveScale
        )

        return curvePoints;
    }

    private cleanupStartPointsToPath() {
        this.pathPoints = HermiteSpline.drawCurve(this.startPosition, 
            this.startTransform.forward, 
            this.pathPoints[this.pathPoints.length-1], 
            LinearAlgebra.flatNor(this.cameraTransform.back),
            this.hermiteResolution 
        );
    }

    private addStartPointToPath() {
        this.pathPoints.push(this.startPosition.uniformScale(1));
    }

    private addStartPointToVisual() {
        this.previewPoints.unshift(this.startPosition);
    }

    private displaceForward(cameraPosOnSurface: vec3) {
        return cameraPosOnSurface.add(LinearAlgebra.flatNor(this.cameraTransform.back).uniformScale(this.previewZOffset));
    }

    private checkCameraMovedFromStartLine(cameraPosOnSurface: vec3, distance: number) {
        if (this.cameraMovedFromStartLine) {
            return true;
        }
        this.cameraMovedFromStartLine = this.startPosition.distance(cameraPosOnSurface) > distance;
        return this.cameraMovedFromStartLine;
    }

    private checkCameraCrossedStartLine(cameraPosOnSurface: vec3, offset: number) {
        if (this.cameraCrossedStartLine) {
            return true;
        }
        this.cameraCrossedStartLine = this.checkCrossedStart(cameraPosOnSurface, offset);
        return this.cameraCrossedStartLine;
    }

    private checkCrossedStart(pos: vec3, offset: number) {
        let startLineForward = this.startTransform.forward;
        let offsetStartPos = this.startPosition.add(startLineForward.uniformScale(offset));
        let cameraPosToStart = pos.sub(offsetStartPos);
        return startLineForward.angleTo(cameraPosToStart) <= Math.PI / 2;
    }

    private checkBehindStart(pos: vec3, offset: number) {
        let startLineForward = this.startTransform.forward;
        let offsetStartPos = this.startPosition.sub(startLineForward.uniformScale(offset));
        let cameraPosToStart = pos.sub(offsetStartPos);
        return startLineForward.angleTo(cameraPosToStart) > Math.PI / 2;
    }

    private checkVisualTargetCrossedStartLine(targetPosOnSurface: vec3) {
        if (this.visualTargetCrossedStartLine) {
            return true;
        }
        this.visualTargetCrossedStartLine = this.checkCrossedStart(targetPosOnSurface, 0);
        return this.visualTargetCrossedStartLine;
    }

    private ensureUiShown() {
        if (this.isUiShown) {
            return;
        }
        this.isUiShown = true;
        this.ui.showDuringPathCreationUi();
    }

    private ensureUiHidden() {
        if (!this.isUiShown) {
            return;
        }
        this.isUiShown = false;
        this.ui.hideUi();
    }

    private ensureLoopUiShown() {
        if (this.isLoop) {
            return;
        }
        this.isLoop = true;
        this.ui.showLoopUi();
    }

    private ensureLoopUiHidden() {
        if (!this.isLoop) {
            return;
        }
        this.isLoop = false;
        this.ui.hideLoopUi();
    }
}