Drift Hell - Processing

Lista scripturi Script Nou Ajutor
ID	Autor	Duplicat din	Ultima modificare
`#7250`	7B-Necsulescu Stefan Matei (Stefan_Matei_Necsulescu)	-	Marti, 19 mai 2026, 14:43
let car;
let trackWalls = [];
let particles = [];

// UI & Score (Elemente DOM pentru zero lag)
let score = 0;
let driftScore = 0;
let multiplier = 1;
let isDrifting = false;

// Elementele HTML
let scoreDiv, driftDiv, speedDiv;

function setup() {
  createCanvas(400, 400, WEBGL);
  pixelDensity(1); // Optimizare obligatorie pentru ecrane de înaltă rezoluție
  
  car = new DriftCar(0, 0);
  generateArena();
  
  // --- HUD HTML OVERLAY (Pentru performanță maximă) ---
  scoreDiv = createDiv('SCOR: 0');
  scoreDiv.position(20, 20);
  scoreDiv.style('color', '#00FFFF');
  scoreDiv.style('font-family', 'sans-serif');
  scoreDiv.style('font-size', '20px');
  scoreDiv.style('font-weight', 'bold');
  scoreDiv.style('text-shadow', '0 0 5px #00FFFF');
  
  driftDiv = createDiv('');
  driftDiv.position(20, 50);
  driftDiv.style('color', '#FF0080');
  driftDiv.style('font-family', 'sans-serif');
  driftDiv.style('font-size', '24px');
  driftDiv.style('font-weight', 'bold');
  driftDiv.style('text-shadow', '0 0 5px #FF0080');
  
  speedDiv = createDiv('VITEZĂ: 0 km/h');
  speedDiv.position(20, 85);
  speedDiv.style('color', '#FFFFFF');
  speedDiv.style('font-family', 'sans-serif');
  speedDiv.style('font-size', '16px');
}

function draw() {
  background(10, 10, 15);
  
  // Lumini
  ambientLight(80, 80, 150);
  directionalLight(255, 0, 128, 1, 1, -1);
  directionalLight(0, 255, 255, -1, 1, -1);

  // Cameră dinamică - trasă mai în spate pentru a accentua senzația de viteză
  let targetCamX = car.pos.x - cos(car.angle) * 350;
  let targetCamY = car.pos.y - sin(car.angle) * 350;
  
  camera(
    lerp(camX(), targetCamX, 0.1), lerp(camY(), targetCamY, 0.1), 180, // Camera mai sus (180)
    car.pos.x, car.pos.y, 10,
    0, 0, -1
  );

  drawGrid();
  for (let wall of trackWalls) wall.display();

  // Particule de fum optimizate
  if (isDrifting && car.vel.mag() > 3) {
    particles.push(new SmokeParticle(car.pos.x - cos(car.angle)*20, car.pos.y - sin(car.angle)*20));
  }
  
  // Limită strictă de particule (Max 30)
  if (particles.length > 30) particles.shift();

  for (let i = particles.length - 1; i >= 0; i--) {
    particles[i].update();
    particles[i].display();
    if (particles[i].alpha <= 0) particles.splice(i, 1);
  }

  car.update();
  car.display();
  
  handleScoring();
  updateHUD();
}

// Funcții ajutătoare pentru camera lerp
function camX() { return _renderer._curCamera.eyeX; }
function camY() { return _renderer._curCamera.eyeY; }

class DriftCar {
  constructor(x, y) {
    this.pos = createVector(x, y);
    this.vel = createVector(0, 0);
    this.angle = 0;
    
    // --- VITEZĂ CRESCUTĂ ---
    this.speed = 0;
    this.maxSpeed = 25;     // Mult mai rapidă
    this.acc = 0.8;         // Accelerație mai agresivă
    this.friction = 0.97;   // Păstrează viteza mai mult
    
    this.driftTraction = 0.90; // Alunecă mai lin
    this.normalTraction = 0.95;
  }

  update() {
    if (keyIsDown(87) || keyIsDown(UP_ARROW)) this.speed += this.acc;
    else if (keyIsDown(83) || keyIsDown(DOWN_ARROW)) this.speed -= this.acc * 1.5; // Frână mai puternică
    else this.speed *= this.friction;
    
    this.speed = constrain(this.speed, -this.maxSpeed/3, this.maxSpeed);

    let currentSteer = 0;
    // Vira mai strâns la viteze mari
    let steerPower = map(this.vel.mag(), 0, this.maxSpeed, 0.03, 0.08); 
    if (keyIsDown(65) || keyIsDown(LEFT_ARROW)) currentSteer = -steerPower;
    if (keyIsDown(68) || keyIsDown(RIGHT_ARROW)) currentSteer = steerPower; 
    
    this.angle += currentSteer;

    let forward = createVector(cos(this.angle), sin(this.angle));
    forward.setMag(this.speed);

    let slipAngle = abs(this.vel.heading() - this.angle);
    if (slipAngle > PI) slipAngle = TWO_PI - slipAngle;

    // Condiție pentru drift (viteză mai mare necesară acum)
    isDrifting = (slipAngle > 0.25 && this.vel.mag() > 8);
    let currentTraction = isDrifting ? this.driftTraction : this.normalTraction;

    this.vel = p5.Vector.lerp(this.vel, forward, 1 - currentTraction);
    this.pos.add(this.vel);
    
    this.pos.x = constrain(this.pos.x, -1900, 1900); // Arenă mai mare
    this.pos.y = constrain(this.pos.y, -1900, 1900);
  }

  display() {
    push();
    translate(this.pos.x, this.pos.y, 10);
    rotateZ(this.angle);
    
    fill(0, 255, 255);
    stroke(255, 0, 128);
    strokeWeight(1);
    box(45, 22, 15);
    
    translate(10, 0, 8);
    fill(255);
    box(12, 18, 4); // Parbriz
    pop();
  }
}

class SmokeParticle {
  constructor(x, y) {
    this.pos = createVector(x, y, 2);
    this.vel = p5.Vector.random2D().mult(0.5);
    this.alpha = 180;
    this.size = random(10, 20);
  }
  update() {
    this.pos.add(this.vel);
    this.alpha -= 12; // Dispare mai repede = mai puține particule de randat
    this.size += 0.8;
  }
  display() {
    push();
    translate(this.pos.x, this.pos.y, this.pos.z);
    noStroke();
    fill(255, 255, 255, this.alpha);
    plane(this.size, this.size); 
    pop();
  }
}

class Obstacle {
  constructor(x, y, h) {
    this.x = x; this.y = y; this.h = h;
  }
  display() {
    push();
    translate(this.x, this.y, this.h / 2);
    fill(20, 20, 30);
    stroke(0, 255, 255);
    strokeWeight(2);
    box(50, 50, this.h);
    pop();
  }
}

function generateArena() {
  for (let i = 0; i < 12; i++) {
    trackWalls.push(new Obstacle(random(-1200, 1200), random(-1200, 1200), random(50, 150)));
  }
}

function drawGrid() {
  stroke(40, 40, 80);
  strokeWeight(1);
  let gridSize = 300; // Grilă mai largă, mai puține linii
  for (let x = -2000; x <= 2000; x += gridSize) {
    line(x, -2000, 0, x, 2000, 0);
    line(-2000, x, 0, 2000, x, 0);
  }
}

function handleScoring() {
  if (isDrifting) {
    driftScore += floor(car.vel.mag() * multiplier * 0.1);
    if (frameCount % 30 === 0) multiplier++;
  } else {
    if (driftScore > 0) {
      score += driftScore;
      driftScore = 0;
      multiplier = 1;
    }
  }
}

// Actualizarea textelor HTML (Fără a re-randa texturi 3D)
function updateHUD() {
  scoreDiv.html(`SCOR TOTAL: ${score + driftScore}`);
  
  if (isDrifting) {
    driftDiv.html(`DRIFT x${multiplier} (+${driftScore})`);
  } else {
    driftDiv.html('');
  }
  
  let speedKmh = floor(car.vel.mag() * 10);
  speedDiv.html(`VITEZĂ: ${speedKmh} km/h`);
}
Du-te sus!