const WALL_MIN_LENGTH = 20; // Minimum length of a wall

const WALL_MAX_LENGTH = 100; // Maximum length of a wall

const SAFE_RADIUS = 155; // Safe radius around start and end points

​

​

// Constants

const WALL_THRESHOLD = 10; // Adjust as needed

const CONTROL_POINT_THRESHOLD = 0.1; // Adjust as needed

​

class Path {

  constructor() {

    this.controlPoints = [];

  }

​

  // Function to convert A* path to Bezier curve

  createBezierPath(astarPath) {

    // Implement this function based on your requirements

    // You can use the astarPath to generate control points for the Bezier curve

  }

​

  // Display function (p5.js)

  display() {

    // Implement this function using p5.js graphics

    // Use this.controlPoints to draw the Bezier curve on the map

  }

​

  // Function to fit Bezier to avoid walls and keep a minimal path

  fitBezierToAvoidWalls() {

    // Implement this function to fit Bezier while avoiding walls

    // You may need to adjust control points to avoid walls and keep the path minimal

  }

​

  // Dynamic addition of control points based on temperature/threshold

  addControlPoints(temperature) {

    // Implement this function to add control points dynamically based on temperature

    // You can use temperature to determine when to add control points

  }

​

  // Remove control points as needed

  removeControlPoints() {

    // Implement this function to remove control points as needed

    // You can use certain criteria or thresholds to decide when to remove control points

  }

}

​

​

​

class Situation {

  constructor() {

    this.reinitialize();

  }

  reinitialize() {

    // random startpoints at opposite ends.

​

    this.startPoint = createVector(width * 0.2, height * 0.2).add(

      p5.Vector.random2D().mult(min(width, height) * 0.1)

    );

    this.endPoint = createVector(width * 0.8, height * 0.8).add(

      p5.Vector.random2D().mult(min(width, height) * 0.1)

    );

​

    this.setupWalls(); // create n_walls in the center.

​

    this.solved = false; // a path is found

    this.isOptimal = false; // the path is optimal

    this.paths = [];

  }

  setupWalls() {

    this.walls = [];

    let midX = (this.startPoint.x + this.endPoint.x) / 2;

    let midY = (this.startPoint.y + this.endPoint.y) / 2;

    let rangeX = abs(this.endPoint.x - this.startPoint.x);

    let rangeY = abs(this.endPoint.y - this.startPoint.y);

​

    for (let i = 0; i < N_WALLS; i++) {

      let x, y, x2, y2, angle, length;

      do {

        x = random(midX - rangeX / 2, midX + rangeX / 2);

        y = random(midY - rangeY / 2, midY + rangeY / 2);

        angle = random(TWO_PI);

        length = random(WALL_MIN_LENGTH, WALL_MAX_LENGTH);

        x2 = x + cos(angle) * length;

        y2 = y + sin(angle) * length;

      } while (

        dist(x, y, this.startPoint.x, this.startPoint.y) < SAFE_RADIUS ||

        dist(x2, y2, this.endPoint.x, this.endPoint.y) < SAFE_RADIUS

      );

​

      this.walls.push([createVector(x, y), createVector(x2, y2)]);

    }

  }

​

  display() {

    fill(0, 255, 255);

    circle(this.startPoint.x, this.startPoint.y, 10);

    fill(255, 0, 255);

    circle(this.endPoint.x, this.endPoint.y, 10);

​

    this.displayWalls();

  }

​

  displayWalls() {

    for (const [p1, p2] of this.walls) {

      line(p1.x, p1.y, p2.x, p2.y);

    }

  }

  displayPaths() {

    for (const p of this.paths){

      p.display()

    }

  }

}

​

var S;

​

function setup() {

  createCanvas(400, 400);

  S = new Situation();

}

​

function draw() {

  background(220);

  S.display();

}

​