public enum EnemyState { Idle, Patrol, Alert, Chase, Attack, Dead }
 
public class EnemyFSM : MonoBehaviour
{
    [Header("State")]
    public EnemyState currentState = EnemyState.Idle;
    
    [Header("Tuning")]
    public float hearingRadius   = 10f;
    public float visionRadius    = 15f;
    public float attackRadius    = 2f;
    public float alertTimeout    = 3f;
    
    private float alertTimer;
    private Transform player;
    
    private void Start()  => player = GameObject.FindGameObjectWithTag("Player").transform;
    
    private void Update() => RunFSM();
    
    private void RunFSM()
    {
        switch (currentState)
        {
            case EnemyState.Idle:
                if (CanHearPlayer())  TransitionTo(EnemyState.Alert);
                break;
                
            case EnemyState.Patrol:
                Patrol();
                if (CanSeePlayer())   TransitionTo(EnemyState.Chase);
                if (CanHearPlayer())  TransitionTo(EnemyState.Alert);
                break;
                
            case EnemyState.Alert:
                alertTimer += Time.deltaTime;
                if (CanSeePlayer())   TransitionTo(EnemyState.Chase);
                if (alertTimer > alertTimeout)  TransitionTo(EnemyState.Patrol);
                break;
                
            case EnemyState.Chase:
                ChasePlayer();
                if (InAttackRange())  TransitionTo(EnemyState.Attack);
                if (!CanSeePlayer())  TransitionTo(EnemyState.Alert);
                break;
                
            case EnemyState.Attack:
                AttackPlayer();
                if (!InAttackRange()) TransitionTo(EnemyState.Chase);
                break;
        }
    }
    
    private void TransitionTo(EnemyState newState)
    {
        // Exit current state
        OnExitState(currentState);
        currentState = newState;
        alertTimer = 0f;
        // Enter new state
        OnEnterState(newState);
    }
    
    private bool CanHearPlayer() => 
        Vector3.Distance(transform.position, player.position) < hearingRadius;
    private bool CanSeePlayer() =>
        Vector3.Distance(transform.position, player.position) < visionRadius && HasLineOfSight();
    private bool InAttackRange() =>
        Vector3.Distance(transform.position, player.position) < attackRadius;
}

public enum BTStatus { Success, Failure, Running }
 
public abstract class BTNode
{
    public abstract BTStatus Tick();
}
 
// Sequence — all must succeed
public class Sequence : BTNode
{
    private readonly List<BTNode> children;
    private int current = 0;
    
    public Sequence(params BTNode[] nodes) => children = new List<BTNode>(nodes);
    
    public override BTStatus Tick()
    {
        while (current < children.Count)
        {
            var status = children[current].Tick();
            if (status == BTStatus.Failure)  { current = 0; return BTStatus.Failure; }
            if (status == BTStatus.Running)  return BTStatus.Running;
            current++;
        }
        current = 0;
        return BTStatus.Success;
    }
}
 
// Selector — first success wins
public class Selector : BTNode
{
    private readonly List<BTNode> children;
    
    public Selector(params BTNode[] nodes) => children = new List<BTNode>(nodes);
    
    public override BTStatus Tick()
    {
        foreach (var child in children)
        {
            var status = child.Tick();
            if (status != BTStatus.Failure) return status;
        }
        return BTStatus.Failure;
    }
}
 
// Condition leaf
public class Condition : BTNode
{
    private readonly Func<bool> condition;
    public Condition(Func<bool> condition) => this.condition = condition;
    public override BTStatus Tick() => condition() ? BTStatus.Success : BTStatus.Failure;
}
 
// Action leaf
public class ActionNode : BTNode
{
    private readonly Func<BTStatus> action;
    public ActionNode(Func<BTStatus> action) => this.action = action;
    public override BTStatus Tick() => action();
}

public class UtilityAI : MonoBehaviour
{
    [System.Serializable]
    public struct Action
    {
        public string name;
        public AnimationCurve utilityCurve; // maps input (0-1) to utility score (0-1)
        public System.Func<float> GetInput;
        public System.Action Execute;
    }
    
    private List<Action> actions = new();
    
    private void Update()
    {
        Action bestAction = default;
        float bestScore = float.MinValue;
        
        foreach (var action in actions)
        {
            float input = action.GetInput();
            float score = action.utilityCurve.Evaluate(input);
            
            if (score > bestScore)
            {
                bestScore = score;
                bestAction = action;
            }
        }
        
        bestAction.Execute?.Invoke();
    }
    
    // Example: NPC hunger utility
    // Input: hunger level (0=full, 1=starving)
    // Curve: exponential rise — small hunger = low priority, high hunger = urgent
}

public class AStarPathfinder
{
    private readonly int[,] grid;
    private readonly int rows, cols;
    
    public AStarPathfinder(int[,] grid)
    {
        this.grid = grid;
        rows = grid.GetLength(0);
        cols = grid.GetLength(1);
    }
    
    public List<Vector2Int> FindPath(Vector2Int start, Vector2Int goal)
    {
        var openSet = new SortedSet<Node>(Comparer<Node>.Create((a, b) => 
            a.F != b.F ? a.F.CompareTo(b.F) : a.GetHashCode().CompareTo(b.GetHashCode())));
        var gScore  = new Dictionary<Vector2Int, float>();
        var parent  = new Dictionary<Vector2Int, Vector2Int>();
        
        gScore[start] = 0;
        openSet.Add(new Node(start, 0 + Heuristic(start, goal)));
        
        while (openSet.Count > 0)
        {
            var current = openSet.Min.Pos;
            openSet.Remove(openSet.Min);
            
            if (current == goal)
                return ReconstructPath(parent, goal);
            
            foreach (var neighbor in GetNeighbors(current))
            {
                float tentativeG = gScore[current] + 1f;
                if (!gScore.ContainsKey(neighbor) || tentativeG < gScore[neighbor])
                {
                    gScore[neighbor] = tentativeG;
                    parent[neighbor] = current;
                    openSet.Add(new Node(neighbor, tentativeG + Heuristic(neighbor, goal)));
                }
            }
        }
        return null; // No path
    }
    
    private float Heuristic(Vector2Int a, Vector2Int b) =>
        Mathf.Abs(a.x - b.x) + Mathf.Abs(a.y - b.y); // Manhattan
    
    private IEnumerable<Vector2Int> GetNeighbors(Vector2Int pos)
    {
        var dirs = new[] { Vector2Int.up, Vector2Int.down, Vector2Int.left, Vector2Int.right };
        foreach (var dir in dirs)
        {
            var n = pos + dir;
            if (n.x >= 0 && n.x < rows && n.y >= 0 && n.y < cols && grid[n.x, n.y] == 0)
                yield return n;
        }
    }
}

public static class SteeringBehaviors
{
    // Seek — accelerate toward target
    public static Vector3 Seek(Vector3 position, Vector3 velocity, 
                                Vector3 target, float maxSpeed)
    {
        Vector3 desiredVelocity = (target - position).normalized * maxSpeed;
        return desiredVelocity - velocity;  // steering force
    }
    
    // Arrive — seek but slow near target
    public static Vector3 Arrive(Vector3 position, Vector3 velocity,
                                 Vector3 target, float maxSpeed, float slowRadius)
    {
        Vector3 toTarget = target - position;
        float dist = toTarget.magnitude;
        
        float speed = dist < slowRadius 
            ? maxSpeed * (dist / slowRadius)   // slow down
            : maxSpeed;
        
        Vector3 desiredVelocity = toTarget.normalized * speed;
        return desiredVelocity - velocity;
    }
    
    // Pursue — seek the target's predicted future position
    public static Vector3 Pursue(Vector3 position, Vector3 velocity,
                                  Vector3 targetPos, Vector3 targetVel, float maxSpeed)
    {
        float lookAheadTime = Vector3.Distance(position, targetPos) / maxSpeed;
        Vector3 futurePos = targetPos + targetVel * lookAheadTime;
        return Seek(position, velocity, futurePos, maxSpeed);
    }
    
    // Wander
    private static Vector3 wanderTarget;
    public static Vector3 Wander(Vector3 position, Vector3 forward,
                                  float circleRadius, float circleDistance, float jitter)
    {
        wanderTarget += new Vector3(
            Random.Range(-1f, 1f) * jitter,
            0,
            Random.Range(-1f, 1f) * jitter
        );
        wanderTarget = wanderTarget.normalized * circleRadius;
        
        Vector3 circleCenter = position + forward * circleDistance;
        return circleCenter + wanderTarget;
    }
}

public class Boid : MonoBehaviour
{
    public float maxSpeed   = 5f;
    public float maxForce   = 0.3f;
    public float perception = 4f;
    
    [Header("Weights")]
    public float separationWeight = 1.5f;
    public float alignmentWeight  = 1.0f;
    public float cohesionWeight   = 1.0f;
    
    private Vector3 velocity;
    
    private void Update()
    {
        var neighbors = FindNeighbors();
        
        Vector3 separation = Separation(neighbors) * separationWeight;
        Vector3 alignment  = Alignment(neighbors)  * alignmentWeight;
        Vector3 cohesion   = Cohesion(neighbors)   * cohesionWeight;
        
        Vector3 acceleration = separation + alignment + cohesion;
        acceleration = Vector3.ClampMagnitude(acceleration, maxForce);
        
        velocity = Vector3.ClampMagnitude(velocity + acceleration, maxSpeed);
        transform.position += velocity * Time.deltaTime;
        if (velocity != Vector3.zero)
            transform.forward = velocity.normalized;
    }
    
    private Vector3 Separation(List<Boid> neighbors)
    {
        Vector3 steer = Vector3.zero;
        foreach (var n in neighbors)
        {
            float d = Vector3.Distance(transform.position, n.transform.position);
            steer += (transform.position - n.transform.position) / (d * d);
        }
        return steer;
    }
    
    private Vector3 Alignment(List<Boid> neighbors)
    {
        if (neighbors.Count == 0) return Vector3.zero;
        Vector3 avg = Vector3.zero;
        foreach (var n in neighbors) avg += n.velocity;
        avg /= neighbors.Count;
        return (avg.normalized * maxSpeed - velocity);
    }
    
    private Vector3 Cohesion(List<Boid> neighbors)
    {
        if (neighbors.Count == 0) return Vector3.zero;
        Vector3 center = Vector3.zero;
        foreach (var n in neighbors) center += n.transform.position;
        center /= neighbors.Count;
        return SteeringBehaviors.Seek(transform.position, velocity, center, maxSpeed);
    }
}

public class PerceptionSystem : MonoBehaviour
{
    [Header("Vision")]
    public float viewRadius = 15f;
    [Range(0, 360)]
    public float viewAngle  = 110f;
    public LayerMask targetMask;
    public LayerMask obstacleMask;
    
    [Header("Hearing")]
    public float hearingRadius = 10f;
    
    public bool CanSeeTarget(Transform target)
    {
        Vector3 dirToTarget = (target.position - transform.position).normalized;
        float   distToTarget = Vector3.Distance(transform.position, target.position);
        
        // Check distance
        if (distToTarget > viewRadius) return false;
        
        // Check angle
        if (Vector3.Angle(transform.forward, dirToTarget) > viewAngle * 0.5f) return false;
        
        // Check line of sight
        if (Physics.Raycast(transform.position + Vector3.up, dirToTarget, distToTarget, obstacleMask))
            return false; // Blocked by obstacle
        
        return true;
    }
    
    // Called when any agent makes noise (footstep, gunshot, etc.)
    public static void BroadcastNoise(Vector3 noisePos, float noiseRadius, 
                                        NoiseType type, LayerMask listenerMask)
    {
        var colliders = Physics.OverlapSphere(noisePos, noiseRadius, listenerMask);
        foreach (var col in colliders)
        {
            if (col.TryGetComponent<PerceptionSystem>(out var listener))
                listener.HearNoise(noisePos, noiseRadius, type);
        }
    }
    
    private void HearNoise(Vector3 pos, float radius, NoiseType type)
    {
        float dist = Vector3.Distance(transform.position, pos);
        float perceived = 1f - (dist / radius); // 0=barely heard, 1=loud
        OnHeardNoise?.Invoke(pos, perceived, type);
    }
    
    public event System.Action<Vector3, float, NoiseType> OnHeardNoise;
}

using Unity.MLAgents;
using Unity.MLAgents.Sensors;
using Unity.MLAgents.Actuators;
 
public class RollerAgent : Agent
{
    public Transform target;
    private Rigidbody rb;
    
    public override void Initialize() => rb = GetComponent<Rigidbody>();
    
    // Called at start of each episode
    public override void OnEpisodeBegin()
    {
        // Reset agent
        rb.velocity        = Vector3.zero;
        rb.angularVelocity = Vector3.zero;
        transform.localPosition = new Vector3(Random.Range(-4f, 4f), 0.5f, Random.Range(-4f, 4f));
        // Randomize target
        target.localPosition = new Vector3(Random.Range(-4f, 4f), 0.5f, Random.Range(-4f, 4f));
    }
    
    // What the agent observes each step
    public override void CollectObservations(VectorSensor sensor)
    {
        sensor.AddObservation(target.localPosition);       // 3 floats
        sensor.AddObservation(transform.localPosition);    // 3 floats
        sensor.AddObservation(rb.velocity.x);              // 1 float
        sensor.AddObservation(rb.velocity.z);              // 1 float
        // Total: 8 observations
    }
    
    // What the agent does each step
    public override void OnActionReceived(ActionBuffers actions)
    {
        Vector3 controlSignal = Vector3.zero;
        controlSignal.x = actions.ContinuousActions[0];
        controlSignal.z = actions.ContinuousActions[1];
        rb.AddForce(controlSignal * 10f);
        
        float dist = Vector3.Distance(transform.localPosition, target.localPosition);
        
        // Reward for reaching target
        if (dist < 1.5f) { SetReward(1f); EndEpisode(); }
        
        // Penalty for falling off platform
        if (transform.localPosition.y < 0) { EndEpisode(); }
        
        // Small reward for getting closer
        AddReward(-0.001f);  // time penalty to encourage speed
    }
    
    // Allow human control during testing
    public override void Heuristic(in ActionBuffers actionsOut)
    {
        var ca = actionsOut.ContinuousActions;
        ca[0] = Input.GetAxis("Horizontal");
        ca[1] = Input.GetAxis("Vertical");
    }
}

behaviors:
  RollerBall:
    trainer_type: ppo
    hyperparameters:
      batch_size: 10
      buffer_size: 100
      learning_rate: 3.0e-4
      beta: 5.0e-3
      epsilon: 0.2
      lambd: 0.99
      num_epoch: 3
      learning_rate_schedule: linear
    network_settings:
      normalize: false
      hidden_units: 128
      num_layers: 2
    reward_signals:
      extrinsic:
        gamma: 0.99
        strength: 1.0
    max_steps: 500000
    time_horizon: 64
    summary_freq: 10000

mlagents-learn config/trainer_config.yaml --run-id=MyFirstRun
# Monitor with TensorBoard
tensorboard --logdir results/MyFirstRun

def minimax(state, depth, alpha, beta, maximizing):
    if depth == 0 or state.is_terminal():
        return state.evaluate()
    
    if maximizing:
        max_eval = float('-inf')
        for move in state.get_moves():
            child = state.apply_move(move)
            eval = minimax(child, depth-1, alpha, beta, False)
            max_eval = max(max_eval, eval)
            alpha = max(alpha, eval)
            if beta <= alpha:
                break  # Beta cut-off — prune!
        return max_eval
    else:
        min_eval = float('inf')
        for move in state.get_moves():
            child = state.apply_move(move)
            eval = minimax(child, depth-1, alpha, beta, True)
            min_eval = min(min_eval, eval)
            beta = min(beta, eval)
            if beta <= alpha:
                break  # Alpha cut-off — prune!
        return min_eval
 
# Best move selection
def get_best_move(state, depth):
    best_move = None
    best_score = float('-inf')
    for move in state.get_moves():
        score = minimax(state.apply_move(move), depth-1, float('-inf'), float('inf'), False)
        if score > best_score:
            best_score = score
            best_move = move
    return best_move

private void OnDrawGizmosSelected()
{
    // Draw vision range
    Gizmos.color = Color.yellow;
    Gizmos.DrawWireSphere(transform.position, viewRadius);
    
    // Draw hearing range  
    Gizmos.color = new Color(0, 1, 1, 0.3f);
    Gizmos.DrawWireSphere(transform.position, hearingRadius);
    
    // Draw FOV cone
    Vector3 viewAngleA = DirFromAngle(-viewAngle / 2, false);
    Vector3 viewAngleB = DirFromAngle( viewAngle / 2, false);
    Gizmos.color = Color.white;
    Gizmos.DrawLine(transform.position, transform.position + viewAngleA * viewRadius);
    Gizmos.DrawLine(transform.position, transform.position + viewAngleB * viewRadius);
    
    // Draw current path
    if (currentPath != null)
    {
        Gizmos.color = Color.green;
        for (int i = 0; i < currentPath.Count - 1; i++)
            Gizmos.DrawLine(currentPath[i], currentPath[i+1]);
    }
    
    // Show state
#if UNITY_EDITOR
    UnityEditor.Handles.Label(transform.position + Vector3.up * 2, currentState.ToString());
#endif
}

public class TerrainGenerator : MonoBehaviour
{
    public int   width      = 256;
    public int   depth      = 256;
    public float scale      = 20f;    // zoom level — smaller = more zoomed in
    public float heightMult = 15f;    // max terrain height
    
    [Header("Octaves — add detail at different scales")]
    public int   octaves    = 4;      // number of noise layers
    public float persistence = 0.5f;  // how much each octave contributes
    public float lacunarity  = 2f;    // how much detail each octave adds
    
    private void Start()
    {
        Terrain terrain = GetComponent<Terrain>();
        terrain.terrainData = GenerateTerrain(terrain.terrainData);
    }
    
    private TerrainData GenerateTerrain(TerrainData data)
    {
        data.heightmapResolution = width + 1;
        data.size = new Vector3(width, heightMult, depth);
        data.SetHeights(0, 0, GenerateHeights());
        return data;
    }
    
    private float[,] GenerateHeights()
    {
        float[,] heights = new float[width, depth];
        float offsetX = Random.Range(0f, 9999f); // random seed
        float offsetZ = Random.Range(0f, 9999f);
        
        for (int x = 0; x < width; x++)
        {
            for (int z = 0; z < depth; z++)
            {
                heights[x, z] = SampleNoise(x + offsetX, z + offsetZ);
            }
        }
        return heights;
    }
    
    private float SampleNoise(float x, float z)
    {
        float amplitude = 1f;
        float frequency = 1f;
        float noiseHeight = 0f;
        float maxPossible = 0f;
        
        // Layer multiple octaves for detail
        for (int i = 0; i < octaves; i++)
        {
            float sampleX = x / scale * frequency;
            float sampleZ = z / scale * frequency;
            
            noiseHeight += Mathf.PerlinNoise(sampleX, sampleZ) * amplitude;
            maxPossible += amplitude;
            
            amplitude  *= persistence; // each layer gets quieter
            frequency  *= lacunarity;  // each layer gets finer
        }
        
        return noiseHeight / maxPossible; // normalize 0-1
    }
}

import random
from dataclasses import dataclass
from typing import Optional, List, Tuple
 
@dataclass
class Rect:
    x: int; y: int; w: int; h: int
    
    def center(self) -> Tuple[int, int]:
        return (self.x + self.w // 2, self.y + self.h // 2)
    
    def intersects(self, other: 'Rect') -> bool:
        return (self.x <= other.x + other.w and self.x + self.w >= other.x and
                self.y <= other.y + other.h and self.y + self.h >= other.y)
 
class BSPNode:
    MIN_SIZE = 6
    
    def __init__(self, region: Rect):
        self.region = region
        self.left:  Optional['BSPNode'] = None
        self.right: Optional['BSPNode'] = None
        self.room:  Optional[Rect]      = None
    
    def split(self) -> bool:
        if self.left or self.right:
            return False
        
        split_h = random.choice([True, False])
        if self.region.w > self.region.h and self.region.w / self.region.h >= 1.25:
            split_h = False
        elif self.region.h > self.region.w and self.region.h / self.region.w >= 1.25:
            split_h = True
        
        max_size = (self.region.h if split_h else self.region.w) - self.MIN_SIZE
        if max_size <= self.MIN_SIZE:
            return False
        
        split_pos = random.randint(self.MIN_SIZE, max_size)
        
        if split_h:
            self.left  = BSPNode(Rect(self.region.x, self.region.y, self.region.w, split_pos))
            self.right = BSPNode(Rect(self.region.x, self.region.y + split_pos,
                                      self.region.w, self.region.h - split_pos))
        else:
            self.left  = BSPNode(Rect(self.region.x, self.region.y, split_pos, self.region.h))
            self.right = BSPNode(Rect(self.region.x + split_pos, self.region.y,
                                      self.region.w - split_pos, self.region.h))
        return True
    
    def create_room(self):
        if self.left or self.right:
            if self.left:  self.left.create_room()
            if self.right: self.right.create_room()
        else:
            # Leaf node — create a room inside this region
            w = random.randint(self.MIN_SIZE - 1, self.region.w - 1)
            h = random.randint(self.MIN_SIZE - 1, self.region.h - 1)
            x = random.randint(self.region.x, self.region.x + (self.region.w - w))
            y = random.randint(self.region.y, self.region.y + (self.region.h - h))
            self.room = Rect(x, y, w, h)

// NPC greeting based on player reputation
VAR reputation = 50
VAR has_met = false
 
-> greet_player
 
=== greet_player ===
{ has_met:
    - The guard nods at you. "Back again?"
    - else:
        ~ has_met = true
        { reputation > 70:
            The guard smiles warmly. "Welcome, friend. Good to have you here."
        - reputation > 30:
            The guard eyes you neutrally. "State your business."
        - else:
            The guard's hand moves to his weapon. "You're not welcome here."
        }
}
 
* [Ask about the town]    -> ask_town
* [Ask about the king]   -> ask_king
* [Say nothing and leave] -> END
 
=== ask_town ===
"The town? Been through rough times. But we're managing."
-> greet_player
 
=== ask_king ===
{ reputation > 50:
    The guard leans in. "Between you and me — the king's been acting strange."
- else:
    "Not my place to speak of the king to strangers."
}
-> greet_player

public class DifficultyDirector : MonoBehaviour
{
    [Range(0f, 1f)]
    public float difficultyScore = 0.5f;   // 0=easy, 1=hard
    
    [Header("Thresholds")]
    public float easyThreshold = 0.3f;     // below this → increase difficulty
    public float hardThreshold = 0.7f;     // above this → decrease difficulty
    
    private float playerDeathRate   = 0f;  // deaths / minute
    private float playerKillRate    = 0f;  // kills / minute
    private float playerHealthRatio = 1f;  // current hp / max hp
    
    private void Update()
    {
        UpdateMetrics();
        AdjustDifficulty();
        ApplyToEnemies();
    }
    
    private void AdjustDifficulty()
    {
        // Player is dying a lot → make it easier
        if (playerDeathRate > 2f || playerHealthRatio < 0.2f)
            difficultyScore -= 0.01f * Time.deltaTime;
        
        // Player is dominating → make it harder
        else if (playerKillRate > 10f && playerHealthRatio > 0.8f)
            difficultyScore += 0.01f * Time.deltaTime;
        
        difficultyScore = Mathf.Clamp01(difficultyScore);
    }
    
    private void ApplyToEnemies()
    {
        // Scale enemy stats based on difficulty
        float enemyHealthMult  = Mathf.Lerp(0.5f, 2.0f,  difficultyScore);
        float enemyDamageMult  = Mathf.Lerp(0.5f, 1.5f,  difficultyScore);
        float enemySpeedMult   = Mathf.Lerp(0.8f, 1.2f,  difficultyScore);
        float spawnRateSeconds = Mathf.Lerp(8f,   2f,     difficultyScore);
        
        EnemySpawner.Instance.SpawnInterval  = spawnRateSeconds;
        EnemySpawner.Instance.HealthMult     = enemyHealthMult;
        EnemySpawner.Instance.DamageMult     = enemyDamageMult;
        EnemySpawner.Instance.SpeedMult      = enemySpeedMult;
    }
}

public class CrowdAgent : MonoBehaviour
{
    public float maxSpeed   = 3.5f;
    public float radius     = 0.5f;
    public float timeHorizon = 2f;   // seconds to look ahead for collisions
    
    private Vector3 preferredVelocity; // where we want to go
    private Vector3 currentVelocity;
    
    private void Update()
    {
        // Desired velocity = straight to goal
        preferredVelocity = (goal - transform.position).normalized * maxSpeed;
        
        // Compute avoidance velocity using ORCA
        var neighbors = GetNearbyAgents(4f);
        currentVelocity = ComputeORCAVelocity(preferredVelocity, neighbors);
        
        transform.position += currentVelocity * Time.deltaTime;
    }
    
    private Vector3 ComputeORCAVelocity(Vector3 preferred, List<CrowdAgent> neighbors)
    {
        // For each neighbor, compute velocity obstacle half-plane
        // Find velocity closest to preferred that satisfies all constraints
        // Full implementation: use RVO2 library or Unity's built-in NavMeshAgent
        // This is simplified — real ORCA requires linear programming solver
        
        Vector3 result = preferred;
        foreach (var neighbor in neighbors)
        {
            Vector3 relPos = neighbor.transform.position - transform.position;
            Vector3 relVel = currentVelocity - neighbor.currentVelocity;
            float   dist   = relPos.magnitude;
            float   minDist = radius + neighbor.radius;
            
            if (dist < minDist + 0.5f) // too close — push away
            {
                Vector3 pushDir = (transform.position - neighbor.transform.position).normalized;
                result += pushDir * (minDist - dist) * 0.5f;
            }
        }
        return Vector3.ClampMagnitude(result, maxSpeed);
    }
}