fluidcad 0.0.2

package/lib/dist/features/2d/connect.js

@@ -0,0 +1,105 @@
+import { Edge } from "../../common/edge.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { EdgeQuery } from "../../oc/edge-query.js";
+import { EdgeOps } from "../../oc/edge-ops.js";
+import { WireOps } from "../../oc/wire-ops.js";
+import { Geometry } from "../../oc/geometry.js";
+export class Connect extends GeometrySceneObject {
+    mode;
+    constructor(mode = 'line') {
+        super();
+        this.mode = mode;
+    }
+    build() {
+        const siblings = this.sketch.getPreviousSiblings(this);
+        const edges = [];
+        for (const obj of siblings) {
+            const shapes = obj.getShapes().filter(s => s instanceof Edge);
+            for (const edge of shapes) {
+                if (EdgeQuery.isEdgeClosedCurve(edge)) {
+                    continue;
+                }
+                edges.push(edge);
+                obj.removeShape(edge, this);
+            }
+        }
+        // Unify edge orientations to match the first edge's winding direction.
+        const normal = this.sketch.getPlane().normal;
+        const windingSigns = [];
+        for (const edge of edges) {
+            const start = EdgeOps.getVertexPoint(EdgeOps.getFirstVertex(edge));
+            const end = EdgeOps.getVertexPoint(EdgeOps.getLastVertex(edge));
+            const mid = EdgeOps.getEdgeMidPoint(edge);
+            const toMid = start.vectorTo(mid);
+            const toEnd = start.vectorTo(end);
+            windingSigns.push(toMid.cross(toEnd).dot(normal));
+        }
+        // Reverse edges whose winding doesn't match the first edge.
+        const refSign = windingSigns[0];
+        for (let i = 1; i < edges.length; i++) {
+            if ((windingSigns[i] > 0) !== (refSign > 0)) {
+                edges[i] = EdgeOps.reverseEdge(edges[i]);
+            }
+        }
+        const useArc = this.mode === 'arc';
+        const makeBridgeEdge = (curve, v1, v2) => {
+            return EdgeOps.makeEdgeFromCurveAndVertices(curve, v1, v2);
+        };
+        const makeBridge = (edge1, edge2) => {
+            const v1 = EdgeOps.getLastVertex(edge1);
+            const v2 = EdgeOps.getFirstVertex(edge2);
+            const startPt = EdgeOps.getVertexPoint(v1);
+            const endPt = EdgeOps.getVertexPoint(v2);
+            if (useArc) {
+                const edgeTangent = EdgeOps.getEdgeTangentAtEnd(edge1);
+                const bridgeDir = startPt.vectorTo(endPt);
+                // If tangent is nearly collinear with the bridge direction, an arc
+                // degenerates into a semicircle. Fall back to a straight line.
+                if (edgeTangent.isParallelTo(bridgeDir)) {
+                    return makeBridgeEdge(Geometry.makeSegment(startPt, endPt), v1, v2);
+                }
+                // Negate tangent only if it points away from the endpoint (would create looping arc).
+                const tangent = edgeTangent.dot(bridgeDir) < 0 ? edgeTangent.negate() : edgeTangent;
+                return makeBridgeEdge(Geometry.makeArcFromTangent(startPt, endPt, tangent), v1, v2);
+            }
+            else {
+                return makeBridgeEdge(Geometry.makeSegment(startPt, endPt), v1, v2);
+            }
+        };
+        // Build wire: edge[0], bridge, edge[1], bridge, edge[2], ..., closing bridge
+        const wireEdges = [];
+        wireEdges.push(edges[0]);
+        for (let i = 1; i < edges.length; i++) {
+            wireEdges.push(makeBridge(edges[i - 1], edges[i]));
+            wireEdges.push(edges[i]);
+        }
+        // Close the loop: bridge from last edge back to first
+        wireEdges.push(makeBridge(edges[edges.length - 1], edges[0]));
+        console.log('Constructed wire edges:', wireEdges.length);
+        let wire = WireOps.buildWire(wireEdges);
+        // Ensure the wire is CCW relative to the sketch plane normal.
+        if (wire.isCW(this.sketch.getPlane().normal)) {
+            console.log('Reversing wire to ensure CCW orientation');
+            wire = WireOps.reverseWire(wire);
+            console.log('Wire reversed', !wire.isCW(this.sketch.getPlane().normal));
+        }
+        this.addShape(wire);
+    }
+    compareTo(other) {
+        if (!(other instanceof Connect)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.mode === other.mode;
+    }
+    getType() {
+        return 'connect';
+    }
+    serialize() {
+        return {
+            mode: this.mode
+        };
+    }
+}

package/lib/dist/features/2d/constraints/constraint.d.ts

@@ -0,0 +1,11 @@
+import { GccEnt_Position, gp_Pln } from "occjs-wrapper";
+import { Comparable, SceneObject } from "../common/scene-object.js";
+export type ConstraintQualifier = 'any' | 'outside' | 'enclosed' | 'enclosing';
+export declare class GeometricConstraint implements Comparable<GeometricConstraint> {
+    private object;
+    private qualifier;
+    constructor(object: SceneObject, qualifier: ConstraintQualifier);
+    getQualified(plane: gp_Pln): any;
+    getQualifier(qualifier: ConstraintQualifier): GccEnt_Position;
+    compareTo(other: GeometricConstraint): any;
+}

package/lib/dist/features/2d/constraints/constraint.js

@@ -0,0 +1,49 @@
+export class GeometricConstraint {
+    object;
+    qualifier;
+    constructor(object, qualifier) {
+        this.object = object;
+        this.qualifier = qualifier;
+    }
+    getQualified(plane) {
+        const oc = getOC();
+        const shape = this.object.getShapes()[0];
+        const adaptor = new oc.BRepAdaptor_Curve(shape.getShape());
+        const type = adaptor.GetType();
+        if (type === oc.GeomAbs_CurveType.GeomAbs_Circle) {
+            const circle = adaptor.Circle();
+            adaptor.delete();
+            const c1 = Geometry.get2dCircleRaw(plane, circle);
+            circle.delete();
+            const qualifier = this.getQualifier(this.qualifier);
+            const qualified = new oc.GccEnt_QualifiedCirc(c1, qualifier);
+            return qualified;
+        }
+        else if (type === oc.GeomAbs_CurveType.GeomAbs_Line) {
+            const line = adaptor.Line();
+            adaptor.delete();
+            const l1 = Geometry.get2dLineRaw(plane, line);
+            line.delete();
+            const qualifier = this.getQualifier(this.qualifier);
+            const qualified = new oc.GccEnt_QualifiedLin(l1, qualifier);
+            return qualified;
+        }
+        throw new Error('Unsupported shape type for constraint: ' + type);
+    }
+    getQualifier(qualifier) {
+        const oc = getOC();
+        switch (qualifier) {
+            case 'any':
+                return oc.GccEnt_Position.GccEnt_unqualified;
+            case 'enclosed':
+                return oc.GccEnt_Position.GccEnt_enclosed;
+            case 'enclosing':
+                return oc.GccEnt_Position.GccEnt_enclosing;
+            case 'outside':
+                return oc.GccEnt_Position.GccEnt_outside;
+        }
+    }
+    compareTo(other) {
+        return this.qualifier === other.qualifier && this.object.compareTo(other.object);
+    }
+}

package/lib/dist/features/2d/constraints/geometry-qualifier.d.ts

@@ -0,0 +1,6 @@
+import { ISceneObject } from "../../../core/interfaces.js";
+import { QualifiedSceneObject } from "./qualified-geometry.js";
+export declare function outside(sceneObject: ISceneObject): QualifiedSceneObject;
+export declare function enclosed(sceneObject: ISceneObject): QualifiedSceneObject;
+export declare function enclosing(sceneObject: ISceneObject): QualifiedSceneObject;
+export declare function unqualified(sceneObject: ISceneObject): QualifiedSceneObject;

package/lib/dist/features/2d/constraints/geometry-qualifier.js

@@ -0,0 +1,13 @@
+import { QualifiedSceneObject } from "./qualified-geometry.js";
+export function outside(sceneObject) {
+    return new QualifiedSceneObject(sceneObject, 'outside');
+}
+export function enclosed(sceneObject) {
+    return new QualifiedSceneObject(sceneObject, 'enclosed');
+}
+export function enclosing(sceneObject) {
+    return new QualifiedSceneObject(sceneObject, 'enclosing');
+}
+export function unqualified(sceneObject) {
+    return new QualifiedSceneObject(sceneObject, 'unqualified');
+}

package/lib/dist/features/2d/constraints/outside.d.ts

@@ -0,0 +1,3 @@
+import { SceneObject } from "../../../common/scene-object.js";
+import { QualifiedGeometry } from "./qualified-geometry.js";
+export declare function outside(sceneObject: SceneObject): QualifiedGeometry;

package/lib/dist/features/2d/constraints/outside.js

@@ -0,0 +1,4 @@
+import { QualifiedGeometry } from "./qualified-geometry.js";
+export function outside(sceneObject) {
+    return new QualifiedGeometry(sceneObject, 'outside');
+}

package/lib/dist/features/2d/constraints/qualified-geometry.d.ts

@@ -0,0 +1,16 @@
+import { Comparable, SceneObject } from "../../../common/scene-object.js";
+import { Shape } from "../../../common/shape.js";
+export type ConstraintQualifier = 'unqualified' | 'outside' | 'enclosed' | 'enclosing';
+export declare class QualifiedSceneObject implements Comparable<QualifiedSceneObject> {
+    object: SceneObject;
+    qualifier: ConstraintQualifier;
+    constructor(object: SceneObject, qualifier: ConstraintQualifier);
+    static from(arg: SceneObject | QualifiedSceneObject): QualifiedSceneObject;
+    compareTo(other: QualifiedSceneObject): boolean;
+    toQualifiedShape(): QualifiedShape;
+}
+export declare class QualifiedShape {
+    shape: Shape;
+    qualifier: ConstraintQualifier;
+    constructor(shape: Shape, qualifier: ConstraintQualifier);
+}

package/lib/dist/features/2d/constraints/qualified-geometry.js

@@ -0,0 +1,36 @@
+import { Wire } from "../../../common/wire.js";
+export class QualifiedSceneObject {
+    object;
+    qualifier;
+    constructor(object, qualifier) {
+        this.object = object;
+        this.qualifier = qualifier;
+    }
+    static from(arg) {
+        if (arg instanceof QualifiedSceneObject) {
+            return arg;
+        }
+        return new QualifiedSceneObject(arg, 'unqualified');
+    }
+    compareTo(other) {
+        return this.qualifier === other.qualifier && this.object.compareTo(other.object);
+    }
+    toQualifiedShape() {
+        let shape = this.object.getShapes({ excludeGuide: false })[0];
+        if (!shape) {
+            throw new Error('At least one shape is required for the tangent line constraint');
+        }
+        if (shape instanceof Wire) {
+            shape = shape.getEdges()[0];
+        }
+        return new QualifiedShape(shape, this.qualifier);
+    }
+}
+export class QualifiedShape {
+    shape;
+    qualifier;
+    constructor(shape, qualifier) {
+        this.shape = shape;
+        this.qualifier = qualifier;
+    }
+}

package/lib/dist/features/2d/extrudable-base.d.ts

@@ -0,0 +1,15 @@
+import { Edge } from "../../common/edge.js";
+import { Wire } from "../../common/wire.js";
+import { Extrudable } from "../../helpers/types.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { Plane } from "../../math/plane.js";
+import { IExtrudableGeometry } from "../../core/interfaces.js";
+export declare abstract class ExtrudableGeometryBase extends GeometrySceneObject implements Extrudable, IExtrudableGeometry {
+    protected targetPlane?: PlaneObjectBase;
+    constructor(targetPlane?: PlaneObjectBase);
+    isExtrudable(): boolean;
+    getGeometries(): Edge[];
+    getGeometriesWithOwner(): Map<Wire | Edge, GeometrySceneObject>;
+    getPlane(): Plane;
+}

package/lib/dist/features/2d/extrudable-base.js

@@ -0,0 +1,27 @@
+import { Edge } from "../../common/edge.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class ExtrudableGeometryBase extends GeometrySceneObject {
+    targetPlane;
+    constructor(targetPlane) {
+        super();
+        this.targetPlane = targetPlane;
+    }
+    isExtrudable() {
+        return true;
+    }
+    getGeometries() {
+        return this.getShapes();
+    }
+    getGeometriesWithOwner() {
+        const geometries = new Map();
+        for (const shape of this.getShapes()) {
+            if (shape instanceof Edge) {
+                geometries.set(shape, this);
+            }
+        }
+        return geometries;
+    }
+    getPlane() {
+        return this.targetPlane ? this.targetPlane.getPlane() : this.sketch.getPlane();
+    }
+}

package/lib/dist/features/2d/geometry.d.ts

@@ -0,0 +1,20 @@
+import { Point2D } from "../../math/point.js";
+import { Sketch } from "./sketch.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { Edge } from "../../common/edge.js";
+import { Plane } from "../../math/plane.js";
+import { IGeometry } from "../../core/interfaces.js";
+export type GeometryOrientation = "cw" | "ccw";
+export declare abstract class GeometrySceneObject extends SceneObject implements IGeometry {
+    constructor();
+    get sketch(): Sketch;
+    protected getCurrentPosition(): Point2D;
+    protected setCurrentPosition(point: Point2D): void;
+    protected setTangent(point: Point2D): void;
+    protected applyEdgeResults(plane: Plane, edges: Edge[]): void;
+    getTangent(): Point2D;
+    start(): LazyVertex;
+    end(): LazyVertex;
+    tangent(): LazyVertex;
+}

package/lib/dist/features/2d/geometry.js

@@ -0,0 +1,77 @@
+import { Sketch } from "./sketch.js";
+import { SceneObject } from "../../common/scene-object.js";
+import { LazyVertex } from "../lazy-vertex.js";
+import { Vertex } from "../../common/vertex.js";
+export class GeometrySceneObject extends SceneObject {
+    constructor() {
+        super();
+    }
+    get sketch() {
+        let parent = this.getParent();
+        while (parent && !(parent instanceof Sketch)) {
+            parent = parent.getParent();
+        }
+        if (!parent) {
+            console.warn('GeometrySceneObject is not contained within a Sketch');
+            return null;
+        }
+        return parent;
+    }
+    getCurrentPosition() {
+        return this.sketch.getPositionAt(this);
+    }
+    setCurrentPosition(point) {
+        this.setState('current-position', point);
+    }
+    setTangent(point) {
+        this.setState('tangent', point);
+    }
+    applyEdgeResults(plane, edges) {
+        for (let i = 0; i < edges.length; i++) {
+            this.setState(`edge-${i}`, edges[i]);
+        }
+        if (edges.length > 0) {
+            const lastEdge = edges[edges.length - 1];
+            const localStart = plane.worldToLocal(lastEdge.getFirstVertex().toPoint());
+            const localEnd = plane.worldToLocal(lastEdge.getLastVertex().toPoint());
+            this.setState('start', Vertex.fromPoint2D(localStart));
+            this.setState('end', Vertex.fromPoint2D(localEnd));
+            this.setTangent(localEnd.subtract(localStart).normalize());
+            this.setCurrentPosition(localEnd);
+        }
+        this.addShapes(edges);
+    }
+    getTangent() {
+        return this.getState('tangent');
+    }
+    start() {
+        return new LazyVertex(this.generateUniqueName('start-vertex'), () => {
+            const start = this.getState('start');
+            console.log('Getting start vertex:', start);
+            if (start) {
+                console.log('Getting start vertex:', start);
+                return [start];
+            }
+            return [];
+        });
+    }
+    end() {
+        return new LazyVertex(this.generateUniqueName('end-vertex'), () => {
+            const end = this.getState('end');
+            if (end) {
+                console.log('Getting end vertex:', end);
+                return [end];
+            }
+            return [];
+        });
+    }
+    tangent() {
+        return new LazyVertex(this.generateUniqueName('tangent'), () => {
+            const tangent = this.getTangent();
+            if (tangent) {
+                return [Vertex.fromPoint2D(tangent)];
+            }
+            return [];
+        });
+    }
+}

package/lib/dist/features/2d/hline.d.ts

@@ -0,0 +1,16 @@
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class HorizontalLine extends GeometrySceneObject {
+    distance: number;
+    centered: boolean;
+    private targetPlane;
+    constructor(distance: number, centered?: boolean, targetPlane?: PlaneObjectBase);
+    build(): void;
+    compareTo(other: HorizontalLine): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        distance: number;
+        centered: boolean;
+    };
+}

package/lib/dist/features/2d/hline.js

@@ -0,0 +1,66 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class HorizontalLine extends GeometrySceneObject {
+    distance;
+    centered;
+    targetPlane;
+    constructor(distance, centered = false, targetPlane = null) {
+        super();
+        this.distance = distance;
+        this.centered = centered;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const currentPos = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const startPoint = this.centered
+            ? currentPos.translate(-this.distance / 2, 0)
+            : currentPos;
+        const endPoint = startPoint.translate(this.distance, 0);
+        const start = plane.localToWorld(startPoint);
+        const end = plane.localToWorld(endPoint);
+        let segment = Geometry.makeSegment(start, end);
+        const edge = Geometry.makeEdge(segment);
+        this.setState('start', Vertex.fromPoint2D(startPoint));
+        this.setState('end', Vertex.fromPoint2D(endPoint));
+        this.addShape(edge);
+        const sign = Math.sign(this.distance) || 1;
+        this.setTangent(new Point2D(sign, 0));
+        if (this.sketch) {
+            this.setCurrentPosition(endPoint);
+        }
+        if (this.targetPlane)
+            this.targetPlane.removeShapes(this);
+    }
+    compareTo(other) {
+        if (!(other instanceof HorizontalLine)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.distance === other.distance && this.centered === other.centered;
+    }
+    getType() {
+        return 'line';
+    }
+    getUniqueType() {
+        return 'hline';
+    }
+    serialize() {
+        return {
+            distance: this.distance,
+            centered: this.centered
+        };
+    }
+}

package/lib/dist/features/2d/hmove.d.ts

@@ -0,0 +1,14 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class HMove extends GeometrySceneObject {
+    distance: number;
+    constructor(distance: number);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        distance: number;
+    };
+}

package/lib/dist/features/2d/hmove.js

@@ -0,0 +1,37 @@
+import { Point2D } from "../../math/point.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class HMove extends GeometrySceneObject {
+    distance;
+    constructor(distance) {
+        super();
+        this.distance = distance;
+    }
+    getType() {
+        return 'hmove';
+    }
+    build() {
+        const pos = this.getCurrentPosition();
+        const newPos = new Point2D(pos.x + this.distance, pos.y);
+        this.setCurrentPosition(newPos);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new HMove(this.distance);
+    }
+    compareTo(other) {
+        if (!(other instanceof HMove)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.distance === other.distance;
+    }
+    serialize() {
+        return {
+            distance: this.distance
+        };
+    }
+}

package/lib/dist/features/2d/line.d.ts

@@ -0,0 +1,15 @@
+import { LazyVertex } from "../lazy-vertex.js";
+import { PlaneObjectBase } from "../plane-renderable-base.js";
+import { GeometrySceneObject } from "./geometry.js";
+export declare class LineTo extends GeometrySceneObject {
+    endPoint: LazyVertex;
+    private targetPlane;
+    constructor(endPoint: LazyVertex, targetPlane?: PlaneObjectBase);
+    build(): void;
+    compareTo(other: LineTo): boolean;
+    getType(): string;
+    getUniqueType(): string;
+    serialize(): {
+        end: LazyVertex;
+    };
+}

package/lib/dist/features/2d/line.js

@@ -0,0 +1,59 @@
+import { Vertex } from "../../common/vertex.js";
+import { Geometry } from "../../oc/geometry.js";
+import { GeometrySceneObject } from "./geometry.js";
+export class LineTo extends GeometrySceneObject {
+    endPoint;
+    targetPlane;
+    constructor(endPoint, targetPlane = null) {
+        super();
+        this.endPoint = endPoint;
+        this.targetPlane = targetPlane;
+    }
+    build() {
+        const plane = this.targetPlane?.getPlane() || this.sketch.getPlane();
+        const targetPoint = this.endPoint.asPoint2D();
+        console.log('Building LineTo to', targetPoint);
+        const currentPos = this.targetPlane
+            ? plane.worldToLocal(this.targetPlane.getPlaneCenter())
+            : this.getCurrentPosition();
+        const start = plane.localToWorld(currentPos);
+        const end = plane.localToWorld(targetPoint);
+        let segment = Geometry.makeSegment(start, end);
+        const edge = Geometry.makeEdge(segment);
+        this.setState('start', Vertex.fromPoint2D(currentPos));
+        this.setState('end', Vertex.fromPoint2D(targetPoint));
+        this.addShape(edge);
+        this.setTangent(targetPoint.subtract(currentPos).normalize());
+        if (this.sketch)
+            this.setCurrentPosition(targetPoint);
+        if (this.targetPlane) {
+            this.targetPlane.removeShapes(this);
+        }
+    }
+    compareTo(other) {
+        if (!(other instanceof LineTo)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        if (this.targetPlane?.constructor !== other.targetPlane?.constructor) {
+            return false;
+        }
+        if (this.targetPlane && other.targetPlane && !this.targetPlane.compareTo(other.targetPlane)) {
+            return false;
+        }
+        return this.endPoint.compareTo(other.endPoint);
+    }
+    getType() {
+        return 'line';
+    }
+    getUniqueType() {
+        return 'line-two-points';
+    }
+    serialize() {
+        return {
+            end: this.endPoint
+        };
+    }
+}

package/lib/dist/features/2d/move.d.ts

@@ -0,0 +1,15 @@
+import { SceneObject } from "../../common/scene-object.js";
+import { GeometrySceneObject } from "./geometry.js";
+import { LazyVertex } from "../lazy-vertex.js";
+export declare class Move extends GeometrySceneObject {
+    targetPosition: LazyVertex;
+    constructor(targetPosition: LazyVertex);
+    getType(): string;
+    build(): void;
+    getDependencies(): SceneObject[];
+    createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
+    compareTo(other: this): boolean;
+    serialize(): {
+        position: LazyVertex;
+    };
+}

package/lib/dist/features/2d/move.js

@@ -0,0 +1,36 @@
+import { GeometrySceneObject } from "./geometry.js";
+export class Move extends GeometrySceneObject {
+    targetPosition;
+    constructor(targetPosition) {
+        super();
+        this.targetPosition = targetPosition;
+    }
+    getType() {
+        return 'move';
+    }
+    build() {
+        const point = this.targetPosition.asPoint2D();
+        console.log('Building Move to', point);
+        this.setCurrentPosition(point);
+    }
+    getDependencies() {
+        return [];
+    }
+    createCopy(remap) {
+        return new Move(this.targetPosition);
+    }
+    compareTo(other) {
+        if (!(other instanceof Move)) {
+            return false;
+        }
+        if (!super.compareTo(other)) {
+            return false;
+        }
+        return this.targetPosition.compareTo(other.targetPosition);
+    }
+    serialize() {
+        return {
+            position: this.targetPosition
+        };
+    }
+}