Script Nou - Processing

Lista scripturi Script Nou Ajutor
ID	Autor	Duplicat din	Ultima modificare
`#7236`	7B-Necsulescu Stefan Matei (Stefan_Matei_Necsulescu)	-	Duminica, 17 mai 2026, 12:08
<!DOCTYPE html>
<html lang="ro">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>CraftCraft 3D - Ediție Completă în p5.js</title>
    <!-- Includem librăria p5.js -->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.9.0/p5.min.js"></script>
    <style>
        html, body {
            margin: 0;
            padding: 0;
            overflow: hidden;
            background-color: #78a7ff;
            font-family: 'Courier New', Courier, monospace;
            user-select: none;
        }
        #canvas-container {
            width: 100vw;
            height: 100vh;
            display: block;
        }
        #hud {
            position: absolute;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            display: flex;
            flex-direction: column;
            align-items: center;
            gap: 10px;
            pointer-events: none;
            z-index: 10;
        }
        #hp-bar-container {
            width: 240px;
            height: 20px;
            background: #222;
            border: 2px solid #fff;
            position: relative;
        }
        #hp-bar {
            width: 100%;
            height: 100%;
            background: #e61c1c;
        }
        #hp-text {
            position: absolute;
            width: 100%;
            text-align: center;
            color: white;
            font-size: 11px;
            font-weight: bold;
            line-height: 20px;
            top: 0;
        }
        #hotbar {
            display: flex;
            gap: 5px;
            background: rgba(30,30,30,0.9);
            padding: 6px;
            border: 3px solid #666;
            pointer-events: auto;
        }
        .slot {
            width: 50px;
            height: 50px;
            background: rgba(10,10,10,0.6);
            border: 2px solid #444;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            color: white;
            font-size: 10px;
            font-weight: bold;
            text-align: center;
            box-sizing: border-box;
        }
        .slot.selected {
            border-color: #ffffff;
            outline: 2px solid #ffcc00;
            background: rgba(100,100,100,0.4);
        }
        #crosshair {
            position: absolute;
            top: 50%;
            left: 50%;
            width: 16px;
            height: 16px;
            transform: translate(-50%, -50%);
            pointer-events: none;
            z-index: 5;
        }
        #crosshair::before, #crosshair::after {
            content: '';
            position: absolute;
            background: rgba(255,255,255,0.85);
        }
        #crosshair::before { top: 7px; left: 0; width: 16px; height: 2px; }
        #crosshair::after { top: 0; left: 7px; width: 2px; height: 16px; }

        #inventory-screen {
            display: none;
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 600px;
            height: 440px;
            background: rgba(25, 25, 25, 0.98);
            border: 4px solid #555;
            color: white;
            z-index: 20;
            padding: 20px;
            box-sizing: border-box;
        }
        .inv-grid {
            display: grid;
            grid-template-columns: repeat(9, 1fr);
            gap: 6px;
            margin-top: 10px;
        }
        .inv-slot {
            width: 48px;
            height: 48px;
            background: #1a1a1a;
            border: 2px solid #333;
            cursor: pointer;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            font-size: 9px;
            font-weight: bold;
            text-align: center;
        }
        .inv-slot:hover { background: #2a2a2a; border-color: #ffcc00; }
        
        .close-btn {
            float: right;
            background: #bc2626;
            color: white;
            border: none;
            padding: 6px 12px;
            cursor: pointer;
            font-weight: bold;
            font-family: inherit;
        }
        .close-btn:hover { background: #e53939; }

        #crafting-section {
            margin-top: 15px;
            display: grid;
            grid-template-columns: repeat(2, 1fr);
            gap: 8px;
        }
        .craft-btn {
            background: #3a3a3a;
            color: white;
            border: 2px solid #555;
            padding: 8px;
            cursor: pointer;
            font-family: inherit;
            font-size: 11px;
            text-align: left;
        }
        .craft-btn:hover { border-color: #ffcc00; background: #444; }
        
        #notifications {
            position: absolute;
            top: 65px;
            left: 50%;
            transform: translateX(-50%);
            color: #ffff00;
            font-weight: bold;
            text-shadow: 1px 1px 3px #000;
            z-index: 10;
            pointer-events: none;
        }
        #info-panel {
            position: absolute;
            top: 10px;
            left: 10px;
            background: rgba(0,0,0,0.75);
            color: white;
            padding: 10px;
            font-size: 11px;
            z-index: 10;
            pointer-events: none;
        }
    </style>
</head>
<body>

    <div id="info-panel">
        <b>MIGRAT COMPLET LA P5.JS</b><br>
        • Mișcare fluidă a mâinii în timpul mersului (Bobbing)<br>
        • Animație completă de Swing (atac/minat) pe click stânga<br>
        • Animație de plasare (recul) pe click dreapta<br>
        • Deschide Inventar / Crafting: Tasta <b>E</b> | Schimbă slot: <b>1 - 9</b><br>
        • Mișcare: W, A, S, D | Sarituri: SPACE
    </div>

    <div id="notifications">Dă un click pe ecran pentru a activa camera!</div>
    <div id="crosshair"></div>

    <div id="hud">
        <div id="hp-bar-container">
            <div id="hp-bar"></div>
            <div id="hp-text">HP: 100/100</div>
        </div>
        <div id="hotbar"></div>
    </div>

    <div id="inventory-screen">
        <button class="close-btn" onclick="toggleInventory()">X</button>
        <h3 style="margin: 0;">INVENTAR & SURVIVAL CRAFT (p5.js)</h3>
        <p style="font-size: 11px; color: #ccc; margin: 5px 0;">Click pe un item din grilă pentru a-l pune în slotul activ din Hotbar.</p>
        <div class="inv-grid" id="inv-grid-container"></div>
        
        <h4 style="margin: 15px 0 5px 0;">REȚETE DISPONIBILE:</h4>
        <div id="crafting-section">
            <button class="craft-btn" onclick="craftItem('planks')">🪵 Scânduri x4 <br><small>Cost: 1 Lemn Brut</small></button>
            <button class="craft-btn" onclick="craftItem('sticks')">🥢 Bețe x4 <br><small>Cost: 2 Scânduri</small></button>
            <button class="craft-btn" onclick="craftItem('pickaxe')">⛏️ Târnăcop Piatră <br><small>Cost: 3 Piatră + 2 Bețe</small></button>
            <button class="craft-btn" onclick="craftItem('sword')">⚔️ Sabie Oțel <br><small>Cost: 2 Piatră + 1 Băț</small></button>
            <button class="craft-btn" onclick="craftItem('torch')">🕯️ Torțe x4 <br><small>Cost: 1 Cărbune + 1 Băț</small></button>
            <button class="craft-btn" onclick="craftItem('glass')">💎 Geam de Sticlă <br><small>Cost: Topire 2 Iarbă</small></button>
        </div>
    </div>

    <div id="canvas-container"></div>

<script>
// ==========================================
// CONFIGURAȚIE BLOCURI ȘI METADATE
// ==========================================
const AIR = 0, GRASS = 1, STONE = 2, WOOD = 3, LEAVES = 4, BRICK = 5, GLASS = 6, PLANKS = 7, SWORD = 8, COAL = 9, PICKAXE = 10, STICK = 11, TORCH = 12;

const blockNames = { 
    [AIR]:"Aer", [GRASS]:"Iarbă", [STONE]:"Piatră", [WOOD]:"Lemn", [LEAVES]:"Frunze", 
    [BRICK]:"Cămidă", [GLASS]:"Sticlă", [PLANKS]:"Scânduri", [SWORD]:"⚔️ Sabie", 
    [COAL]:"Cărbune", [PICKAXE]:"⛏️ Târnăcop", [STICK]:"Băț", [TORCH]:"🕯️ Torță" 
};

// Culori traduse pentru p5.js color() sau hex
const blockColors = { 
    [GRASS]: '#5a9e32', [STONE]: '#7a7a7a', [WOOD]: '#5c3a21', [LEAVES]: '#1e641e', 
    [BRICK]: '#9c2a2a', [GLASS]: 'rgba(187,221,255,0.5)', [PLANKS]: '#ad723e', [COAL]: '#222222', [TORCH]: '#ffaa00'
};

let world = new Map();
let loadedChunks = new Set();
const CHUNK_SIZE = 8;
const RENDER_DIST = 3; // Optimizat pentru sistemul de randare p5.js
const BLOCK_SIZE = 40; // Dimensiunea unui block în unități p5.js

let hotbar = [PICKAXE, SWORD, GRASS, STONE, WOOD, PLANKS, TORCH, AIR, AIR];
let selectedSlot = 0;
let inventory = [
    { id: PICKAXE, count: 1 }, { id: SWORD, count: 1 }, { id: STONE, count: 20 }, 
    { id: WOOD, count: 10 }, { id: COAL, count: 5 }, { id: BRICK, count: 5 }
];
for(let i=inventory.length; i<27; i++) inventory.push({ id: AIR, count: 0 });

let showInventory = false;
let pX = 0, pY = 400, pZ = 0; // Scalat pentru p5.js
let rotY = 0, rotX = 0;

// Animații procedurale
let swingProgress = 0;
let isSwinging = false;
let placeActionProgress = 0;

let isPointerLocked = false;

// ==========================================
// LUME ȘI ENGINE P5.JS
// ==========================================
function setup() {
    let canvas = createCanvas(windowWidth, windowHeight, WEBGL);
    canvas.parent('canvas-container');
    
    // Configurare eveniment Pointer Lock direct pe canvas-ul p5
    canvas.elt.addEventListener('click', () => {
        if (!showInventory) {
            canvas.elt.requestPointerLock();
        }
    });

    document.addEventListener('pointerlockchange', () => {
        isPointerLocked = (document.pointerLockElement === canvas.elt);
        if(isPointerLocked) notify("Control mouse activat!");
    });

    // Poziția inițială a jucătorului generată pe baza înălțimii hărții
    pY = (getNoiseHeight(0, 0) + 3) * BLOCK_SIZE;
    
    updateHUD();
}

function draw() {
    background('#78a7ff');
    
    // Lumini ambientale și direcționale
    ambientLight(160);
    directionalLight(120, 120, 120, 0.5, 1, -0.3);

    if (isPointerLocked && !showInventory) {
        rotY -= (movedX * 0.0025);
        rotX -= (movedY * 0.0025);
        rotX = constrain(rotX, -HALF_PI + 0.05, HALF_PI - 0.05);
    }

    handlePhysics();
    
    // Setare cameră în stil First Person
    let headY = -pY - 50; // Inversat pentru axa Y din p5.js și ridicat la nivelul ochilor
    let lookX = pX + sin(rotY) * cos(rotX);
    let lookY = headY + sin(rotX);
    let lookZ = pZ + cos(rotY);
    
    camera(pX, headY, pZ, lookX, lookY, lookZ, 0, 1, 0);
    
    // Generare și randare blocuri din lume
    updateInfiniteWorld();
    
    // Randare model mână / armă din HUD-ul 3D
    push();
    // Resetăm matricea camerei pentru a desena direct în fața ei ca interfață atașată
    resetMatrix();
    renderHandModel();
    pop();
}

// ==========================================
// GENERATOR LUME INFINITĂ (PROXIMITATE)
// ==========================================
function setBlock(x, y, z, type) {
    if (type === AIR) world.delete(`${x},${y},${z}`);
    else world.set(`${x},${y},${z}`, type);
}

function getBlock(x, y, z) {
    return world.get(`${x},${y},${z}`) || AIR;
}

function getNoiseHeight(x, z) {
    let n = sin(x * 0.08) * cos(z * 0.08) * 4;
    return floor(n + 7);
}

function generateChunk(cx, cz) {
    let chunkKey = `${cx},${cz}`;
    if (loadedChunks.has(chunkKey)) return;
    loadedChunks.add(chunkKey);

    let startX = cx * CHUNK_SIZE;
    let startZ = cz * CHUNK_SIZE;

    for (let x = 0; x < CHUNK_SIZE; x++) {
        for (let z = 0; z < CHUNK_SIZE; z++) {
            let wx = startX + x;
            let wz = startZ + z;
            let h = getNoiseHeight(wx, wz);

            for (let y = 0; y < h; y++) {
                if (y === h - 1) setBlock(wx, y, wz, GRASS);
                else if (y > h - 4) setBlock(wx, y, wz, STONE);
                else setBlock(wx, y, wz, random() < 0.08 ? COAL : STONE);
            }

            // Copaci procedurali
            if (abs(wx) % 11 === 0 && abs(wz) % 11 === 0 && random() < 0.35) {
                for (let th = 0; th < 4; th++) setBlock(wx, h + th, wz, WOOD);
                for (let ox = -1; ox <= 1; ox++) {
                    for (let oz = -1; oz <= 1; oz++) {
                        setBlock(wx + ox, h + 3, wz + oz, LEAVES);
                    }
                }
                setBlock(wx, h + 4, wz, LEAVES);
            }
        }
    }
}

function updateInfiniteWorld() {
    let playerChunkX = floor((pX / BLOCK_SIZE) / CHUNK_SIZE);
    let playerChunkZ = floor((pZ / BLOCK_SIZE) / CHUNK_SIZE);

    for (let x = -RENDER_DIST; x <= RENDER_DIST; x++) {
        for (let z = -RENDER_DIST; z <= RENDER_DIST; z++) {
            generateChunk(playerChunkX + x, playerChunkZ + z);
        }
    }

    let pBlockX = round(pX / BLOCK_SIZE);
    let pBlockY = floor(pY / BLOCK_SIZE);
    let pBlockZ = round(pZ / BLOCK_SIZE);

    // Iterare și randare blocuri vizibile
    for (let [key, type] of world.entries()) {
        let [x, y, z] = key.split(',').map(Number);
        
        if (abs(x - pBlockX) > RENDER_DIST * CHUNK_SIZE || abs(z - pBlockZ) > RENDER_DIST * CHUNK_SIZE) continue;

        // Randare doar dacă atinge aerul (optimizare)
        let isVisible = 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 (isVisible) {
            push();
            translate(x * BLOCK_SIZE, -y * BLOCK_SIZE, z * BLOCK_SIZE);
            
            let col = blockColors[type] || '#ffffff';
            fill(col);
            stroke(0, 30); // Linii discrete contur blocuri
            
            if (type === GLASS) {
                // p5 gestionează sticla prin transparența fill-ului rgba
                fill(187, 221, 255, 100);
            }

            if (type === TORCH) {
                translate(0, BLOCK_SIZE/4, 0);
                box(BLOCK_SIZE * 0.2, BLOCK_SIZE * 0.6, BLOCK_SIZE * 0.2);
            } else {
                box(BLOCK_SIZE);
            }
            pop();
        }
    }
}

// ==========================================
// FIZICĂ ȘI MIȘCARE
// ==========================================
let velocityY = 0, isGrounded = false;

function checkCollision(x, y, z) {
    let bx = round(x / BLOCK_SIZE);
    let by = floor(y / BLOCK_SIZE);
    let bz = round(z / BLOCK_SIZE);
    
    // Verificăm picioarele și capul
    return (getBlock(bx, by, bz) !== AIR || getBlock(bx, by + 1, bz) !== AIR);
}

function handlePhysics() {
    if (showInventory) return;

    let speed = 4.0;
    let dx = 0, dz = 0;

    if (keyIsDown(87) || keyIsDown(UP_ARROW)) { dx += sin(rotY) * speed; dz += cos(rotY) * speed; } // W
    if (keyIsDown(83) || keyIsDown(DOWN_ARROW)) { dx -= sin(rotY) * speed; dz -= cos(rotY) * speed; } // S
    if (keyIsDown(65) || keyIsDown(LEFT_ARROW)) { dx += cos(rotY) * speed; dz -= sin(rotY) * speed; } // A
    if (keyIsDown(68) || keyIsDown(RIGHT_ARROW)) { dx -= cos(rotY) * speed; dz += sin(rotY) * speed; } // D

    if (!checkCollision(pX + dx, pY, pZ)) pX += dx;
    if (!checkCollision(pX, pY, pZ + dz)) pZ += dz;

    // Gravitație
    velocityY -= 0.4;
    pY += velocityY;

    if (checkCollision(pX, pY, pZ)) {
        pY -= velocityY; 
        velocityY = 0; 
        isGrounded = true;
    } else {
        isGrounded = false;
    }

    // Reset dacă cazi în void
    if (pY < -1000) { 
        pX = 0; pZ = 0; 
        pY = (getNoiseHeight(0,0) + 3) * BLOCK_SIZE; 
        velocityY = 0; 
    }
}

function keyPressed() {
    let k = key.toLowerCase();
    if (k === 'e') { toggleInventory(); }

    if (key >= '1' && key <= '9') {
        selectedSlot = parseInt(key) - 1;
        updateHUD();
    }
    
    if (keyCode === 32 && isGrounded && !showInventory) { // Space Bar
        velocityY = 7.5; 
        isGrounded = false;
    }
}

// ==========================================
// INTERACȚIUNE MOUSE (SPART / PUS BLOCURI)
// ==========================================
function mousePressed() {
    if (showInventory || !isPointerLocked) return;

    // Animație Swing la click stânga
    if (mouseButton === LEFT && !isSwinging) {
        isSwinging = true;
        swingProgress = 0;
    }

    // Algoritm Raycast simplificat pentru p5.js bazat pe direcția camerei
    let target = performRaycast();
    if (!target) return;

    if (mouseButton === LEFT) { // Sparge bloc
        let type = getBlock(target.hx, target.hy, target.hz);
        if (type !== AIR) {
            addItem(type);
            setBlock(target.hx, target.hy, target.hz, AIR);
            notify("Ai colectat: " + blockNames[type]);
        }
    } else if (mouseButton === RIGHT) { // Pune bloc
        let handItem = hotbar[selectedSlot];
        if (handItem === AIR || handItem === SWORD || handItem === PICKAXE || handItem === STICK) return;
        if (countItems(handItem) <= 0) return;

        if (!checkCollision(target.px * BLOCK_SIZE, target.py * BLOCK_SIZE, target.pz * BLOCK_SIZE)) {
            setBlock(target.px, target.py, target.pz, handItem);
            removeItem(handItem, 1);
            placeActionProgress = 1.0; // Declanșare recul
        }
    }
}

// Interceptează click-ul dreapta din browser
document.addEventListener('contextmenu', e => e.preventDefault());

function performRaycast() {
    // Proiectăm o rază incrementală din centrul camerei pe o distanță de 5 blocuri
    let startX = pX;
    let startY = pY + 50; 
    let startZ = pZ;

    let dirX = sin(rotY) * cos(rotX);
    let dirY = -sin(rotX); // Inversat pentru sistemul cartezian p5
    let dirZ = cos(rotY);

    let currentX = startX;
    let currentY = startY;
    let currentZ = startZ;

    let step = 5; // Rezoluție detecție pas incremental
    let prevBx = round(startX / BLOCK_SIZE), prevBy = floor(startY / BLOCK_SIZE), prevBz = round(startZ / BLOCK_SIZE);

    for (let d = 0; d < 200; d += step) {
        currentX += dirX * step;
        currentY += dirY * step;
        currentZ += dirZ * step;

        let bx = round(currentX / BLOCK_SIZE);
        let by = floor(currentY / BLOCK_SIZE);
        let bz = round(currentZ / BLOCK_SIZE);

        if (getBlock(bx, by, bz) !== AIR) {
            return { hx: bx, hy: by, hz: bz, px: prevBx, py: prevBy, pz: prevBz };
        }
        prevBx = bx; prevBy = by; prevBz = bz;
    }
    return null;
}

// ==========================================
// RENDER PROCEDURAL AL MODELULUI DIN MÂNĂ
// ==========================================
function renderHandModel() {
    let currentItem = hotbar[selectedSlot];
    if (currentItem === AIR) return;

    let timeNow = millis();

    // Poziții inițiale bază în spațiul HUD p5
    let targetX = width * 0.22;
    let targetY = height * 0.22;
    let targetZ = -300;

    let rotModX = 0.4;
    let rotModY = -0.5;
    let rotModZ = (currentItem === PICKAXE) ? -0.4 : 0.0;

    // 1. Mers (Bobbing Effect)
    let isMoving = (keyIsDown(87) || keyIsDown(83) || keyIsDown(65) || keyIsDown(68)) && isGrounded;
    if (isMoving) {
        let bobSpeed = timeNow * 0.008;
        targetX += cos(bobSpeed) * 8;
        targetY += abs(sin(bobSpeed)) * 8;
    } else {
        // 2. Respirație (Idle Breathing)
        let breathe = timeNow * 0.0015;
        targetY += sin(breathe) * 2;
    }

    // 3. Animație plasare bloc (Recul)
    if (placeActionProgress > 0) {
        targetZ -= placeActionProgress * 40; 
        targetY += placeActionProgress * 15;
        placeActionProgress -= 0.1;
    }

    // 4. Animație atac (Swing)
    if (isSwinging) {
        swingProgress += 0.12;
        if (swingProgress >= 1.0) {
            isSwinging = false;
            swingProgress = 0;
        }
        let angle = sin(swingProgress * Math.PI);
        rotModX += angle * 1.2;
        rotModY -= angle * 0.6;
        targetX -= angle * 40;
        targetY -= angle * 20;
    }

    // Randarea propriu-zisă a geometriei uneltelor în p5.js
    translate(targetX, targetY, targetZ);
    rotateX(rotModX);
    rotateY(rotModY);
    rotateZ(rotModZ);

    stroke(0);
    
    if (currentItem === SWORD) {
        // Lamă
        fill('#dddddd');
        push();
        translate(0, -35, 0);
        box(8, 90, 8);
        pop();
        // Mâner complet
        fill('#5c3a21');
        push();
        box(30, 8, 8);
        translate(0, 20, 0);
        box(8, 30, 8);
        pop();
    } else if (currentItem === PICKAXE) {
        // Coadă lemn
        fill('#5c3a21');
        push();
        box(8, 80, 8);
        pop();
        // Cap târnăcop
        fill('#999999');
        push();
        translate(0, -35, 0);
        box(60, 10, 12);
        pop();
    } else if (currentItem === STICK) {
        fill('#5c3a21');
        box(8, 80, 8);
    } else {
        // Randare Cub/Torță în mână
        let col = blockColors[currentItem] || '#ffffff';
        fill(col);
        if (currentItem === TORCH) {
            box(10, 40, 10);
        } else {
            box(45);
        }
    }
}

// ==========================================
// HUD, INVENTAR ȘI MANAGEMENT CRAFTING
// ==========================================
function addItem(type) {
    for(let s of inventory) { if(s.id === type && s.count < 64) { s.count++; updateHUD(); return; } }
    for(let s of inventory) { if(s.id === AIR) { s.id = type; s.count = 1; updateHUD(); return; } }
}
function countItems(type) {
    let t = 0; for(let s of inventory) { if(s.id === type) t += s.count; } return t;
}
function removeItem(type, amt) {
    for(let s of inventory) { if(s.id === type) { if(s.count >= amt) { s.count -= amt; if(s.count===0) s.id = AIR; updateHUD(); return; } } }
}

function updateHUD() {
    let hb = document.getElementById('hotbar');
    hb.innerHTML = '';
    for(let i=0; i<9; i++) {
        let type = hotbar[i];
        let content = type !== AIR ? `${blockNames[type].substring(0,4)}<br>(${countItems(type)})` : '';
        if(type === SWORD) content = "⚔️";
        if(type === PICKAXE) content = "⛏️";
        if(type === STICK) content = "🥢";
        let cl = i === selectedSlot ? 'slot selected' : 'slot';
        hb.innerHTML += `<div class="${cl}">${content}</div>`;
    }

    let grid = document.getElementById('inv-grid-container');
    grid.innerHTML = '';
    for(let i=0; i<27; i++) {
        let item = inventory[i];
        let txt = item.id !== AIR ? `${blockNames[item.id].substring(0,4)}<br>${item.count}` : '';
        if(item.id === SWORD) txt = "⚔️";
        if(item.id === PICKAXE) txt = "⛏️";
        if(item.id === STICK) txt = "🥢";
        grid.innerHTML += `<div class="inv-slot" onclick="equip(${i})">${txt}</div>`;
    }
}

function equip(idx) {
    if(inventory[idx].id !== AIR) {
        hotbar[selectedSlot] = inventory[idx].id;
        updateHUD();
    }
}

function craftItem(recipe) {
    if(recipe === 'planks' && countItems(WOOD) >= 1) { removeItem(WOOD, 1); for(let i=0;i<4;i++) addItem(PLANKS); notify("Craftat: Scânduri x4"); }
    if(recipe === 'sticks' && countItems(PLANKS) >= 2) { removeItem(PLANKS, 2); for(let i=0;i<4;i++) addItem(STICK); notify("Craftat: Bețe x4"); }
    if(recipe === 'pickaxe' && countItems(STONE) >= 3 && countItems(STICK) >= 2) { removeItem(STONE, 3); removeItem(STICK, 2); addItem(PICKAXE); notify("Craftat: Târnăcop"); }
    if(recipe === 'sword' && countItems(STONE) >= 2 && countItems(STICK) >= 1) { removeItem(STONE, 2); removeItem(STICK, 1); addItem(SWORD); notify("Craftat: Sabie"); }
    if(recipe === 'torch' && countItems(COAL) >= 1 && countItems(STICK) >= 1) { removeItem(COAL, 1); removeItem(STICK, 1); for(let i=0;i<4;i++) addItem(TORCH); notify("Craftat: Torțe x4"); }
    if(recipe === 'glass' && countItems(GRASS) >= 2) { removeItem(GRASS, 2); addItem(GLASS); notify("Topit: Sticlă x1"); }
    updateHUD();
}

function toggleInventory() {
    showInventory = !showInventory;
    document.getElementById('inventory-screen').style.display = showInventory ? 'block' : 'none';
    if(showInventory) { 
        document.exitPointerLock(); 
    } else {
        updateHUD();
    }
}

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

function notify(msg) { document.getElementById('notifications').innerText = msg; }
</script>
</body>
</html>
Du-te sus!