implement dedicated classses for input and route management

src/RouteManager.js

@@ -0,0 +1,248 @@
+import * as THREE from 'three';
+
+export class RouteManager {
+  constructor(scene, settings) {
+    this.scene = scene;
+    this.settings = settings;
+
+    this.graphData = null;
+
+    // State: A route is an ordered list of Node IDs
+    this.currentRouteNodes = [];
+
+    // Visuals
+    this.markers = [];
+    this.pathMesh = null;
+
+    // Constants
+    this.ROAD_OFFSET = 3.0; // Meters to right
+  }
+
+  initGraph(data) {
+    this.graphData = data;
+
+    // Prepare Adjacency List (mirrors previous logic)
+    // IMPORTANT: Fix coordinates here once, so logic uses correct Z
+    this.graphData.adjacency = {};
+
+    // 1. Flip Y to Z for Nodes
+    for (let key in this.graphData.nodes) {
+      this.graphData.nodes[key].y = -this.graphData.nodes[key].y;
+    }
+
+    // 2. Process Edges
+    this.graphData.edges.forEach((edge, index) => {
+      // Flip geometry points
+      if (edge.points) {
+        edge.points.forEach(p => { p[1] = -p[1]; });
+      }
+
+      if (!this.graphData.adjacency[edge.u]) this.graphData.adjacency[edge.u] = [];
+      this.graphData.adjacency[edge.u].push({
+        to: edge.v,
+        cost: edge.length || 1,
+        edgeIndex: index
+      });
+
+      if (!edge.oneway) {
+        if (!this.graphData.adjacency[edge.v]) this.graphData.adjacency[edge.v] = [];
+        this.graphData.adjacency[edge.v].push({
+          to: edge.u,
+          cost: edge.length || 1,
+          edgeIndex: index,
+          isReverse: true
+        });
+      }
+    });
+  }
+
+  // ============================
+  // Interaction Methods
+  // ============================
+
+  /**
+   * Called when user clicks the map. Adds a node to the route.
+   */
+  addNodeByWorldPosition(vector3) {
+    if (!this.graphData) return;
+
+    const nodeId = this.findNearestNode(vector3.x, vector3.z);
+
+    // Prevent adding same node twice in a row
+    if (this.currentRouteNodes.length > 0 &&
+      this.currentRouteNodes[this.currentRouteNodes.length - 1] === nodeId) {
+      return;
+    }
+
+    this.currentRouteNodes.push(nodeId);
+
+    // Visuals
+    this.addMarker(nodeId);
+    this.updatePathVisuals();
+  }
+
+  resetRoute() {
+    this.currentRouteNodes = [];
+    // Clear Visuals
+    this.markers.forEach(m => this.scene.remove(m));
+    this.markers = [];
+    if (this.pathMesh) {
+      this.scene.remove(this.pathMesh);
+      this.pathMesh = null;
+    }
+  }
+
+  // ============================
+  // Logic & Algorithms
+  // ============================
+
+  findNearestNode(x, z) {
+    let closestId = null;
+    let minDist = Infinity;
+    for (const [id, node] of Object.entries(this.graphData.nodes)) {
+      const dx = node.x - x;
+      const dz = node.y - z; // Graph Y is World Z
+      const d2 = dx * dx + dz * dz;
+      if (d2 < minDist) {
+        minDist = d2;
+        closestId = parseInt(id);
+      }
+    }
+    return closestId;
+  }
+
+  updatePathVisuals() {
+    // We need at least 2 nodes to draw a path
+    if (this.currentRouteNodes.length < 2) return;
+
+    // 1. Calculate Full Path (Segment by Segment)
+    let fullPathPoints = [];
+
+    for (let i = 0; i < this.currentRouteNodes.length - 1; i++) {
+      const start = this.currentRouteNodes[i];
+      const end = this.currentRouteNodes[i + 1];
+
+      const segmentEdges = this.computePathAStar(start, end);
+
+      if (!segmentEdges) {
+        console.warn(`No path found between ${start} and ${end}`);
+        continue;
+      }
+
+      // Process Geometry for this segment
+      segmentEdges.forEach(step => {
+        const rawPoints = step.edgeData.points;
+        let segmentPoints = rawPoints.map(p => new THREE.Vector2(p[0], p[1]));
+        if (step.isReverse) segmentPoints.reverse();
+
+        const offsetSegment = this.getOffsetPath(segmentPoints, this.ROAD_OFFSET);
+
+        offsetSegment.forEach(p => {
+          fullPathPoints.push(new THREE.Vector3(p.x, 0.5, p.y));
+        });
+      });
+    }
+
+    // 2. Draw Tube
+    if (this.pathMesh) this.scene.remove(this.pathMesh);
+    if (fullPathPoints.length < 2) return;
+
+    const curve = new THREE.CatmullRomCurve3(fullPathPoints);
+    const tubeGeom = new THREE.TubeGeometry(curve, fullPathPoints.length, 1.5, 6, false);
+    const tubeMat = new THREE.MeshBasicMaterial({ color: this.settings.colors.route });
+
+    this.pathMesh = new THREE.Mesh(tubeGeom, tubeMat);
+    this.scene.add(this.pathMesh);
+  }
+
+  addMarker(nodeId) {
+    const node = this.graphData.nodes[nodeId];
+    const geom = new THREE.SphereGeometry(4);
+
+    // Color logic: Green for start, Red for end, Yellow for waypoints
+    let color = this.settings.colors.pathStart;
+    if (this.markers.length > 0) color = 0xFFFF00; // Middle
+
+    const mat = new THREE.MeshBasicMaterial({ color: color });
+    const mesh = new THREE.Mesh(geom, mat);
+    mesh.position.set(node.x, 2, node.y);
+    mesh.userData = { isMarker: true, nodeId: nodeId }; // Tag for input manager
+
+    this.scene.add(mesh);
+    this.markers.push(mesh);
+
+    // Update last marker to Red
+    if (this.markers.length > 1) {
+      this.markers[this.markers.length - 1].material.color.setHex(this.settings.colors.pathEnd);
+    }
+  }
+
+  // ============================
+  // A* Implementation
+  // ============================
+  computePathAStar(start, end) {
+    const openSet = new Set([start]);
+    const cameFrom = {};
+    const gScore = {};
+    const fScore = {};
+
+    gScore[start] = 0;
+    fScore[start] = this.heuristic(start, end);
+
+    while (openSet.size > 0) {
+      let current = null;
+      let minF = Infinity;
+      for (const node of openSet) {
+        const score = fScore[node] !== undefined ? fScore[node] : Infinity;
+        if (score < minF) { minF = score; current = node; }
+      }
+
+      if (current === end) return this.reconstructPath(cameFrom, current);
+
+      openSet.delete(current);
+
+      const neighbors = this.graphData.adjacency[current] || [];
+      for (const neighbor of neighbors) {
+        const tentativeG = gScore[current] + neighbor.cost;
+        if (tentativeG < (gScore[neighbor.to] !== undefined ? gScore[neighbor.to] : Infinity)) {
+          cameFrom[neighbor.to] = { prev: current, edgeIdx: neighbor.edgeIndex, isReverse: neighbor.isReverse };
+          gScore[neighbor.to] = tentativeG;
+          fScore[neighbor.to] = tentativeG + this.heuristic(neighbor.to, end);
+          openSet.add(neighbor.to);
+        }
+      }
+    }
+    return null;
+  }
+
+  heuristic(a, b) {
+    const nA = this.graphData.nodes[a];
+    const nB = this.graphData.nodes[b];
+    return Math.sqrt((nA.x - nB.x) ** 2 + (nA.y - nB.y) ** 2);
+  }
+
+  reconstructPath(cameFrom, current) {
+    const edges = [];
+    while (current in cameFrom) {
+      const data = cameFrom[current];
+      edges.push({ edgeData: this.graphData.edges[data.edgeIdx], isReverse: data.isReverse });
+      current = data.prev;
+    }
+    return edges.reverse();
+  }
+
+  getOffsetPath(points, offset) {
+    if (points.length < 2) return points;
+    const newPath = [];
+    for (let i = 0; i < points.length - 1; i++) {
+      const p1 = points[i];
+      const p2 = points[i + 1];
+      const dir = new THREE.Vector2().subVectors(p2, p1).normalize();
+      const normal = new THREE.Vector2(-dir.y, dir.x);
+      const off = normal.multiplyScalar(offset);
+      newPath.push(new THREE.Vector2().addVectors(p1, off));
+      if (i === points.length - 2) newPath.push(new THREE.Vector2().addVectors(p2, off));
+    }
+    return newPath;
+  }
+}