Geometric Interactions: Simulating Public Space Behaviors with Steering Principles

Appendix B: Optimizing Multi-Object and Role Dynamic Scenarios for Smooth Transitions

Overall, this project features an algorithm that enables smooth transitions for multiple objects and roles within a simulated environment. For example, in the Cult mode, the algorithm creates natural movements by adjusting the interactions between a leader and its followers using Perlin noise. This approach smoothly integrates leader, evangelist, and follower roles, incorporating separation and dynamically weighted forces, allowing for realistic and fluid transitions between different roles and behaviors.

The project also uses Perlin noise to generate natural variations in movement, ensuring seamless transitions between behaviors. This method ensures that changes between different states and roles appear smoothly, avoiding abrupt shifts that could disrupt immersion. The subtle approach to managing multi-object and multi-role behaviors demonstrates a bit more attention to detail of control and flexibility in applying steering behaviors that are both aesthetic and functionally optimized.

Sample Usage:

// Abstracted logic for leader following with Perlin noise

// Function to generate smooth, natural variations
function getPerlinNoiseValue(x, y) {
    return noise(x * 0.01, y * 0.01);
}

// Function to calculate the desired distance based on Perlin noise
function calculateDesiredDistance(noiseValue) {
    return map(noiseValue, 0, 1, 55, 125); // Desired distance range

// Main algorithm for leader-following behavior
function followLeader(mover, leader, isEvangelist) {
    // Calculate the force to move towards the leader
    let followForce = seek(mover.position, leader.position);

    // Calculate separation force to avoid crowding
    let separationForce = separate(mover, allMovers);

    // Adjust separation force based on distance from the leader
    let distanceToLeader = dist(mover.position, leader.position);
    let noiseValue = getPerlinNoiseValue(mover.position.x, mover.position.y);
    let desiredDistance = calculateDesiredDistance(noiseValue);

    if (distanceToLeader < desiredDistance) {
        let difference = p5.Vector.sub(mover.position, leader.position);
        difference.normalize();
        difference.div(distanceToLeader); // Weight by distance
        separationForce.add(difference);
    }

    // Apply different weights for evangelists and regular followers
    followForce.mult(isEvangelist ? 3.0 : 0.55);
   // Modulate separation force with Perlin noise
      separationForce.mult(1.5 * noiseValue);  

    // Combine forces to get the final steering force
    let finalForce = p5.Vector.add(followForce, separationForce);

    return finalForce;
}

// Function to seek a target position
function seek(currentPosition, targetPosition) {
    let desired = p5.Vector.sub(targetPosition, currentPosition);
    desired.setMag(maxSpeed); // Set the magnitude to the maximum speed
    let steer = p5.Vector.sub(desired, currentVelocity);
    steer.limit(maxForce); // Limit to the maximum force
    return steer;
}

// Function to calculate separation force
function separate(mover, movers) {
    let desiredSeparation = mover.size * 1.0;
    let steer = createVector(0, 0);
    let count = 0;

    for (let other of movers) {
        let d = p5.Vector.dist(mover.position, other.position);
        if (d > 0 && d < desiredSeparation) {
            let diff = p5.Vector.sub(mover.position, other.position);
            diff.normalize();
            diff.div(d); // Weight by distance
            steer.add(diff);
            count++;
        }
    }

    if (count > 0) {
        steer.div(count); // Average steering force
    }

    if (steer.mag() > 0) {
        steer.setMag(maxSpeed);
        steer.sub(mover.velocity);
        steer.limit(maxForce); // Limit to the maximum steering force
    }

    return steer;
}

Function Parameters:

• The getPerlinNoiseValue(x, y) function generates smooth variations by returning a noise value based on the x and y coordinates.
• The calculateDesiredDistance(noiseValue) function maps this noise value to a range (e.g., 55 to 125) to determine the desired distance dynamically.
• In the followLeader function, the noise value influences how closely followers stay to the leader, introducing natural variation.