TrafficController.pde

import java.util.function.Supplier;
import java.util.Stack;

class TrafficController implements GameElement {
  // ----- Fields
  
  private final float timeToStart = 2.35f;
  private final float vehicleCullInterval = 2.5f;
  private final float hVehicleMinSpeed = 3, hVehicleMaxSpeed = 5;
  private final float vVehicleMinSpeed = 3, vVehicleMaxSpeed = 5;
  
  private final Scene gameScene;
  private final IntLabel score;
  
  private final Stack<Vehicle> inactiveVVehicles = new Stack<Vehicle>();
  private final Stack<Vehicle> inactiveHVehicles = new Stack<Vehicle>();
  private final Stack<Vehicle> activeVVehicles = new Stack<Vehicle>();
  private final Stack<Vehicle> activeHVehicles = new Stack<Vehicle>();
  private final MultiCollection<Vehicle> activeVehicles = new MultiCollection<Vehicle>(activeVVehicles, activeHVehicles);
  
  private final RoadLane[] lanes = new RoadLane[] {
    new RoadLane(new Vec2Int(-100, 400), Vec2Int.UP, vVehicleMinSpeed, vVehicleMaxSpeed, this::takeVVehicle),
    new RoadLane(new Vec2Int(0, 400), Vec2Int.UP, vVehicleMinSpeed, vVehicleMaxSpeed, this::takeVVehicle),
    new RoadLane(new Vec2Int(100, 400), Vec2Int.UP, vVehicleMinSpeed, vVehicleMaxSpeed, this::takeVVehicle),
    new RoadLane(new Vec2Int(-900, -100), Vec2Int.RIGHT, hVehicleMinSpeed, hVehicleMaxSpeed, this::takeHVehicle),
    new RoadLane(new Vec2Int(-900, 0), Vec2Int.RIGHT, hVehicleMinSpeed, hVehicleMaxSpeed, this::takeHVehicle),
    new RoadLane(new Vec2Int(-900, 100), Vec2Int.RIGHT, hVehicleMinSpeed, hVehicleMaxSpeed, this::takeHVehicle)
  };
  
  private TrafficLight trafficLight;
  
  private float startTimer;
  private boolean timerOut;
  private boolean gameStarted;
  
  private float vehicleCullTimer = vehicleCullInterval;
  
  // ----- Constructors
  
  public TrafficController(Scene gameScene) {
    this.gameScene = gameScene;
 //<>//
    score = (IntLabel)gameScene.firstElement(e -> e instanceof IntLabel);
  }
  
  // ----- Methods
  
  @Override
  public void draw() {
    float deltaTime = 1f / frameRate;
    
    if (!timerOut) {
      startTimer += deltaTime;
      timerOut = startTimer >= timeToStart;
      return;
    }
    
    if (!gameStarted) {
      onGameStart();
      gameStarted = true;
      return;
    }
    
    for (RoadLane lane : lanes) {
      lane.draw();
    }
    
    vehicleCullTimer -= deltaTime;
    if (vehicleCullTimer <= 0f) {
      cullVehicles();
      vehicleCullTimer = vehicleCullInterval;
    }
    
    for (Vehicle v : activeVVehicles) {
      if (v.position.y <= -375) {
        disableVehicle(v);
        score.increaseValue(1);
        break;
      }
    }
  }
  
  private void onGameStart() {
    trafficLight = (TrafficLight)gameScene.firstElement(e -> e instanceof TrafficLight);
    trafficLight.setState(LightColor.GREEN);
    
    TweenEngineHelpers.tween(score, JuicyIntLabelTweenAccessor.ALPHA_ID, .5f)
    .target(255)
    .delay(.45f)
    .start(tweenManager);
  }
  
  private void cullVehicles() {
    final int margin = 200;
    final int rightLimit = width / 2 + margin, topLimit = -height / 2 - margin;
    
    var toDisable = new ArrayList<Vehicle>();
    for (Vehicle v : activeHVehicles) {
      if (v.position.x >= rightLimit)
        toDisable.add(v);
    }
    
    for (Vehicle v : toDisable) {
      disableVehicle(v);
    }
  }
  
  private Vehicle takeVehicle(Stack<Vehicle> inactiveSource, Stack<Vehicle> activeSource, Supplier<Vehicle> factory) {
    if (inactiveSource.isEmpty()) {
      var newVehicle = factory.get();
      gameScene.add(newVehicle);
      inactiveSource.push(newVehicle);
    }
      
    Vehicle val = inactiveSource.pop();
    activeSource.push(val);
    return val;
  }
  
  private Vehicle takeVVehicle() {
    return takeVehicle(inactiveVVehicles, activeVVehicles, () -> new ControlledVehicle(trafficLight, this::onVehicleDestroyed));
  }
  
  private Vehicle takeHVehicle() {
    return takeVehicle(inactiveHVehicles, activeHVehicles, () -> new Vehicle(this::onVehicleDestroyed));
  }
  
  private void onVehicleDestroyed(Vehicle subject) {
    disableVehicle(subject);
  }
  
  private void disableVehicle(Vehicle val) {
    val.disable();
    
    if (val instanceof ControlledVehicle) {
      activeVVehicles.remove(val);
      inactiveVVehicles.push((ControlledVehicle)val);
    } else {
      activeHVehicles.remove(val);
      inactiveHVehicles.push(val);
    }
  }
  
  // ----- Nested Types
  
  private class RoadLane implements GameElement {
    // ----- Fields
    
    private static final int numOfLanes = 3;
    
    private final Vec2Int vehicleSpawnPos;
    private final Vec2Int direction;
    private final float minSpeed, maxSpeed;
    private final Supplier<Vehicle> takeVehicle;
    
    private float vehicleSpawnTimer;
    private float[] laneDelays = new float[numOfLanes];
    
    // ----- Constructors
    
    public RoadLane(Vec2Int vehicleSpawnPos, Vec2Int dir, float minSpeed, float maxSpeed, Supplier<Vehicle> takeVehicle) {
      this.vehicleSpawnPos = vehicleSpawnPos;
      direction = dir;
      this.minSpeed = minSpeed;
      this.maxSpeed = maxSpeed;
      this.takeVehicle = takeVehicle;
      
      vehicleSpawnTimer = random(10f);
    }
    
    // ----- Methods
    
    @Override
    public void draw() {
      vehicleSpawnTimer -= 1f / frameRate;
      
      if (vehicleSpawnTimer <= 0f) {
        spawnVehicle();
        scheduleNextVehicleSpawn();
      }
      
      for (var vehicle : activeVVehicles) {
        RectCollider current = vehicle.getCollider();
        if (current == null) continue;
        
        for (var otherVehicle : activeVehicles) {
          if (otherVehicle == vehicle) continue;
          
          RectCollider other = otherVehicle.getCollider();
          if (other == null) continue;
          
          if (current.intersects(other)) {
            vehicle.destroy(true);
            otherVehicle.destroy(true);
            
            score.increaseValue(-5);
          }
        }
      }
    }
    
    private void spawnVehicle() {
      int laneIndex = (int)random(numOfLanes);
      
      Vehicle spawned = takeVehicle.get();
      spawned.position = vehicleSpawnPos;
      spawned.initAndEnable(direction, minSpeed, maxSpeed); //<>//
    }
    
    private void scheduleNextVehicleSpawn() {
      final float minTime = 5f, maxTime = 10f;
      vehicleSpawnTimer = random(minTime, maxTime);
    }
  }
}