// Create a Noa engine instance const noa = new Engine({ debug: false, showFPS: false, inverseY: false, inverseX: false, chunkSize: 32, chunkAddDistance: 2.5, chunkRemoveDistance: 3.5, playerHeight: 1.8, playerWidth: 0.6, playerAutoStep: true, useAO: true, AOmultipliers: [0.93, 0.8, 0.5], manuallyControlChunkLoading: false, blockTestDistance: 10, texturePath: '', playerStart: [0.5, 20, 0.5], clearColor: [0.8, 0.9, 1], gravity: [0, -20, 0], // Increased gravity for more realistic physics }); // Перлин шум // Improved Perlin noise implementation const permutation = [151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180 ]; // Extend the permutation table const p = new Array(512); for (let i = 0; i < 256; i++) p[256 + i] = p[i] = permutation[i]; function fade(t) { return t * t * t * (t * (t * 6 - 15) + 10); } function lerp(t, a, b) { return a + t * (b - a); } function grad(hash, x, y, z) { const h = hash & 15; const u = h < 8 ? x : y; const v = h < 4 ? y : h == 12 || h == 14 ? x : z; return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v); } function perlin(x, y, z) { const X = Math.floor(x) & 255; const Y = Math.floor(y) & 255; const Z = Math.floor(z) & 255; x -= Math.floor(x); y -= Math.floor(y); z -= Math.floor(z); const u = fade(x); const v = fade(y); const w = fade(z); const A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z; const B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z)), lerp(u, grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z))), lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1)), lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1)))); } function riverNoise(x, z) { return Math.abs(perlin(x / 400, 0, z / 400)) * Math.abs(perlin(x / 200, z / 200, 0)); } function mountainRangeNoise(x, z) { return (1 + perlin(x / 1000, 0, z / 1000)) / 2; } // Основной код const brownish = [0.45, 0.36, 0.22]; const greenish = [0.1, 0.8, 0.2]; const darkGreenish = [0.05, 0.5, 0.05]; const blueish = [0.1, 0.8, 0.2]; const redish = [0.1, 0.8, 0.2]; const sandish = [0.9, 0.8, 0.6]; const woodish = [0.6, 0.4, 0.2]; const leafish = [0.2, 0.8, 0.2]; const blueLeafish = [0.1, 0.8, 0.2]; const redLeafish = [0.1, 0.8, 0.2]; const waterish = [0.2, 0.6, 0.8]; const stoneish = [0.5, 0.5, 0.5]; const grassPlantish = [0.1, 0.8, 0.1]; let selectedColorID = 0; // Chunk storage system const chunkStorage = new Map(); function getChunkKey(x, y, z) { return `${x},${y},${z}`; } function saveChunk(chunkX, chunkY, chunkZ, chunkData) { const key = getChunkKey(chunkX, chunkY, chunkZ); chunkStorage.set(key, chunkData); } function loadChunk(chunkX, chunkY, chunkZ) { const key = getChunkKey(chunkX, chunkY, chunkZ); return chunkStorage.get(key); } const dirtMaterial = noa.registry.registerMaterial('dirt', { color: brownish }); const grassMaterial = noa.registry.registerMaterial('grass', { color: greenish }); const darkGrassMaterial = noa.registry.registerMaterial('darkGrass', { color: darkGreenish }); const blueMaterial = noa.registry.registerMaterial('blue', { color: blueish }); const redMaterial = noa.registry.registerMaterial('red', { color: redish }); const sandMaterial = noa.registry.registerMaterial('sand', { color: sandish }); const woodMaterial = noa.registry.registerMaterial('wood', { color: woodish }); const leafMaterial = noa.registry.registerMaterial('leaf', { color: leafish }); const blueLeafMaterial = noa.registry.registerMaterial('blueLeaf', { color: blueLeafish }); const redLeafMaterial = noa.registry.registerMaterial('redLeaf', { color: redLeafish }); const waterMaterial = noa.registry.registerMaterial('water', { color: [0.2, 0.6, 0.8, 0.7], // Added alpha channel for transparency properties: { reflectivity: 0.6, specularPower: 64, specularColor: [1, 1, 1], useSpecularOverAlpha: true, alpha: 0.7 } }); const stoneMaterial = noa.registry.registerMaterial('stone', { color: stoneish }); const grassPlantMaterial = noa.registry.registerMaterial('grassPlant', { color: grassPlantish }); const dirtID = noa.registry.registerBlock(1, { material: 'dirt' }); const grassID = noa.registry.registerBlock(2, { material: 'grass' }); const darkGrassID = noa.registry.registerBlock(3, { material: 'darkGrass' }); const blueGrassID = noa.registry.registerBlock(4, { material: 'blue' }); const redGrassID = noa.registry.registerBlock(5, { material: 'red' }); const sandID = noa.registry.registerBlock(6, { material: 'sand' }); const woodID = noa.registry.registerBlock(7, { material: 'wood' }); const leafID = noa.registry.registerBlock(8, { material: 'leaf' }); const blueLeafID = noa.registry.registerBlock(9, { material: 'blueLeaf' }); const redLeafID = noa.registry.registerBlock(10, { material: 'redLeaf' }); const waterID = noa.registry.registerBlock(11, { material: 'water', fluid: true, opaque: false, fluidDensity: 0.8, viscosity: 0.5 }); const pineLeafID = noa.registry.registerBlock(12, { material: 'pineLeaf' }); const jungleLeafID = noa.registry.registerBlock(13, { material: 'jungleLeaf' }); const africanLeafID = noa.registry.registerBlock(14, { material: 'africanLeaf' }); const stoneID = noa.registry.registerBlock(15, { material: 'stone' }); const grassPlantID = noa.registry.registerBlock(16, { material: 'grassPlant', opaque: false, solid: false }); //const caveID = noa.registry.registerBlock(12, { material: 'dirt' }); // Блок для пещер //const airID = 0; // Воздух для генерации пещер const colors = [dirtID, grassID, darkGrassID, blueGrassID, redGrassID, sandID, grassPlantID]; function getVoxelID(x, y, z) { const baseHeight = Math.floor(60 * (perlin(x / 300, y / 300, z / 300) * 0.5 + 0.5)); const mountainNoise = Math.max(0, perlin(x / 500, y / 500, z / 500)); const biomeNoise = perlin(x / 800, y / 800, z / 800); const riverValue = riverNoise(x, z); const waterLevel = 40; // Generate smoother terrain without high mountains let terrainHeight = baseHeight + Math.floor(mountainNoise * 20); // Generate water bodies (oceans and lakes) if (y <= waterLevel && y > terrainHeight) { return waterID; } // Generate terrain blocks if (y < terrainHeight - 5) { return stoneID; } else if (y < terrainHeight - 3) { return dirtID; } else if (y < terrainHeight) { // Create a gradient from stone/dirt to surface block return (Math.random() < (terrainHeight - y) / 3) ? (y < terrainHeight - 4 ? stoneID : dirtID) : getSurfaceBlock(biomeNoise, y, waterLevel, terrainHeight); } else if (y === terrainHeight) { // Check if the block is underwater if (y < waterLevel) { return sandID; // Use sand for underwater surface } else { return getSurfaceBlock(biomeNoise, y, waterLevel, terrainHeight); } } else { return 0; // Air above the surface } } function getSurfaceBlock(biomeNoise, y, waterLevel, terrainHeight) { if (y < waterLevel) { // Underwater surface return Math.random() < 0.7 ? sandID : dirtID; // 70% sand, 30% dirt underwater } else if (y === waterLevel) { return sandID; // Create sandy shores } else if (terrainHeight > 70) { // Slightly elevated areas return Math.random() < 0.6 ? grassID : stoneID; // Mix of grass and stone } else if (biomeNoise < -0.3) { return darkGrassID; } else if (biomeNoise < -0.1) { return blueGrassID; } else if (biomeNoise > 0.4) { return sandID; } else if (biomeNoise > 0.2) { return redGrassID; } else { return grassID; } } function placeGrassPlants(data, i, j, k) { const surfaceBlockID = data.get(i, j, k); if (surfaceBlockID === grassID || surfaceBlockID === darkGrassID || surfaceBlockID === blueGrassID || surfaceBlockID === redGrassID) { if (data.get(i, j + 1, k) === 0 && Math.random() < 0.1) { data.set(i, j + 1, k, grassPlantID); } } } noa.world.on('worldDataNeeded', function(id, data, x, y, z) { const loadedChunk = loadChunk(x, y, z); if (loadedChunk) { // If the chunk was previously saved, load it for (let i = 0; i < data.shape[0]; i++) { for (let j = 0; j < data.shape[1]; j++) { for (let k = 0; k < data.shape[2]; k++) { data.set(i, j, k, loadedChunk[i][j][k]); } } } } else { // Generate a new chunk for (let i = 0; i < data.shape[0]; i++) { for (let j = 0; j < data.shape[1]; j++) { for (let k = 0; k < data.shape[2]; k++) { const voxelID = getVoxelID(x + i, y + j, z + k); data.set(i, j, k, voxelID); } } } // Tree generation for (let i = 0; i < data.shape[0]; i++) { for (let k = 0; k < data.shape[2]; k++) { let j = data.shape[1] - 1; while (j > 0 && data.get(i, j, k) === 0) j--; if (j > 0 && data.get(i, j, k) !== waterID) { const blockID = data.get(i, j, k); const terrainHeight = j; if (blockID === grassID && Math.random() < 0.02) { if (generateSimpleTree(data, i, j + 1, k)) continue; } else if (blockID === stoneID && terrainHeight > 150 && Math.random() < 0.005) { if (generateMountainTree(data, i, j + 1, k)) continue; } } } } // Add grass plants for (let i = 0; i < data.shape[0]; i++) { for (let k = 0; k < data.shape[2]; k++) { let j = data.shape[1] - 1; while (j > 0 && data.get(i, j, k) === 0) j--; if (j > 0) { placeGrassPlants(data, i, j, k); } } } // Save the newly generated chunk saveChunk(x, y, z, data.raw); } noa.world.setChunkData(id, data); }); function applyPhysicsToChunk(chunkX, chunkY, chunkZ, chunkShape) { // This function is now empty as we've removed block physics } // Function to handle block physics // The handleBlockPhysics function has been removed function generateOakTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 3) + 5; // Generate trunk for (let h = 0; h < treeHeight; h++) { if (data.get(i, j + h, k) === 0) { data.set(i, j + h, k, woodID); } } // Generate leaves for (let dx = -2; dx <= 2; dx++) { for (let dy = -2; dy <= 2; dy++) { for (let dz = -2; dz <= 2; dz++) { if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) <= 3) { const x = i + dx; const y = j + treeHeight + dy - 1; const z = k + dz; if (data.get(x, y, z) === 0) { data.set(x, y, z, leafID); } } } } } } function generateBirchTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 2) + 6; // Generate trunk for (let h = 0; h < treeHeight; h++) { if (data.get(i, j + h, k) === 0) { data.set(i, j + h, k, woodID); } } // Generate leaves for (let dx = -2; dx <= 2; dx++) { for (let dy = -2; dy <= 2; dy++) { for (let dz = -2; dz <= 2; dz++) { if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) <= 3) { const x = i + dx; const y = j + treeHeight + dy - 1; const z = k + dz; if (data.get(x, y, z) === 0) { data.set(x, y, z, blueLeafID); } } } } } } function generateSpruceTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 5) + 7; // Generate trunk for (let h = 0; h < treeHeight; h++) { if (data.get(i, j + h, k) === 0) { data.set(i, j + h, k, woodID); } } // Generate leaves for (let y = 1; y < treeHeight - 1; y++) { const radius = Math.min(2, Math.floor((treeHeight - y) / 3) + 1); for (let dx = -radius; dx <= radius; dx++) { for (let dz = -radius; dz <= radius; dz++) { if (Math.abs(dx) + Math.abs(dz) <= radius) { const x = i + dx; const z = k + dz; if (data.get(x, j + y, z) === 0) { data.set(x, j + y, z, redLeafID); } } } } } } function generateJungleTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 7) + 9; // Generate trunk for (let h = 0; h < treeHeight; h++) { if (data.get(i, j + h, k) === 0) { data.set(i, j + h, k, woodID); } } // Generate leaves for (let dx = -2; dx <= 2; dx++) { for (let dy = -3; dy <= 1; dy++) { for (let dz = -2; dz <= 2; dz++) { if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) <= 4) { const x = i + dx; const y = j + treeHeight + dy - 1; const z = k + dz; if (data.get(x, y, z) === 0) { data.set(x, y, z, jungleLeafID); } } } } } } function generateSimpleTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 3) + 4; // Trees from 4 to 6 blocks tall // Generate trunk for (let y = 0; y < treeHeight; y++) { setBlockIfEmpty(data, i, j + y, k, woodID); } // Generate leaves for (let dx = -2; dx <= 2; dx++) { for (let dy = -2; dy <= 2; dy++) { for (let dz = -2; dz <= 2; dz++) { if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) <= 3) { const x = i + dx; const y = j + treeHeight + dy - 1; const z = k + dz; if (setBlockIfEmpty(data, x, y, z, leafID)) { // Leaf placed successfully } } } } } return true; } function generateMountainTree(data, i, j, k) { const treeHeight = Math.floor(Math.random() * 2) + 3; // Shorter trees for mountains // Generate trunk for (let y = 0; y < treeHeight; y++) { setBlockIfEmpty(data, i, j + y, k, woodID); } // Generate sparse leaves for (let dx = -1; dx <= 1; dx++) { for (let dy = -1; dy <= 1; dy++) { for (let dz = -1; dz <= 1; dz++) { if (Math.abs(dx) + Math.abs(dy) + Math.abs(dz) <= 2 && Math.random() < 0.7) { const x = i + dx; const y = j + treeHeight + dy - 1; const z = k + dz; setBlockIfEmpty(data, x, y, z, leafID); } } } } return true; } function setBlockIfEmpty(data, x, y, z, blockID) { if (data.get(x, y, z) === 0) { data.set(x, y, z, blockID); return true; } return false; } // Добавленная функция для установки начальной позиции игрока function getPlayerSpawnHeight(x, z) { let y = 100; // Start from a high point // Find the first non-air block (surface) while (y > 0 && getVoxelID(x, y, z) === 0) { y--; } // Check if it's water, and if so, continue searching for solid ground while (y > 0 && getVoxelID(x, y, z) === waterID) { y--; } // Move up one block to ensure player is on top of the surface return y + 1; } function findSafeSpawnLocation() { let attempts = 0; const maxAttempts = 100; let spawnX, spawnZ, spawnY; while (attempts < maxAttempts) { spawnX = Math.floor(Math.random() * 200) - 100; // Random X between -100 and 100 spawnZ = Math.floor(Math.random() * 200) - 100; // Random Z between -100 and 100 spawnY = getPlayerSpawnHeight(spawnX, spawnZ); // Check if the spawn location is safe (not water and has air above) if (getVoxelID(spawnX, spawnY - 1, spawnZ) !== waterID && getVoxelID(spawnX, spawnY, spawnZ) === 0 && getVoxelID(spawnX, spawnY + 1, spawnZ) === 0) { return [spawnX, spawnY, spawnZ]; } attempts++; } // If no safe location found, return a default location return [0, getPlayerSpawnHeight(0, 0), 0]; } const [spawnX, spawnY, spawnZ] = findSafeSpawnLocation(); const player = noa.playerEntity; const dat = noa.entities.getPositionData(player); const w = dat.width; const h = dat.height; // Set player position to spawn point noa.ents.setPosition(player, spawnX, spawnY, spawnZ); const scene = noa.rendering.getScene(); scene.clearColor = new BABYLON.Color3(0.7, 0.7, 1); // Установка цвета неба const mesh = BABYLON.MeshBuilder.CreateBox('player-mesh', {}, scene); mesh.scaling.x = w; mesh.scaling.z = w; mesh.scaling.y = h; mesh.material = noa.rendering.makeStandardMaterial("default"); noa.entities.addComponent(player, noa.entities.names.mesh, { mesh: mesh, offset: [0, h / 2, 0], }); noa.inputs.down.on('fire', function() { if (noa.targetedBlock) { const pos = noa.targetedBlock.position; noa.setBlock(0, pos[0], pos[1], pos[2]); updateChunkStorage(pos[0], pos[1], pos[2], 0); } }); noa.inputs.down.on('alt-fire', function() { if (noa.targetedBlock) { const pos = noa.targetedBlock.adjacent; const blockID = colors[selectedColorID]; noa.setBlock(blockID, pos[0], pos[1], pos[2]); updateChunkStorage(pos[0], pos[1], pos[2], blockID); } }); function updateChunkStorage(x, y, z, blockID) { const chunkSize = noa.world.chunkSize; const chunkX = Math.floor(x / chunkSize) * chunkSize; const chunkY = Math.floor(y / chunkSize) * chunkSize; const chunkZ = Math.floor(z / chunkSize) * chunkSize; const chunk = loadChunk(chunkX, chunkY, chunkZ); if (chunk) { const localX = x - chunkX; const localY = y - chunkY; const localZ = z - chunkZ; chunk[localX][localY][localZ] = blockID; saveChunk(chunkX, chunkY, chunkZ, chunk); } } // binding keys 1-9 to select color for (let i = 1; i <= 9; i++) { noa.inputs.bind(i.toString(), 'Digit' + i); noa.inputs.down.on(i.toString(), function() { selectedColorID = i - 1; }); } noa.on('tick', function(dt) { const scroll = noa.inputs.pointerState.scrolly; if (scroll !== 0) { noa.camera.zoomDistance += scroll > 0 ? 1 : -1; if (noa.camera.zoomDistance < 0) noa.camera.zoomDistance = 0; if (noa.camera.zoomDistance > 10) noa.camera.zoomDistance = 10; } // Water physics if (isPlayerInWater()) { const body = noa.ents.getPhysicsBody(noa.playerEntity); body.gravityMultiplier = 0.3; // Reduced gravity in water body.friction = 0.1; // Reduced friction in water body.floatsOnWater = true; // Makes the player float // Buoyancy effect const waterSurfaceY = Math.floor(noa.ents.getPosition(noa.playerEntity)[1]) + 1; const playerY = noa.ents.getPosition(noa.playerEntity)[1]; const depth = waterSurfaceY - playerY; if (depth > 0) { body.applyForce([0, 9.8 * 0.5 * depth, 0]); // Upward force based on depth } // Swimming controls if (noa.inputs.state.forward || noa.inputs.state.backward || noa.inputs.state.left || noa.inputs.state.right) { const swimSpeed = 0.1; const moveVector = [0, 0, 0]; if (noa.inputs.state.forward) moveVector[2] -= 1; if (noa.inputs.state.backward) moveVector[2] += 1; if (noa.inputs.state.left) moveVector[0] -= 1; if (noa.inputs.state.right) moveVector[0] += 1; noa.ents.addComponent(noa.playerEntity, noa.entities.names.movement, { impulse: moveVector.map(v => v * swimSpeed) }); } } else { // Reset physics when out of water const body = noa.ents.getPhysicsBody(noa.playerEntity); body.gravityMultiplier = 1; body.friction = 1; body.floatsOnWater = false; } }); // Handle chunk unloading noa.world.on('chunkBeingRemoved', function(id, data, x, y, z) { saveChunk(x, y, z, data.raw); }); // Adjust player jump mechanics noa.inputs.down.on('jump', function() { if (isPlayerInWater()) { const body = noa.ents.getPhysicsBody(noa.playerEntity); body.applyImpulse([0, 5, 0]); // Swim upwards } else if (noa.ents.getState(noa.playerEntity, 'physics').body.resting[1] === -1) { const body = noa.ents.getPhysicsBody(noa.playerEntity); body.applyImpulse([0, 7, 0]); // Normal jump } }); function isPlayerInWater() { const pos = noa.ents.getPosition(noa.playerEntity); const blockID = noa.world.getBlockID(Math.floor(pos[0]), Math.floor(pos[1] + 1), Math.floor(pos[2])); return blockID === waterID; }