Script Nou - Processing

Lista scripturi Script Nou Ajutor
ID	Autor	Duplicat din	Ultima modificare
`#7235`	7B-Necsulescu Stefan Matei (Stefan_Matei_Necsulescu)	-	Duminica, 17 mai 2026, 11:23
Noile Controale:
Mișcare player: W, A, S, D (și Shift pentru ghemuit / crouch).
Privire (Cameră): I (sus), K (jos), J (stânga), L (dreapta).
Minare / Distrugere bloc: Apasă tasta U.
Plasare bloc / Construire: Apasă tasta O.
Săritură: Space (Spațiu).
Meniu Inventar: Tasta E
// =========================
// SETTINGS & GLOBALS
// =========================
let world = new Map();
let visibleBlocks = [];
let needsMeshUpdate = true;
let chunks = new Set();
let particles = [];
let clouds = [];
let mobs = [];

const chunkSize = 4;
const renderDistance = 3; 
const blockSize = 40;
let eyeHeight = 50;
const normalEyeHeight = 50;
const crouchEyeHeight = 30;

// Block & Item IDs
const AIR = 0, GRASS = 1, STONE = 2, WOOD = 3, LEAVES = 4, BRICK = 5, CHEST = 6, GLASS = 7, PLANKS = 8, CRAFTING_TABLE = 9, SWORD = 10;

const blockNames = {
  [GRASS]: "Iarbă", [STONE]: "Piatră", [WOOD]: "Lemn", [LEAVES]: "Frunze",
  [BRICK]: "Cămidă", [GLASS]: "Sticlă", [PLANKS]: "Scânduri", [CRAFTING_TABLE]: "Crafting Table", [SWORD]: "Sabie"
};

const breakTimes = {
  [GRASS]: 10, [STONE]: 30, [WOOD]: 20, [LEAVES]: 4, [BRICK]: 40, [CHEST]: 15, [GLASS]: 5, [PLANKS]: 15, [CRAFTING_TABLE]: 25
};

let breakingBlock = null;
let breakProgress = 0;

// =========================
// PLAYER
// =========================
let pX = 0, pY = -300, pZ = 0;
let rotX = 0, rotY = 0;
let velocityY = 0;
let isGrounded = false;
let isCrouching = false;
let playerRadius = 12;
let health = 100, maxHealth = 100;

// =========================
// INVENTORY SYSTEM (REPARAT)
// =========================
let showInventory = false;
let hotbar = [SWORD, GRASS, STONE, WOOD, AIR, AIR, AIR, AIR, AIR];
let selectedSlot = 0; 

let inventorySlots = [
  { id: STONE, count: 32 },
  { id: WOOD, count: 10 },
  { id: SWORD, count: 1 }
];
for(let i = inventorySlots.length; i < 27; i++) inventorySlots.push({ id: AIR, count: 0 });

let lootMessage = "Controale: WASD = Mișcare | IJKL = Cameră | U = Minează | O = Pune Bloc";
let lootTimer = 180;

// =========================
// SETUP
// =========================
function setup() {
  createCanvas(windowWidth, windowHeight, WEBGL);
  noiseSeed(99);
  document.body.style.overflow = "hidden";
  document.oncontextmenu = () => false;

  for(let i=0; i<15; i++) {
    clouds.push({ x: random(-2000, 2000), y: random(-800, -500), z: random(-2000, 2000), w: random(100, 300) });
  }
}

// =========================
// MAIN LOOP
// =========================
function draw() {
  let skyBrightness = map(sin(millis()/40000), -1, 1, 40, 255);
  background(skyBrightness * 0.5, skyBrightness * 0.8, skyBrightness);
  
  ambientLight(map(sin(millis()/40000), -1, 1, 60, 180));
  directionalLight(255, 255, 255, 0.5, -1, 0.3);
  pointLight(255, 230, 180, pX, pY, pZ);

  if (!showInventory) {
    handleInput();          
    handleCameraInput();    
    handleBlockBreaking();  
  }
  
  handlePhysics();
  updateCamera();

  renderWorld();
  updateMobs();
  drawClouds();
  updateParticles();

  if (!showInventory) drawCursor();
  
  drawUI();
}

// =========================
// CAMERA & RAYCAST
// =========================
function updateCamera() {
  eyeHeight = lerp(eyeHeight, isCrouching ? crouchEyeHeight : normalEyeHeight, 0.2);
  let camY = pY - eyeHeight;
  
  let lookX = sin(rotY) * cos(rotX);
  let lookY = sin(rotX);
  let lookZ = -cos(rotY) * cos(rotX);

  camera(pX, camY, pZ, pX + lookX, camY + lookY, pZ + lookZ, 0, 1, 0);
  perspective(PI/3, width/height, 0.1, 8000);
}

function handleCameraInput() {
  let camSpeed = 0.04;
  if (keyIsDown(73)) rotX -= camSpeed; 
  if (keyIsDown(75)) rotX += camSpeed; 
  if (keyIsDown(74)) rotY -= camSpeed; 
  if (keyIsDown(76)) rotY += camSpeed; 

  rotX = constrain(rotX, -1.4, 1.4);
}

function raycast() {
  let maxDist = 200;
  let camY = pY - eyeHeight;
  let dirX = sin(rotY) * cos(rotX);
  let dirY = sin(rotX);
  let dirZ = -cos(rotY) * cos(rotX);

  let lastX = floor(pX / blockSize), lastY = floor(-camY / blockSize), lastZ = floor(pZ / blockSize);

  for (let d = 0; d < maxDist; d += 2.0) { 
    let rx = pX + dirX * d, ry = camY + dirY * d, rz = pZ + dirZ * d;
    let bx = floor(rx / blockSize), by = floor(-ry / blockSize), bz = floor(rz / blockSize);

    if (getBlock(bx, by, bz) !== AIR) {
      return { hit: { x: bx, y: by, z: bz }, prev: { x: lastX, y: lastY, z: lastZ } };
    }
    lastX = bx; lastY = by; lastZ = bz;
  }
  return null;
}

// =========================
// LOGICA INVENTAR REPARATĂ COMPLET
// =========================
function addItemToInventory(type) {
  if (type === AIR) return;
  
  // 1. Încearcă să adaugi la un slot existent care are același tip
  for (let slot of inventorySlots) {
    if (slot.id === type && slot.count < 64) {
      slot.count++;
      return;
    }
  }
  // 2. Dacă nu există, pune în primul slot gol
  for (let slot of inventorySlots) {
    if (slot.id === AIR) {
      slot.id = type;
      slot.count = 1;
      return;
    }
  }
  lootMessage = "Inventar plin!"; lootTimer = 60;
}

function countItems(type) {
  let total = 0;
  for (let slot of inventorySlots) {
    if (slot.id === type) total += slot.count;
  }
  return total;
}

function removeItem(type, amount) {
  for (let slot of inventorySlots) {
    if (slot.id === type) {
      if (slot.count >= amount) {
        slot.count -= amount;
        if (slot.count === 0) slot.id = AIR;
        return;
      } else {
        amount -= slot.count;
        slot.id = AIR;
        slot.count = 0;
      }
    }
  }
}

// =========================
// WORLD GENERATION & RENDERING
// =========================
function keyXYZ(x, y, z) { return `${x},${y},${z}`; }
function getBlock(x, y, z) { return world.get(keyXYZ(x, y, z)) || 0; }

function setBlock(x, y, z, type) {
  if (type === 0) world.delete(keyXYZ(x, y, z));
  else world.set(keyXYZ(x, y, z), type);
  needsMeshUpdate = true;
}

function generateChunk(cx, cz) {
  const chunkID = `${cx},${cz}`;
  if (chunks.has(chunkID)) return;
  chunks.add(chunkID);

  for (let x = 0; x < chunkSize; x++) {
    for (let z = 0; z < chunkSize; z++) {
      let wx = cx * chunkSize + x, wz = cz * chunkSize + z;
      let h = floor(noise(wx * 0.05, wz * 0.05) * 8) + 5;

      for (let y = 0; y < h; y++) {
        if (y === h - 1) setBlock(wx, y, wz, GRASS);
        else setBlock(wx, y, wz, STONE);
      }
      if (random() < 0.015) spawnTree(wx, h, wz);
      if (random() < 0.003) mobs.push(new Mob(wx * blockSize, -h * blockSize, wz * blockSize));
    }
  }
  needsMeshUpdate = true;
}

function spawnTree(x, y, z) {
  let h = floor(random(3, 5));
  for (let i = 0; i < h; i++) setBlock(x, y + i, z, WOOD);
  setBlock(x, y + h, z, LEAVES);
}

function updateVisibleMesh() {
  visibleBlocks = [];
  let maxDistSq = pow(renderDistance * chunkSize * blockSize * 1.5, 2);

  for (let [k, type] of world.entries()) {
    let [x, y, z] = k.split(",").map(Number);
    let wx = x * blockSize, wy = -y * blockSize, wz = z * blockSize;

    if (distSq(wx, wz, pX, pZ) > maxDistSq) continue;

    let visible = getBlock(x+1,y,z)===AIR || getBlock(x-1,y,z)===AIR ||
                  getBlock(x,y+1,z)===AIR || getBlock(x,y-1,z)===AIR ||
                  getBlock(x,y,z+1)===AIR || getBlock(x,y,z-1)===AIR;
                  
    if (visible) visibleBlocks.push({ x, y, z, wx, wy, wz, type });
  }
}

function renderWorld() {
  let pcx = floor(pX / blockSize / chunkSize), pcz = floor(pZ / blockSize / chunkSize);
  for (let cx = pcx - renderDistance; cx <= pcx + renderDistance; cx++) {
    for (let cz = pcz - renderDistance; cz <= pcz + renderDistance; cz++) {
      generateChunk(cx, cz);
    }
  }

  if (frameCount === 2) {
    for (let i = 20; i < 50; i++) {
      if (!checkCollision(0, -i * blockSize, 0)) { pY = -i * blockSize; break; }
    }
  }

  if (needsMeshUpdate) { updateVisibleMesh(); needsMeshUpdate = false; }

  for (let b of visibleBlocks) {
    push(); 
    translate(b.wx, b.wy, b.wz);
    let currentSize = blockSize;
    if (breakingBlock && breakingBlock.x === b.x && breakingBlock.y === b.y && breakingBlock.z === b.z) {
      currentSize = lerp(blockSize, blockSize * 0.5, breakProgress / (breakTimes[b.type] || 30));
    }
    applyBlockMaterial(b.type); 
    box(currentSize); 
    pop();
  }
}

function applyBlockMaterial(type) {
  noStroke();
  if (type === GRASS) fill(60, 170, 60);
  else if (type === STONE) fill(110);
  else if (type === WOOD) fill(110, 70, 40);
  else if (type === PLANKS) fill(180, 130, 80);
  else if (type === CRAFTING_TABLE) fill(140, 90, 50);
  else if (type === LEAVES) fill(40, 120, 40);
  else if (type === BRICK) fill(170, 60, 60);
  else if (type === GLASS) { fill(160, 210, 255, 130); stroke(255, 80); }
}

function distSq(x1, z1, x2, z2) { return (x1 - x2) * (x1 - x2) + (z1 - z2) * (z1 - z2); }

// =========================
// MOBS (ZOMBIES)
// =========================
class Mob {
  constructor(x, y, z) { this.pos = createVector(x, y, z); this.hp = 40; this.speed = 1.2; }
  update() {
    let dx = pX - this.pos.x, dz = pZ - this.pos.z;
    let dSq = distSq(this.pos.x, this.pos.z, pX, pZ);
    if (dSq < 90000 && dSq > 800) {
      let ang = atan2(dz, dx);
      this.pos.x += cos(ang) * this.speed; this.pos.z += sin(ang) * this.speed;
    }
    if (dSq < 1500 && frameCount % 45 === 0) { takeDamage(8); lootMessage = "AI FOST LOVIT!"; lootTimer = 40; }
    push(); translate(this.pos.x, this.pos.y - 20, this.pos.z); fill(220, 40, 40); box(30, 50, 30); pop();
  }
}
function updateMobs() {
  for (let i = mobs.length - 1; i >= 0; i--) {
    mobs[i].update();
    if (mobs[i].hp <= 0) { mobs.splice(i, 1); addItemToInventory(STONE); lootMessage = "Mob eliminat! (+1 Piatră)"; lootTimer = 60; }
  }
}

// =========================
// INPUT & PHYSICS
// =========================
function handleInput() {
  isCrouching = keyIsDown(16); 
  let speed = isCrouching ? 2.2 : 4.5;
  let dx = 0, dz = 0;

  if (keyIsDown(87)) { dx += sin(rotY); dz -= cos(rotY); } 
  if (keyIsDown(83)) { dx -= sin(rotY); dz += cos(rotY); } 
  if (keyIsDown(65)) { dx -= cos(rotY); dz -= sin(rotY); } 
  if (keyIsDown(68)) { dx += cos(rotY); dz += sin(rotY); } 

  let len = Math.hypot(dx, dz);
  if (len > 0) { dx = (dx / len) * speed; dz = (dz / len) * speed; }

  pX += dx; if (checkCollision(pX, pY, pZ)) { pY -= blockSize; if (checkCollision(pX, pY, pZ)) { pY += blockSize; pX -= dx; } }
  pZ += dz; if (checkCollision(pX, pY, pZ)) { pY -= blockSize; if (checkCollision(pX, pY, pZ)) { pY += blockSize; pZ -= dz; } }
}

function handlePhysics() {
  velocityY += 0.38; velocityY = constrain(velocityY, -22, 14);
  let steps = ceil(abs(velocityY)), stepAmt = velocityY / steps;

  for (let i = 0; i < steps; i++) {
    let ny = pY + stepAmt;
    if (checkCollision(pX, ny, pZ)) {
      if (velocityY > 0) { isGrounded = true; pY = (-floor((-ny + blockSize/2) / blockSize) * blockSize) - (blockSize/2) - 0.01; }
      velocityY = 0; break;
    } else { pY = ny; isGrounded = false; }
  }
}

function checkCollision(x, y, z) {
  let margin = 3, pMinX = x - playerRadius + margin, pMaxX = x + playerRadius - margin;
  let pH = isCrouching ? normalEyeHeight * 0.7 : normalEyeHeight * 1.4;
  let sX = floor((pMinX + blockSize/2) / blockSize), eX = floor((pMaxX + blockSize/2) / blockSize);
  let sZ = floor((z - playerRadius + margin + blockSize/2) / blockSize), eZ = floor((z + playerRadius - margin + blockSize/2) / blockSize);
  let sY = floor((-(y - margin) + blockSize/2) / blockSize), eY = floor((-(y - pH + margin) + blockSize/2) / blockSize);

  for (let bx = sX; bx <= eX; bx++) {
    for (let by = sY; by <= eY; by++) {
      for (let bz = sZ; bz <= eZ; bz++) { if (getBlock(bx, by, bz) !== AIR) return true; }
    }
  }
  return false;
}

function takeDamage(amount) {
  health -= amount;
  if (health <= 0) { health = maxHealth; pX = 0; pZ = 0; pY = -1200; lootMessage = "AI MURIT!"; lootTimer = 120; }
}

// =========================
// MINING & COMBAT (TASTA U - REPARATĂ)
// =========================
function handleBlockBreaking() {
  if (keyIsDown(85)) { 
    let currentHand = hotbar[selectedSlot];

    for (let m of mobs) {
      if (distSq(pX, pZ, m.pos.x, m.pos.z) < 4500 && abs(pY - m.pos.y) < 80) {
        if (frameCount % 10 === 0) {
          m.hp -= (currentHand === SWORD) ? 20 : 4;
          m.pos.x += sin(rotY) * 12; m.pos.z -= cos(rotY) * 12; 
        }
        return;
      }
    }

    let result = raycast();
    if (!result || !result.hit) { resetMining(); return; }
    let hit = result.hit;

    if (!breakingBlock || hit.x !== breakingBlock.x || hit.y !== breakingBlock.y || hit.z !== breakingBlock.z) {
      breakingBlock = hit; breakProgress = 0;
    }

    let type = getBlock(hit.x, hit.y, hit.z);
    breakProgress++;
    if (frameCount % 3 === 0) particles.push(new Particle(hit.x * blockSize, -hit.y * blockSize, hit.z * blockSize, type));

    if (breakProgress >= (breakTimes[type] || 25)) {
      addItemToInventory(type); // Adaugă corect blocul în inventar
      setBlock(hit.x, hit.y, hit.z, 0); resetMining();
    }
  } else resetMining();
}

function resetMining() { breakingBlock = null; breakProgress = 0; }

// =========================
// PLASARE BLOCURI (TASTA O - REPARATĂ)
// =========================
function placeBlockAction() {
  let currentHand = hotbar[selectedSlot];
  if (currentHand === AIR || currentHand === SWORD) return;

  // Verificăm dacă mai avem blocuri de tipul respectiv în inventar înainte de a plasa
  if (countItems(currentHand) <= 0) {
    lootMessage = "Nu mai ai blocuri de acest tip!"; lootTimer = 60;
    return;
  }

  let result = raycast();
  if (!result) return;
  let { prev } = result;

  if (getBlock(prev.x, prev.y, prev.z) === AIR) {
    setBlock(prev.x, prev.y, prev.z, currentHand);
    if (checkCollision(pX, pY, pZ)) {
      setBlock(prev.x, prev.y, prev.z, AIR);
    } else {
      removeItem(currentHand, 1); // Scade corect 1 bucată din inventar
    }
  }
}

// =========================
// INTERFAȚĂ INVENTAR & CLICK-URI
// =========================
function handleInventoryClicks() {
  let mx = mouseX - width / 2;
  let my = mouseY - height / 2;

  let startX = -210, startY = -60;
  for (let i = 0; i < 27; i++) {
    let row = floor(i / 9), col = i % 9;
    let x = startX + col * 46, y = startY + row * 46;
    if (mx > x && mx < x + 40 && my > y && my < y + 40) {
      if (inventorySlots[i].id !== AIR) {
        hotbar[selectedSlot] = inventorySlots[i].id;
        lootMessage = "Echipat pe hotbar: " + blockNames[inventorySlots[i].id]; lootTimer = 40;
      }
    }
  }

  if (mx > 60 && mx < 240) {
    if (my > -80 && my < -50 && countItems(WOOD) >= 1) { 
      removeItem(WOOD, 1); addItemToInventory(PLANKS);
    }
    if (my > -40 && my < -10 && countItems(PLANKS) >= 4) { 
      removeItem(PLANKS, 4); addItemToInventory(CRAFTING_TABLE);
    }
    if (my > 0 && my < 30 && countItems(WOOD) >= 1 && countItems(STONE) >= 2) { 
      removeItem(WOOD, 1); removeItem(STONE, 2); addItemToInventory(SWORD);
    }
  }
}

function mousePressed() {
  if (showInventory) {
    handleInventoryClicks();
  }
}

// =========================
// RENDER UI & HUD
// =========================
function drawUI() {
  push(); 
  resetMatrix(); 
  ortho(); 
  noLights();
  
  let gl = this._renderer.GL; 
  if (gl) gl.disable(gl.DEPTH_TEST); 

  if (!showInventory) {
    stroke(255); strokeWeight(2); line(-10, 0, 10, 0); line(0, -10, 0, 10); 
  }

  // HUD: Viață
  let barX = -width / 2 + 30, barY = height / 2 - 40;
  noStroke(); fill(40); rect(barX, barY, 200, 18);
  fill(240, 40, 40); rect(barX, barY, map(health, 0, maxHealth, 0, 200), 18);
  fill(255); textSize(12); textAlign(LEFT, TOP); text(`HP: ${health}/${maxHealth}`, barX + 6, barY + 2);

  // HUD: Hotbar
  let hbStartX = -207, hbY = height / 2 - 50;
  for (let i = 0; i < 9; i++) {
    stroke(i === selectedSlot ? color(255, 215, 0) : 100);
    strokeWeight(i === selectedSlot ? 3 : 1); 
    fill(i === selectedSlot ? 70 : 30, 200);
    rect(hbStartX + i * 46, hbY, 40, 40, 4);
    
    let type = hotbar[i];
    if (type !== AIR) {
      noStroke(); fill(255); textSize(11); textAlign(CENTER, CENTER);
      let tCount = countItems(type);
      let label = (type === SWORD) ? "⚔️" : (blockNames[type] ? blockNames[type].substring(0,2) : "??");
      text(`${label}\n(${tCount})`, hbStartX + i * 46 + 20, hbY + 20);
    }
  }

  // Meniul E
  if (showInventory) {
    fill(20, 20, 20, 230); stroke(150); strokeWeight(2); rect(-250, -160, 500, 320, 12);
    fill(255); noStroke(); textSize(18); textAlign(CENTER); text("INVENTAR & MENIU CRAFTING", 0, -135);

    let startX = -210, startY = -60;
    for (let i = 0; i < 27; i++) {
      let row = floor(i / 9), col = i % 9;
      let x = startX + col * 46, y = startY + row * 46;
      
      fill(50); stroke(100); strokeWeight(1); rect(x, y, 40, 40, 4);
      
      if (inventorySlots[i].id !== AIR) {
        noStroke(); fill(255); textSize(11); textAlign(CENTER, CENTER);
        let name = blockNames[inventorySlots[i].id] ? blockNames[inventorySlots[i].id].substring(0, 4) : "??";
        if (inventorySlots[i].id === SWORD) name = "⚔️";
        text(`${name}\n${inventorySlots[i].count}`, x + 20, y + 20);
      }
    }
    
    fill(180); noStroke(); textSize(12); textAlign(LEFT);
    text("* Click pe un item din grilă pentru a-l pune în slotul de hotbar selectat.", -210, 95);

    let cx = 60, cy = -60;
    textSize(14); fill(255); text("CRAFTING:", cx, cy - 15);
    
    fill(countItems(WOOD) >= 1 ? color(40, 150, 40) : 60); rect(cx, cy, 170, 26, 4);
    fill(255); text("Scânduri x4 (1 Lemn)", cx + 10, cy + 18);
    
    fill(countItems(PLANKS) >= 4 ? color(40, 150, 40) : 60); rect(cx, cy + 40, 170, 26, 4);
    fill(255); text("Crafting Table (4 Scând.)", cx + 10, cy + 58);

    fill((countItems(WOOD) >= 1 && countItems(STONE) >= 2) ? color(40, 150, 40) : 60); rect(cx, cy + 80, 170, 26, 4);
    fill(255); text("Sabie Piatră (1L + 2P)", cx + 10, cy + 98);
  }

  if (lootTimer > 0) {
    fill(255, 255, 0); textSize(14); textAlign(CENTER); text(lootMessage, 0, -height/2 + 30); lootTimer--;
  }
  
  if (gl) gl.enable(gl.DEPTH_TEST); 
  pop();
}

function drawCursor() {
  let result = raycast();
  if (result && result.hit) {
    let { x, y, z } = result.hit;
    push(); translate(x * blockSize, -y * blockSize, z * blockSize);
    noFill(); stroke(0); strokeWeight(2); box(blockSize + 1); pop();
  }
}

function keyPressed() {
  if (key === " " && isGrounded && !showInventory) { velocityY = -7.2; isGrounded = false; }
  
  if (key.toLowerCase() === "e") {
    showInventory = !showInventory;
  }

  if (key.toLowerCase() === "o" && !showInventory) {
    placeBlockAction();
  }
  
  if (key >= '1' && key <= '9') {
    selectedSlot = parseInt(key) - 1;
  }
}

function windowResized() { resizeCanvas(windowWidth, windowHeight); }

// =========================
// ALTE ELEMENTE (PARTICULE & NORI)
// =========================
class Particle {
  constructor(x, y, z, type) {
    this.pos = createVector(x + random(-8, 8), y + random(-8, 8), z + random(-8, 8));
    this.vel = createVector(random(-1.5, 1.5), random(-4, -1), random(-1.5, 1.5));
    this.life = 255; this.type = type;
  }
  update() { this.vel.y += 0.4; this.pos.add(this.vel); this.life -= 18; }
  display() {
    push(); translate(this.pos.x, this.pos.y, this.pos.z); applyBlockMaterial(this.type); box(6); pop();
  }
}
function updateParticles() {
  for (let i = particles.length - 1; i >= 0; i--) {
    particles[i].update(); particles[i].display(); if (particles[i].life <= 0) particles.splice(i, 1);
  }
}
function drawClouds() {
  noStroke(); fill(255, 160);
  for (let c of clouds) {
    push(); translate(c.x, c.y, c.z); box(c.w, 35, c.w * 0.7); pop();
    c.x += 0.4; if (c.x > 2000) c.x = -2000;
  }
}
Du-te sus!