Spaces:

Aleksmorshen
/

Testreact

Running

App Files Files Community

Aleksmorshen commited on May 4, 2025

Commit

798a123

verified ·

1 Parent(s): b925469

Update index.html

Browse files

Files changed (1) hide show

index.html +256 -185

index.html CHANGED Viewed

@@ -2,247 +2,318 @@
 <html lang="ru">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Простой Minecraft-клон на Babylon.js</title>
     <style>
         html, body {
-            overflow: hidden;
-            width: 100%;
-            height: 100%;
             margin: 0;
             padding: 0;
-            font-family: sans-serif; /* Добавим шрифт для UI */
         }
         #renderCanvas {
             width: 100%;
             height: 100%;
-            touch-action: none; /* Для мобильных устройств */
-        }
-        /* Простой интерфейс для прицела */
-        #crosshair {
-            position: absolute;
-            top: 50%;
-            left: 50%;
-            width: 10px;
-            height: 10px;
-            border: 1px solid white;
-            background-color: rgba(0, 0, 0, 0.5);
-            transform: translate(-50%, -50%);
-            pointer-events: none; /* Чтобы не мешал кликам */
-        }
-         /* Инструкция */
-        #instructions {
-            position: absolute;
-            bottom: 10px;
-            left: 10px;
-            color: white;
-            background-color: rgba(0,0,0,0.5);
-            padding: 5px;
-            border-radius: 3px;
-            font-size: 12px;
         }
     </style>
-    <!-- Подключение Babylon.js -->
     <script src="https://cdn.babylonjs.com/babylon.js"></script>
-    <!-- Опционально: загрузчики моделей/текстур, если понадобятся -->
     <!-- <script src="https://cdn.babylonjs.com/loaders/babylonjs.loaders.min.js"></script> -->
 </head>
 <body>
     <canvas id="renderCanvas"></canvas>
-    <div id="crosshair"></div>
-    <div id="instructions">
-        WASD/Стрелки: Движение | Пробел: Вверх | Shift: Вниз <br>
-        Левый клик: Удалить блок | Правый клик: Поставить блок
-    </div>
     <script>
         const canvas = document.getElementById('renderCanvas');
-        const engine = new BABYLON.Engine(canvas, true, { preserveDrawingBuffer: true, stencil: true });
-        const BLOCK_SIZE = 1; // Размер одного блока
         const WORLD_WIDTH = 16; // Ширина мира в блоках
         const WORLD_DEPTH = 16; // Глубина мира в блоках
-        const WORLD_HEIGHT = 8;  // Максимальная высота мира (для генерации)
-        // --- Создание сцены ---
         const createScene = () => {
             const scene = new BABYLON.Scene(engine);
-            scene.clearColor = new BABYLON.Color3(0.5, 0.8, 1.0); // Цвет неба
-            scene.gravity = new BABYLON.Vector3(0, -0.9, 0); // Гравитация
-            scene.collisionsEnabled = true; // Включаем обработку столкновений
-            // --- Камера ---
-            const camera = new BABYLON.UniversalCamera("playerCamera", new BABYLON.Vector3(WORLD_WIDTH / 2, WORLD_HEIGHT + 2, WORLD_DEPTH / 2), scene);
-            camera.setTarget(BABYLON.Vector3.Zero()); // Смотрим в центр
-            camera.attachControl(canvas, true); // Подключаем управление
-            camera.speed = 0.2; // Скорость движения
-            camera.angularSensibility = 4000; // Чувствительность мыши
-            // Включаем столкновения для камеры
-            camera.checkCollisions = true;
             camera.applyGravity = true;
-            // Задаем "эллипсоид" - физическую модель игрока для столкновений
-            camera.ellipsoid = new BABYLON.Vector3(0.5, 0.9, 0.5); // Ширина, Высота, Глубина
-            // Управление с клавиатуры (WASD + пробел/shift)
             camera.keysUp.push(87);    // W
             camera.keysDown.push(83);  // S
             camera.keysLeft.push(65);  // A
             camera.keysRight.push(68); // D
-            // Добавляем управление вверх/вниз (не стандартное для UniversalCamera)
-            scene.onBeforeRenderObservable.add(() => {
-                 if (camera.inputs.attached.keyboard) {
-                    const keyboard = camera.inputs.attached.keyboard;
-                    if (keyboard.directInput[' ']) { // Пробел
-                         camera.cameraDirection.y += camera.speed / 10; // Двигаемся вверх
                     }
-                    if (keyboard.directInput[16]) { // Shift
-                         camera.cameraDirection.y -= camera.speed / 10; // Двигаемся вниз
                     }
                  }
-            });
-            // --- Освещение ---
-            const light = new BABYLON.HemisphericLight("light", new BABYLON.Vector3(0, 1, 0), scene);
-            light.intensity = 0.8;
-            // --- Материалы блоков ---
-            const grassMaterial = new BABYLON.StandardMaterial("grassMat", scene);
-            grassMaterial.diffuseColor = new BABYLON.Color3(0.4, 0.8, 0.4); // Зеленый
-            grassMaterial.specularColor = new BABYLON.Color3(0.1, 0.1, 0.1); // Меньше бликов
-            const dirtMaterial = new BABYLON.StandardMaterial("dirtMat", scene);
-            dirtMaterial.diffuseColor = new BABYLON.Color3(0.6, 0.4, 0.2); // Коричневый
-            dirtMaterial.specularColor = new BABYLON.Color3(0.1, 0.1, 0.1);
-            const stoneMaterial = new BABYLON.StandardMaterial("stoneMat", scene);
-            stoneMaterial.diffuseColor = new BABYLON.Color3(0.5, 0.5, 0.5); // Серый
-            stoneMaterial.specularColor = new BABYLON.Color3(0.1, 0.1, 0.1);
-            // --- Мир блоков ---
-            // Используем Map для хранения блоков { "x,y,z": mesh }
-            const blocks = new Map();
-            // Прототип блока (для клонирования)
-            const blockPrototype = BABYLON.MeshBuilder.CreateBox("blockProto", { size: BLOCK_SIZE }, scene);
-            blockPrototype.isVisible = false; // Сам прототип не видим
-            blockPrototype.checkCollisions = true; // Блоки должны иметь коллизию
-            // Генерация простого ландшафта
             for (let x = 0; x < WORLD_WIDTH; x++) {
                 for (let z = 0; z < WORLD_DEPTH; z++) {
-                    // Простая высота на основе шума (очень примитивно)
-                    const height = Math.floor(WORLD_HEIGHT / 2 + Math.sin(x * 0.3) * 2 + Math.cos(z * 0.2) * 2);
-                    for (let y = 0; y < height; y++) {
-                        const block = blockPrototype.clone(`block_${x}_${y}_${z}`);
-                        block.position = new BABYLON.Vector3(
-                            x * BLOCK_SIZE + BLOCK_SIZE / 2,
-                            y * BLOCK_SIZE + BLOCK_SIZE / 2,
-                            z * BLOCK_SIZE + BLOCK_SIZE / 2
-                        );
-                        block.isVisible = true;
-                        // Назначаем материал в зависимости от высоты
-                        if (y === height - 1) {
-                             block.material = grassMaterial; // Верхний слой - трава
-                        } else if (y > height - 4) {
-                             block.material = dirtMaterial; // Под травой - земля
-                        } else {
-                             block.material = stoneMaterial; // Глубже - камень
-                        }
-                        const blockKey = `${block.position.x - BLOCK_SIZE/2},${block.position.y - BLOCK_SIZE/2},${block.position.z - BLOCK_SIZE/2}`; // Ключ по нижнему углу
-                        blocks.set(blockKey, block);
-                         block.isBlock = true; // Флаг, что это наш блок
                     }
                 }
             }
-            // --- Взаимодействие с блоками ---
-            scene.onPointerDown = (evt, pickResult) => {
-                // evt.button: 0 = левый клик, 1 = средний, 2 = правый клик
-                // --- Удаление блока (левый клик) ---
-                if (evt.button === 0) {
-                    if (pickResult.hit && pickResult.pickedMesh && pickResult.pickedMesh.isBlock) {
-                         const blockToRemove = pickResult.pickedMesh;
-                         const blockKey = `${blockToRemove.position.x - BLOCK_SIZE/2},${blockToRemove.position.y - BLOCK_SIZE/2},${blockToRemove.position.z - BLOCK_SIZE/2}`;
-                         blocks.delete(blockKey);
-                         blockToRemove.dispose();
-                    }
-                }
-                // --- Размещение блока (правый клик) ---
-                if (evt.button === 2) {
-                    if (pickResult.hit && pickResult.pickedMesh) { // Проверяем, что попали во что-то
-                        // Определяем позицию для нового блока
-                        // Она должна быть смещена от точки попадания по нормали к поверхности
-                        const normal = pickResult.getNormal(true); // Получаем нормаль к грани
-                        const hitPoint = pickResult.pickedPoint;
-                        // Вычисляем центр потенциального нового блока
-                        const potentialPos = hitPoint.add(normal.scale(BLOCK_SIZE / 2));
-                        // Округляем (снапим) к сетке блоков
-                        // Важно: Вычитаем/добавляем половину размера блока для центрирования
-                        const newBlockX = Math.floor(potentialPos.x / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
-                        const newBlockY = Math.floor(potentialPos.y / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
-                        const newBlockZ = Math.floor(potentialPos.z / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
-                        const newBlockKey = `${newBlockX - BLOCK_SIZE/2},${newBlockY - BLOCK_SIZE/2},${newBlockZ - BLOCK_SIZE/2}`;
-                        // Проверяем, не занято ли это место
-                        if (!blocks.has(newBlockKey)) {
-                             // Проверяем, не ставим ли блок "внутрь" игрока
-                             const playerBox = new BABYLON.BoundingBox(
-                                 camera.position.subtract(camera.ellipsoid),
-                                 camera.position.add(camera.ellipsoid)
-                             );
-                             const newBlockBox = new BABYLON.BoundingBox(
-                                 new BABYLON.Vector3(newBlockX - BLOCK_SIZE/2, newBlockY - BLOCK_SIZE/2, newBlockZ - BLOCK_SIZE/2),
-                                 new BABYLON.Vector3(newBlockX + BLOCK_SIZE/2, newBlockY + BLOCK_SIZE/2, newBlockZ + BLOCK_SIZE/2)
-                             );
-                             if (!playerBox.intersects(newBlockBox)) {
-                                const newBlock = blockPrototype.clone(`block_${newBlockKey.replace(/,/g, '_')}`);
-                                newBlock.position = new BABYLON.Vector3(newBlockX, newBlockY, newBlockZ);
-                                newBlock.material = dirtMaterial; // По умолчанию ставим землю
-                                newBlock.isVisible = true;
-                                newBlock.isBlock = true;
-                                blocks.set(newBlockKey, newBlock);
-                             } else {
-                                console.log("Нельзя ставить блок внутри себя!");
-                             }
-                        } else {
-                            console.log("Место занято!");
-                        }
-                    }
-                }
-            };
-             // Отключаем контекстное меню по правому клику на канвасе
-            canvas.addEventListener("contextmenu", (evt) => {
-                evt.preventDefault();
-            });
-            // --- Оптимизация (очень базовая) ---
-            // Можно добавить Octree для ускорения рендеринга и коллизий
-            // scene.createOrUpdateSelectionOctree();
-            return scene;
-        };
         // --- Запуск ---
-        const scene = createScene();
         engine.runRenderLoop(() => {
             scene.render();
         });
         window.addEventListener('resize', () => {
             engine.resize();
         });

 <html lang="ru">
 <head>
     <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <title>BabylonCraft Demo</title>
     <style>
+        /* Базовый сброс стилей и стили для canvas */
         html, body {
             margin: 0;
             padding: 0;
+            overflow: hidden; /* Убираем прокрутку */
+            width: 100%;
+            height: 100%;
+            background-color: #000; /* Черный фон на случай проблем */
         }
         #renderCanvas {
             width: 100%;
             height: 100%;
+            display: block; /* Убираем лишнее пространство под canvas */
+            touch-action: none; /* Отключаем стандартные действия браузера при касании (важно для управления камерой) */
+            outline: none; /* Убираем обводку при фокусе */
         }
     </style>
+    <!-- Подключаем Babylon.js через CDN -->
     <script src="https://cdn.babylonjs.com/babylon.js"></script>
+    <!-- Можно добавить библиотеки материалов, загрузчиков и т.д. при необходимости -->
+    <!-- <script src="https://cdn.babylonjs.com/materialsLibrary/babylonjs.materials.min.js"></script> -->
     <!-- <script src="https://cdn.babylonjs.com/loaders/babylonjs.loaders.min.js"></script> -->
 </head>
 <body>
     <canvas id="renderCanvas"></canvas>
     <script>
+        // Получаем элемент canvas
         const canvas = document.getElementById('renderCanvas');
+        // Создаем движок Babylon.js
+        const engine = new BABYLON.Engine(canvas, true, {
+            preserveDrawingBuffer: true, // Необходимо для некоторых эффектов, может влиять на производительность
+            stencil: true // Необходимо для некоторых эффектов
+        });
+        // --- Глобальные переменные и константы ---
+        const BLOCK_SIZE = 1; // Размер блока
         const WORLD_WIDTH = 16; // Ширина мира в блоках
         const WORLD_DEPTH = 16; // Глубина мира в блоках
+        const PLAYER_HEIGHT = 1.8; // Рост игрока
+        const blockStorage = {}; // Объект для хранения созданных блоков { "x_y_z": blockMesh }
+        // --- Материалы для блоков ---
+        let grassMat, dirtMat, stoneMat;
+        // Функция создания основной сцены
         const createScene = () => {
             const scene = new BABYLON.Scene(engine);
+            scene.clearColor = new BABYLON.Color3(0.5, 0.8, 1.0); // Цвет неба (голубой)
+            scene.collisionsEnabled = true; // Включаем обработку столкновений на сцене
+            scene.gravity = new BABYLON.Vector3(0, -0.9, 0); // Глобальная гравитация (примерно как в Minecraft)
+            // --- Камера от первого лица ---
+            // Используем UniversalCamera для поддержки и мыши/клавиатуры, и сенсорного ввода
+            const camera = new BABYLON.UniversalCamera("playerCamera", new BABYLON.Vector3(WORLD_WIDTH / 2, PLAYER_HEIGHT * 2, WORLD_DEPTH / 2), scene);
+            camera.setTarget(new BABYLON.Vector3(0, PLAYER_HEIGHT, 0)); // Куда смотрит камера при старте
+            camera.attachControl(canvas, true); // Привязываем управление к canvas
+            // Настройки камеры
+            camera.speed = 0.15; // Скорость перемещения
+            camera.angularSensibility = 3000; // Чувствительность мыши/сенсора
+            camera.inertia = 0.5; // Инерция при движении и вращении
+            // Включаем гравитацию и столкновения для камеры
             camera.applyGravity = true;
+            // Определяем размеры "тела" игрока для столкновений (эллипсоид)
+            camera.ellipsoid = new BABYLON.Vector3(BLOCK_SIZE * 0.4, PLAYER_HEIGHT * 0.45, BLOCK_SIZE * 0.4);
+             camera.ellipsoidOffset = new BABYLON.Vector3(0, PLAYER_HEIGHT * 0.45, 0); // Смещение эллипсоида, чтобы "ноги" были внизу
+            camera.checkCollisions = true; // Камера будет проверять столкновения
+            // Назначение клавиш управления (WASD)
             camera.keysUp.push(87);    // W
             camera.keysDown.push(83);  // S
             camera.keysLeft.push(65);  // A
             camera.keysRight.push(68); // D
+             // camera.keysUpward.push(32); // Пробел для прыжка (требует доп. логики или физического движка)
+            // --- Освещение ---
+            // Простое полусферическое освещение, имитирующее небо и землю
+            const light = new BABYLON.HemisphericLight("hemiLight", new BABYLON.Vector3(0, 1, 0), scene);
+            light.intensity = 0.8;
+            light.diffuse = new BABYLON.Color3(1, 1, 1); // Цвет света сверху
+            light.specular = new BABYLON.Color3(0.5, 0.5, 0.5); // Блики
+            light.groundColor = new BABYLON.Color3(0.3, 0.3, 0.3); // Цвет света снизу
+            // --- Создание материалов ---
+            grassMat = new BABYLON.StandardMaterial("grassMat", scene);
+            grassMat.diffuseColor = new BABYLON.Color3(0.3, 0.6, 0.2); // Зеленый
+            grassMat.specularColor = new BABYLON.Color3(0.1, 0.1, 0.1); // Меньше бликов
+            dirtMat = new BABYLON.StandardMaterial("dirtMat", scene);
+            dirtMat.diffuseColor = new BABYLON.Color3(0.6, 0.4, 0.2); // Коричневый
+            dirtMat.specularColor = new BABYLON.Color3(0.1, 0.1, 0.1);
+            stoneMat = new BABYLON.StandardMaterial("stoneMat", scene);
+            stoneMat.diffuseColor = new BABYLON.Color3(0.5, 0.5, 0.5); // Серый
+            stoneMat.specularColor = new BABYLON.Color3(0.2, 0.2, 0.2);
+            // --- Генерация простого мира ---
+            generateFlatWorld(scene);
+            // --- Логика взаимодействия (размещение/удаление блоков) ---
+            scene.onPointerDown = (evt, pickInfo) => {
+                // evt.button: 0 = левая, 1 = средняя, 2 = правая
+                const isRightClick = evt.button === 2;
+                const isLeftClick = evt.button === 0;
+                if (pickInfo.hit) {
+                    const pickedMesh = pickInfo.pickedMesh;
+                    // --- Удаление блока ---
+                    // Левая кнопка мыши ИЛИ простое касание на мобильном, если попали в блок
+                    if (pickedMesh && pickedMesh.isBlock && isLeftClick) {
+                        removeBlock(pickedMesh.position.x, pickedMesh.position.y, pickedMesh.position.z);
                     }
+                    // --- Размещение блока ---
+                    // Правая кнопка мыши ИЛИ простое касание на мобильном, если попали НЕ в блок (или в грань блока)
+                    else if (pickedMesh && (isRightClick || (!pickedMesh.isBlock && isLeftClick))) {
+                        // Рассчитываем позицию для нового блока
+                        // Берем точку попадания и сдвигаемся на половину блока по нормали к поверхности
+                        const normal = pickInfo.getNormal(true); // Получаем нормаль к поверхности в мировой системе координат
+                        const placePos = pickInfo.pickedPoint.add(normal.scale(BLOCK_SIZE / 2));
+                        // Выравниваем по сетке и центрируем
+                        const gridX = Math.floor(placePos.x / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                        const gridY = Math.floor(placePos.y / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                        const gridZ = Math.floor(placePos.z / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                         // Проверка, не пытаемся ли поставить блок внутри игрока
+                         if (!isPositionOccupiedByPlayer(gridX, gridY, gridZ, camera)) {
+                            // Сейчас всегда ставим камень
+                            createBlock(gridX, gridY, gridZ, stoneMat, scene);
+                         } else {
+                             console.log("Нельзя разместить блок внутри себя!");
+                         }
                     }
+                }
+            };
+             // Блокировка курсора при клике на canvas для удобного управления мышью
+             let isPointerLocked = false;
+             scene.onPointerDown = (evt) => {
+                 if (!isPointerLocked && evt.button === 0) { // Блокируем только по левому клику
+                     canvas.requestPointerLock = canvas.requestPointerLock || canvas.msRequestPointerLock || canvas.mozRequestPointerLock || canvas.webkitRequestPointerLock;
+                     if (canvas.requestPointerLock) {
+                         canvas.requestPointerLock();
+                     }
                  }
+                 // Вызываем предыдущую логику клика (размещение/удаление)
+                 handlePointerDown(evt, scene.pick(scene.pointerX, scene.pointerY));
+             };
+             // Освобождение курсора при нажатии Esc
+             const pointerLockChange = () => {
+                 let controlEnabled = document.pointerLockElement || document.mozPointerLockElement || document.webkitPointerLockElement || document.msPointerLockElement || null;
+                 isPointerLocked = !!controlEnabled;
+                 // Если курсор разблокирован, останавливаем камеру (опционально)
+                 // if (!controlEnabled) {
+                 //     camera.detachControl(canvas);
+                 // } else {
+                 //     camera.attachControl(canvas, true);
+                 // }
+             };
+             document.addEventListener("pointerlockchange", pointerLockChange, false);
+             document.addEventListener("mspointerlockchange", pointerLockChange, false);
+             document.addEventListener("mozpointerlockchange", pointerLockChange, false);
+             document.addEventListener("webkitpointerlockchange", pointerLockChange, false);
+            return scene;
+        };
+        // --- Вспомогательные функции ---
+        // Функция создания блока
+        function createBlock(x, y, z, material, scene) {
+            const blockId = `${Math.floor(x)}_${Math.floor(y)}_${Math.floor(z)}`;
+            // Проверяем, нет ли уже блока в этой позиции
+            if (blockStorage[blockId]) {
+                // console.log(`Блок ${blockId} уже существует.`);
+                return null;
+            }
+            // Создаем куб (box)
+            const box = BABYLON.MeshBuilder.CreateBox("block_" + blockId, { size: BLOCK_SIZE }, scene);
+            box.position = new BABYLON.Vector3(x, y, z);
+            box.material = material;
+            box.checkCollisions = true; // Включаем столкновения для блока
+            box.isBlock = true; // Пользовательское свойство для идентификации
+            // Добавляем блок в хранилище
+            blockStorage[blockId] = box;
+            // console.log(`Создан блок ${blockId} в ${x}, ${y}, ${z}`);
+            return box;
+        }
+        // Функция удаления блока
+        function removeBlock(x, y, z) {
+            const blockId = `${Math.floor(x)}_${Math.floor(y)}_${Math.floor(z)}`;
+            const blockToRemove = blockStorage[blockId];
+            if (blockToRemove) {
+                blockToRemove.dispose(); // Удаляем меш из сцены
+                delete blockStorage[blockId]; // Удаляем из хранилища
+                // console.log(`Удален блок ${blockId}`);
+            } else {
+                // console.log(`Блок ${blockId} не найден для удаления.`);
+            }
+        }
+        // Функция генерации плоского мира
+        function generateFlatWorld(scene) {
+            const groundLevel = 0; // Уровень земли
+            const dirtDepth = 3; // Глубина слоя грязи под травой
             for (let x = 0; x < WORLD_WIDTH; x++) {
                 for (let z = 0; z < WORLD_DEPTH; z++) {
+                    // Верхний слой - трава
+                    createBlock(x + BLOCK_SIZE / 2, groundLevel + BLOCK_SIZE / 2, z + BLOCK_SIZE / 2, grassMat, scene);
+                    // Слои грязи под травой
+                    for (let y = 1; y <= dirtDepth; y++) {
+                         createBlock(x + BLOCK_SIZE / 2, groundLevel + BLOCK_SIZE / 2 - y * BLOCK_SIZE, z + BLOCK_SIZE / 2, dirtMat, scene);
                     }
                 }
             }
+            console.log(`Сгенерирован плоский мир ${WORLD_WIDTH}x${WORLD_DEPTH}`);
+        }
+         // Проверка, попадает ли позиция в эллипсоид игрока
+         function isPositionOccupiedByPlayer(gridX, gridY, gridZ, camera) {
+             const playerPos = camera.position;
+             const playerEllipsoid = camera.ellipsoid;
+             const playerOffset = camera.ellipsoidOffset;
+             // Центр эллипсоида игрока
+             const playerCenterY = playerPos.y + playerOffset.y;
+             // Границы блока
+             const blockMinX = gridX - BLOCK_SIZE / 2;
+             const blockMaxX = gridX + BLOCK_SIZE / 2;
+             const blockMinY = gridY - BLOCK_SIZE / 2;
+             const blockMaxY = gridY + BLOCK_SIZE / 2;
+             const blockMinZ = gridZ - BLOCK_SIZE / 2;
+             const blockMaxZ = gridZ + BLOCK_SIZE / 2;
+             // Границы эллипсоида игрока (приблизительно)
+             const playerMinX = playerPos.x - playerEllipsoid.x;
+             const playerMaxX = playerPos.x + playerEllipsoid.x;
+             const playerMinY = playerCenterY - playerEllipsoid.y; // Используем центр эллипсоида
+             const playerMaxY = playerCenterY + playerEllipsoid.y; // Используем центр эллипсоида
+             const playerMinZ = playerPos.z - playerEllipsoid.z;
+             const playerMaxZ = playerPos.z + playerEllipsoid.z;
+            // Проверка на пересечение AABB (Axis-Aligned Bounding Box)
+            const overlapX = playerMinX < blockMaxX && playerMaxX > blockMinX;
+            const overlapY = playerMinY < blockMaxY && playerMaxY > blockMinY;
+            const overlapZ = playerMinZ < blockMaxZ && playerMaxZ > blockMinZ;
+            return overlapX && overlapY && overlapZ;
+         }
+         // Обработчик клика/касания (вынесен для работы с блокировкой курсора)
+         function handlePointerDown(evt, pickInfo) {
+              // evt.button: 0 = левая, 1 = средняя, 2 = правая
+              const isRightClick = evt.button === 2;
+              const isLeftClick = evt.button === 0;
+              if (pickInfo && pickInfo.hit) {
+                  const pickedMesh = pickInfo.pickedMesh;
+                  const scene = pickedMesh.getScene(); // Получаем сцену из объекта
+                  // --- Удаление блока ---
+                  // Левая кнопка мыши ИЛИ простое касание на мобильном, если попали в блок
+                  if (pickedMesh && pickedMesh.isBlock && isLeftClick) {
+                      removeBlock(pickedMesh.position.x, pickedMesh.position.y, pickedMesh.position.z);
+                  }
+                  // --- Размещение блока ---
+                  // Правая кнопка мыши ИЛИ простое касание на мобильном, если попали НЕ в блок (или в грань блока)
+                  else if (pickedMesh && (isRightClick || (!pickedMesh.isBlock && isLeftClick))) {
+                      const normal = pickInfo.getNormal(true);
+                      const placePos = pickInfo.pickedPoint.add(normal.scale(BLOCK_SIZE / 2));
+                      const gridX = Math.floor(placePos.x / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                      const gridY = Math.floor(placePos.y / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                      const gridZ = Math.floor(placePos.z / BLOCK_SIZE) * BLOCK_SIZE + BLOCK_SIZE / 2;
+                      if (!isPositionOccupiedByPlayer(gridX, gridY, gridZ, scene.activeCamera)) {
+                          createBlock(gridX, gridY, gridZ, stoneMat, scene);
+                      } else {
+                          console.log("Нельзя разместить блок внутри себя!");
+                      }
+                  }
+              }
+         }
         // --- Запуск ---
+        const scene = createScene(); // Создаем сцену
+        // Главный цикл рендеринга
         engine.runRenderLoop(() => {
             scene.render();
         });
+        // Обработчик изменения размера окна/экрана
         window.addEventListener('resize', () => {
             engine.resize();
         });