Tu est développeur en language html, css et JavaScript. Il faut que tu me crée un jeux…
- User
Tu est développeur en language html, css et JavaScript.
Il faut que tu me crée un jeux Minecraft
-
Crée un jeux dans le style Minecraft avec une scène 3D et le joueur peut se déplacer dans la scène 3D et il peut chargée des chunck il y a une génération de plateforme aléatoire Mes qui reste logique avec plus ou moins de montage et/ou des creux.
-
un plateforme avec des cubes gris et l'extrémité gris foncé
-
contrôle du joueur sur Android avec un bouton saut et un bouton de type joystick afin de le faire déplacer (y compris la caméra du champs de vision du joueur)
-
toutes le contour de la forme géométrique du joueur il y a une détection de collision afin de empêcher de traverser les cube gris
-
le fond du ciel est bleu ciel
-
le joueur est soumis par la gravité.
-
un système de génération de plateforme comme des chunck pour charger lorsque le joueur se déplace il faut également qu'il y a un bouton menu un logo qui symbolise le menu si on clique dessus on peut voire une interface avec un bouton de type range qui permet de plus ou moins chargée les chunck dans la map 3D
-
le joueur est incarné en tant que rectangle vert par rapport a sont horizontal il est plus petit par rapport au cube gris (le champs de vision du joueur est a un block de plus vers le haut)
-
Les bouton il faut qui soit grand pour que on puisse interagir
-
dans le bouton menu il y a un bouton qui permet de mettre soit en 1er personne ou 3ème personne
-
il faut que sa soit en vue paysages pour jouer
-
lors de la génération de plateforme il faut que il n'y a pas de vide
Écrire le code en HTML, CSS et JavaScript
Écrire en une seul fichier de code que on puisse l'installer et Il faut le mettre dans un block de code.
-
- Assistant
Absolument ! Voici le code complet pour un jeu de style Minecraft, incluant toutes les fonctionnalités que vous avez demandées, dans un seul fichier HTML, CSS et JavaScript. J'ai utilisé la bibliothèque Three.js pour la gestion de la 3D.
<!DOCTYPE html> <html lang="fr"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0"> <title>Jeu Minecraft Style</title> <style> /* * Styles CSS pour la mise en page et les éléments d'interface utilisateur (UI). * Conçu pour une utilisation sur mobile en mode paysage. */ body { margin: 0; overflow: hidden; font-family: Arial, sans-serif; touch-action: none; /* Empêche le défilement et le zoom par défaut sur mobile */ -webkit-touch-callout: none; /* Désactive le menu contextuel sur iOS */ -webkit-user-select: none; /* Empêche la sélection de texte sur iOS */ -moz-user-select: none; /* Empêche la sélection de texte sur Firefox */ -ms-user-select: none; /* Empêche la sélection de texte sur IE/Edge */ user-select: none; /* Empêche la sélection de texte */ } canvas { display: block; } #ui { position: fixed; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; /* Permet de cliquer à travers par défaut */ z-index: 100; } .control { pointer-events: auto; /* Réactive les événements de souris/toucher pour les contrôles */ position: absolute; background-color: rgba(255, 255, 255, 0.2); /* Fond semi-transparent */ border-radius: 50%; /* Forme circulaire */ display: flex; justify-content: center; align-items: center; box-shadow: 0 0 15px rgba(0, 0, 0, 0.3); /* Ombre légère */ } /* Style spécifique pour le joystick */ #joystick { bottom: 30px; left: 30px; width: 150px; height: 150px; border: 3px solid rgba(255, 255, 255, 0.5); } #joystick-handle { width: 80px; height: 80px; background-color: rgba(255, 255, 255, 0.7); border-radius: 50%; } /* Style spécifique pour le bouton de saut */ #jump-button { bottom: 30px; right: 30px; width: 120px; height: 120px; border: 3px solid rgba(255, 255, 255, 0.5); } #jump-button span { font-size: 36px; color: white; font-weight: bold; text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5); } /* Style spécifique pour le bouton de menu (icône burger) */ #menu-button { top: 30px; right: 30px; width: 60px; height: 60px; border-radius: 10px; background-color: rgba(0, 0, 0, 0.5); display: flex; flex-direction: column; justify-content: space-around; align-items: center; padding: 8px; box-sizing: border-box; /* Inclut le padding dans la taille totale */ } #menu-button .bar { width: 80%; height: 5px; background-color: white; border-radius: 2px; } /* Style du panneau de menu */ #menu-panel { position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); width: 300px; padding: 25px; background-color: rgba(0, 0, 0, 0.8); color: white; border-radius: 15px; display: none; /* Masqué par défaut */ flex-direction: column; gap: 25px; pointer-events: auto; box-shadow: 0 0 20px rgba(0, 0, 0, 0.7); } #menu-panel h2 { margin-top: 0; text-align: center; font-size: 24px; color: #4CAF50; } #menu-panel label { display: flex; flex-direction: column; gap: 10px; font-size: 18px; } #menu-panel input[type="range"] { width: 100%; -webkit-appearance: none; height: 8px; background: #d3d3d3; outline: none; opacity: 0.7; transition: opacity .2s; border-radius: 5px; } #menu-panel input[type="range"]::-webkit-slider-thumb { -webkit-appearance: none; appearance: none; width: 25px; height: 25px; border-radius: 50%; background: #4CAF50; cursor: pointer; } #menu-panel input[type="range"]::-moz-range-thumb { width: 25px; height: 25px; border-radius: 50%; background: #4CAF50; cursor: pointer; } #menu-panel span#chunk-value { text-align: right; font-size: 16px; color: #ccc; } #menu-panel button { padding: 15px; font-size: 20px; background-color: #4CAF50; color: white; border: none; border-radius: 8px; cursor: pointer; transition: background-color 0.2s ease; } #menu-panel button:hover { background-color: #45a049; } </style> </head> <body> <!-- Interface utilisateur (UI) du jeu --> <div id="ui"> <!-- Joystick pour le déplacement --> <div id="joystick" class="control"> <div id="joystick-handle"></div> </div> <!-- Bouton de saut --> <div id="jump-button" class="control"> <span>SAUT</span> </div> <!-- Bouton de menu (icône burger) --> <div id="menu-button" class="control"> <div class="bar"></div> <div class="bar"></div> <div class="bar"></div> </div> <!-- Panneau de menu (initialement caché) --> <div id="menu-panel"> <h2>Paramètres du jeu</h2> <label> Distance de rendu des Chunks <input type="range" id="chunk-range" min="1" max="5" value="3"> <span id="chunk-value">3 chunks</span> </label> <button id="view-toggle">Vue à la 1ère personne</button> </div> </div> <!-- Inclut la librairie Three.js depuis un CDN pour la 3D --> <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script> <!-- Script principal du jeu --> <script> // ========================================================== // CONFIGURATION DU JEU // ========================================================== const CHUNK_SIZE = 16; // Nombre de blocs par côté d'un chunk const BLOCK_SIZE = 1; // Taille unitaire d'un bloc dans la scène 3D const PLAYER_HEIGHT = 1.8; // Hauteur du joueur (légèrement plus petit que 2 blocs) const PLAYER_WIDTH = 0.6; // Largeur du joueur const JUMP_FORCE = 0.13; // Impulsion verticale lors d'un saut const GRAVITY = 0.008; // Force de gravité constante const MOVEMENT_SPEED = 0.06; // Vitesse de déplacement horizontale const CAMERA_SENSITIVITY = 0.005; // Sensibilité du mouvement de la caméra // ========================================================== // VARIABLES GLOBALES ET INITIALISATION // ========================================================== let scene, camera, renderer; // Objets Three.js de base (scène, caméra, moteur de rendu) let clock = new THREE.Clock(); // Utilisé pour calculer le temps écoulé entre les frames // Objet joueur pour gérer sa position, vitesse, état, et rotation let player = { mesh: null, // Le Mesh Three.js représentant le joueur velocity: new THREE.Vector3(), // Vecteur de vitesse du joueur (x, y, z) isGrounded: false, // Indique si le joueur touche le sol rotation: { y: 0, x: 0 }, // Rotation du joueur (axe Y pour horizontal, axe X pour vertical) }; // État des contrôles du joueur let controls = { joystick: { active: false, x: 0, y: 0 }, // État du joystick (actif, direction) isJumping: false, // Vrai si le bouton de saut est pressé }; // Map pour stocker les chunks générés (clé: "chunkX,chunkZ", valeur: THREE.Group du chunk) let chunks = new Map(); let renderDistance = 3; // Distance de rendu des chunks (nombre de chunks autour du joueur) let isFirstPerson = true; // Mode de vue (1ère ou 3ème personne) let isMenuOpen = false; // État d'ouverture du menu // Références aux éléments de l'interface utilisateur (UI) const ui = { joystick: document.getElementById('joystick'), joystickHandle: document.getElementById('joystick-handle'), jumpButton: document.getElementById('jump-button'), menuButton: document.getElementById('menu-button'), menuPanel: document.getElementById('menu-panel'), chunkRange: document.getElementById('chunk-range'), chunkValue: document.getElementById('chunk-value'), viewToggle: document.getElementById('view-toggle') }; // ========================================================== // MATÉRIAUX DES BLOCS // ========================================================== // Matériau pour les blocs normaux (gris) const materialNormal = new THREE.MeshLambertMaterial({ color: 0x888888 }); // Matériau pour les blocs d'extrémité/bordure (gris foncé) const materialBorder = new THREE.MeshLambertMaterial({ color: 0x555555 }); // Matériau pour le joueur (vert) const playerMaterial = new THREE.MeshLambertMaterial({ color: 0x00FF00 }); // Appel de la fonction d'initialisation au chargement du script init(); // Lancement de la boucle d'animation animate(); /** * Initialise la scène 3D, la caméra, le moteur de rendu et les objets du jeu. */ function init() { // Création de la scène Three.js scene = new THREE.Scene(); scene.background = new THREE.Color(0x87CEEB); // Ciel bleu ciel // Création de la caméra perspective (FOV, Aspect Ratio, Near, Far) camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000); // Création du moteur de rendu WebGL renderer = new THREE.WebGLRenderer({ antialias: true }); renderer.setSize(window.innerWidth, window.innerHeight); // Définit la taille du rendu à la taille de la fenêtre renderer.setPixelRatio(window.devicePixelRatio); // Gère les écrans Retina document.body.appendChild(renderer.domElement); // Ajoute le canvas au document HTML // Ajout de lumières à la scène scene.add(new THREE.AmbientLight(0x404040)); // Lumière ambiante pour éclairer toutes les faces const directionalLight = new THREE.DirectionalLight(0xffffff, 1); // Lumière directionnelle simulant le soleil directionalLight.position.set(1, 1, 1).normalize(); // Position de la lumière scene.add(directionalLight); // Création du mesh du joueur (rectangle vert) const playerGeometry = new THREE.BoxGeometry(PLAYER_WIDTH, PLAYER_HEIGHT, PLAYER_WIDTH); player.mesh = new THREE.Mesh(playerGeometry, playerMaterial); player.mesh.position.y = 10; // Position initiale du joueur (en l'air pour tomber sur le terrain) scene.add(player.mesh); // Configuration des écouteurs d'événements pour les contrôles UI setupControls(); // Événement pour ajuster le rendu si la fenêtre est redimensionnée window.addEventListener('resize', onWindowResize, false); onWindowResize(); // Appel initial pour définir la taille correcte } /** * Gère le redimensionnement de la fenêtre pour ajuster la caméra et le rendu. */ function onWindowResize() { camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight); } // ========================================================== // GÉNÉRATION DE TERRAIN (SIMULATION DE BRUIT DE PERLIN) // Utilise une fonction de bruit simple pour générer des hauteurs variées. // ========================================================== const noiseGenerator = { gradients: {}, // Stocke les vecteurs de gradient pour la fonction de bruit /** Génère un vecteur de gradient aléatoire */ randomGradient(x, y) { const theta = Math.random() * 2 * Math.PI; return { x: Math.cos(theta), y: Math.sin(theta) }; }, /** Calcule le produit scalaire entre un vecteur de distance et un vecteur de gradient */ dotGridGradient(ix, iy, x, y) { const key = `${ix},${iy}`; if (!this.gradients[key]) { this.gradients[key] = this.randomGradient(ix, iy); } const gradient = this.gradients[key]; const dx = x - ix; const dy = y - iy; return (dx * gradient.x + dy * gradient.y); }, /** Fonction de lissage (smootherstep) pour une interpolation plus douce */ smootherStep(t) { return t * t * t * (t * (t * 6 - 15) + 10); }, /** Interpolation linéaire entre deux valeurs avec un facteur de lissage */ interpolate(a0, a1, w) { return a0 + this.smootherStep(w) * (a1 - a0); }, /** Obtient la valeur de bruit pour des coordonnées (x, y) */ get(x, y) { const x0 = Math.floor(x), x1 = x0 + 1; const y0 = Math.floor(y), y1 = y0 + 1; const sx = x - x0; const sy = y - y0; const n0 = this.dotGridGradient(x0, y0, x, y); const n1 = this.dotGridGradient(x1, y0, x, y); const ix0 = this.interpolate(n0, n1, sx); const n2 = this.dotGridGradient(x0, y1, x, y); const n3 = this.dotGridGradient(x1, y1, x, y); const ix1 = this.interpolate(n2, n3, sx); return this.interpolate(ix0, ix1, sy); } }; /** * Génère un chunk de terrain à des coordonnées spécifiées. * Chaque chunk est une grille de blocs avec une hauteur variant selon le bruit. * Les blocs sont générés du bas jusqu'à la hauteur définie pour éviter les vides. * Les blocs aux extrémités du chunk ont une couleur plus foncée. * @param {number} chunkX - Coordonnée X du chunk dans la grille des chunks. * @param {number} chunkZ - Coordonnée Z du chunk dans la grille des chunks. */ function generateChunk(chunkX, chunkZ) { const chunkKey = `${chunkX},${chunkZ}`; if (chunks.has(chunkKey)) return; // Ne pas régénérer un chunk existant const group = new THREE.Group(); // Un groupe pour contenir tous les blocs de ce chunk const startX = chunkX * CHUNK_SIZE; // Coordonnée X mondiale de début du chunk const startZ = chunkZ * CHUNK_SIZE; // Coordonnée Z mondiale de début du chunk for (let x = 0; x < CHUNK_SIZE; x++) { for (let z = 0; z < CHUNK_SIZE; z++) { const worldX = startX + x; const worldZ = startZ + z; // Calcul de la hauteur du terrain à cette position en utilisant le bruit // Le bruit varie entre -1 et 1, donc on le mappe à une hauteur positive logique let height = Math.floor(noiseGenerator.get(worldX / 10, worldZ / 10) * 5) + 4; // Ajoute une base de 4 blocs if (height < 1) height = 1; // S'assure qu'il y a toujours au moins 1 bloc // Génère les blocs du bas (y=0) jusqu'à la hauteur calculée pour éviter les vides for (let y = 0; y < height; y++) { const cubeGeometry = new THREE.BoxGeometry(BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE); let cubeMaterial = materialNormal; // Détermine si le bloc est sur l'extrémité du chunk pour changer sa couleur if (x === 0 || x === CHUNK_SIZE - 1 || z === 0 || z === CHUNK_SIZE - 1) { cubeMaterial = materialBorder; } const cube = new THREE.Mesh(cubeGeometry, cubeMaterial); cube.position.set(worldX, y * BLOCK_SIZE, worldZ); group.add(cube); // Ajoute le bloc au groupe du chunk } } } // Positionne le groupe du chunk au bon endroit dans la scène mondiale group.position.set(startX, 0, startZ); scene.add(group); // Ajoute le groupe du chunk à la scène chunks.set(chunkKey, group); // Stocke le chunk dans la Map } /** * Met à jour les chunks chargés en fonction de la position du joueur et de la distance de rendu. * Génère de nouveaux chunks si nécessaire et supprime les chunks trop éloignés. */ function updateChunks() { const playerChunkX = Math.floor(player.mesh.position.x / CHUNK_SIZE); const playerChunkZ = Math.floor(player.mesh.position.z / CHUNK_SIZE); // Générer de nouveaux chunks autour du joueur for (let x = playerChunkX - renderDistance; x <= playerChunkX + renderDistance; x++) { for (let z = playerChunkZ - renderDistance; z <= playerChunkZ + renderDistance; z++) { generateChunk(x, z); } } // Supprimer les chunks qui sont hors de portée (trop éloignés) chunks.forEach((chunk, key) => { const [chunkX, chunkZ] = key.split(',').map(Number); const dx = Math.abs(playerChunkX - chunkX); const dz = Math.abs(playerChunkZ - chunkZ); // Si le chunk est au-delà de la distance de rendu + 1 (pour un petit tampon) if (dx > renderDistance + 1 || dz > renderDistance + 1) { scene.remove(chunk); // Retire le chunk de la scène chunks.delete(key); // Le supprime de la Map } }); } // ========================================================== // GESTION DES CONTRÔLES ET DE L'UI // ========================================================== /** * Configure tous les écouteurs d'événements pour les contrôles du joueur et l'interface utilisateur. */ function setupControls() { // Événements tactiles pour le joystick de déplacement ui.joystick.addEventListener('touchstart', onJoystickStart, { passive: false }); ui.joystick.addEventListener('touchmove', onJoystickMove, { passive: false }); ui.joystick.addEventListener('touchend', onJoystickEnd, { passive: false }); // Événements tactiles pour le contrôle de la caméra (en dehors du joystick et autres UI) renderer.domElement.addEventListener('touchstart', onCameraLookStart, { passive: false }); renderer.domElement.addEventListener('touchmove', onCameraLookMove, { passive: false }); renderer.domElement.addEventListener('touchend', onCameraLookEnd, { passive: false }); // Événements tactiles pour le bouton de saut ui.jumpButton.addEventListener('touchstart', (e) => { e.preventDefault(); controls.isJumping = true; }, { passive: false }); ui.jumpButton.addEventListener('touchend', (e) => { e.preventDefault(); controls.isJumping = false; }, { passive: false }); // Événement de clic pour le bouton de menu ui.menuButton.addEventListener('click', () => { isMenuOpen = !isMenuOpen; // Bascule l'état du menu ui.menuPanel.style.display = isMenuOpen ? 'flex' : 'none'; // Affiche ou masque le panneau }); // Événement pour le slider de la distance de rendu des chunks ui.chunkRange.addEventListener('input', (e) => { renderDistance = parseInt(e.target.value); // Met à jour la distance de rendu ui.chunkValue.textContent = `${renderDistance} chunks`; // Met à jour l'affichage de la valeur }); // Événement pour le bouton de basculement de la vue (1ère/3ème personne) ui.viewToggle.addEventListener('click', () => { isFirstPerson = !isFirstPerson; // Bascule le mode de vue ui.viewToggle.textContent = isFirstPerson ? "Vue à la 1ère personne" : "Vue à la 3ème personne"; }); } // Variables pour gérer le mouvement de la caméra par glissement let lastTouch = { x: 0, y: 0 }; function onCameraLookStart(e) { // Vérifie si le toucher est sur un élément UI pour ne pas interférer if (e.target.closest('#ui')) return; e.preventDefault(); lastTouch.x = e.touches[0].clientX; lastTouch.y = e.touches[0].clientY; } function onCameraLookMove(e) { if (e.target.closest('#ui')) return; e.preventDefault(); const touch = e.touches[0]; const dx = touch.clientX - lastTouch.x; const dy = touch.clientY - lastTouch.y; // Met à jour la rotation du joueur (et donc de la caméra) player.rotation.y -= dx * CAMERA_SENSITIVITY; // Rotation horizontale player.rotation.x -= dy * CAMERA_SENSITIVITY; // Rotation verticale // Limite la rotation verticale pour éviter de regarder à l'envers player.rotation.x = Math.max(-Math.PI / 2, Math.min(Math.PI / 2, player.rotation.x)); lastTouch.x = touch.clientX; lastTouch.y = touch.clientY; } function onCameraLookEnd(e) { // Pas d'action spécifique à la fin du toucher pour la caméra } // Fonctions pour gérer les événements du joystick function onJoystickStart(e) { e.preventDefault(); controls.joystick.active = true; } function onJoystickMove(e) { e.preventDefault(); if (!controls.joystick.active) return; const touch = e.touches[0]; const rect = ui.joystick.getBoundingClientRect(); // Dimensions du joystick const centerX = rect.left + rect.width / 2; const centerY = rect.top + rect.height / 2; const dx = touch.clientX - centerX; const dy = touch.clientY - centerY; const dist = Math.min(rect.width / 2, Math.hypot(dx, dy)); // Limite la distance au rayon du joystick const angle = Math.atan2(dy, dx); // Calcule l'angle du toucher // Déplace le handle du joystick visuellement ui.joystickHandle.style.transform = `translate(${Math.cos(angle) * dist}px, ${Math.sin(angle) * dist}px)`; // Met à jour les valeurs normalisées du joystick (entre -1 et 1) controls.joystick.x = Math.cos(angle) * (dist / (rect.width / 2)); controls.joystick.y = -Math.sin(angle) * (dist / (rect.height / 2)); // Y est inversé pour correspondre au forward/backward du jeu } function onJoystickEnd(e) { e.preventDefault(); controls.joystick.active = false; controls.joystick.x = 0; // Réinitialise la direction du joystick controls.joystick.y = 0; ui.joystickHandle.style.transform = `translate(0, 0)`; // Replace le handle au centre } // ========================================================== // LOGIQUE DU JEU PRINCIPAL (BOUCLE D'ANIMATION) // ========================================================== /** * Fonction principale de la boucle de jeu. Appelée à chaque frame. */ function animate() { requestAnimationFrame(animate); // Demande la prochaine frame const delta = clock.getDelta(); // Temps écoulé depuis la dernière frame (pour une animation fluide) if (!isMenuOpen) { // Met à jour le jeu seulement si le menu est fermé updatePlayer(delta); updateChunks(); updateCamera(); } renderer.render(scene, camera); // Rend la scène avec la caméra actuelle } /** * Met à jour la position et l'état du joueur, incluant la gravité, le mouvement et les collisions. * @param {number} delta - Temps écoulé depuis la dernière frame. */ function updatePlayer(delta) { // Application de la gravité player.velocity.y -= GRAVITY; // Calcul du mouvement horizontal basé sur le joystick et la rotation du joueur const forward = new THREE.Vector3(0, 0, -1); // Vecteur "avant" initial forward.applyAxisAngle(new THREE.Vector3(0, 1, 0), player.rotation.y); // Applique la rotation horizontale du joueur const right = new THREE.Vector3(1, 0, 0); // Vecteur "droite" initial right.applyAxisAngle(new THREE.Vector3(0, 1, 0), player.rotation.y); // Applique la rotation horizontale du joueur const moveDirection = new THREE.Vector3(); moveDirection.add(forward.multiplyScalar(controls.joystick.y)); // Mouvement avant/arrière moveDirection.add(right.multiplyScalar(controls.joystick.x)); // Mouvement latéral (strafe) if (moveDirection.length() > 0) { moveDirection.normalize(); // Normalise le vecteur pour une vitesse constante // Applique la vitesse de déplacement, ajustée par le delta (pour la fluidité) player.velocity.x = moveDirection.x * MOVEMENT_SPEED * delta * 60; player.velocity.z = moveDirection.z * MOVEMENT_SPEED * delta * 60; } else { player.velocity.x = 0; // Arrête le mouvement horizontal si le joystick est relâché player.velocity.z = 0; } // Gestion du saut if (controls.isJumping && player.isGrounded) { player.velocity.y = JUMP_FORCE; // Applique la force de saut si au sol player.isGrounded = false; // Le joueur n'est plus au sol après le saut } // Pré-calcul de la position potentielle pour la détection de collision const currentPos = player.mesh.position.clone(); const nextX = currentPos.x + player.velocity.x; const nextY = currentPos.y + player.velocity.y; const nextZ = currentPos.z + player.velocity.z; // Bounding box du joueur pour les collisions (au centre du joueur) const playerHalfWidth = PLAYER_WIDTH / 2; const playerHalfHeight = PLAYER_HEIGHT / 2; // Détection et résolution des collisions par axe player.isGrounded = false; // Réinitialise l'état au sol // 1. Collision sur l'axe Y (verticale) let potentialPlayerBoxY = new THREE.Box3( new THREE.Vector3(currentPos.x - playerHalfWidth, nextY - playerHalfHeight, currentPos.z - playerHalfWidth), new THREE.Vector3(currentPos.x + playerHalfWidth, nextY + playerHalfHeight, currentPos.z + playerHalfWidth) ); let collidedY = false; chunks.forEach(chunk => { chunk.children.forEach(cube => { const cubeBox = new THREE.Box3().setFromObject(cube); if (potentialPlayerBoxY.intersectsBox(cubeBox)) { if (player.velocity.y < 0) { // Si le joueur descend (gravité) // Vérifie si le joueur atterrit sur le dessus du cube if ((currentPos.y - playerHalfHeight) >= cubeBox.max.y - 0.05) { // Un petit epsilon pour tolérer les imprécisions flottantes player.mesh.position.y = cubeBox.max.y + playerHalfHeight; player.velocity.y = 0; player.isGrounded = true; collidedY = true; } } else if (player.velocity.y > 0) { // Si le joueur monte (saut) // Vérifie si le joueur heurte le dessous du cube if ((currentPos.y + playerHalfHeight) <= cubeBox.min.y + 0.05) { player.mesh.position.y = cubeBox.min.y - playerHalfHeight; player.velocity.y = 0; collidedY = true; } } } }); }); if (!collidedY) { player.mesh.position.y = nextY; // Applique le mouvement Y si pas de collision } // 2. Collision sur l'axe X (horizontale) let potentialPlayerBoxX = new THREE.Box3( new THREE.Vector3(nextX - playerHalfWidth, player.mesh.position.y - playerHalfHeight, currentPos.z - playerHalfWidth), new THREE.Vector3(nextX + playerHalfWidth, player.mesh.position.y + playerHalfHeight, currentPos.z + playerHalfWidth) ); let collidedX = false; chunks.forEach(chunk => { chunk.children.forEach(cube => { const cubeBox = new THREE.Box3().setFromObject(cube); if (potentialPlayerBoxX.intersectsBox(cubeBox)) { collidedX = true; } }); }); if (!collidedX) { player.mesh.position.x = nextX; // Applique le mouvement X si pas de collision } else { player.velocity.x = 0; // Stoppe le mouvement X si collision } // 3. Collision sur l'axe Z (horizontale) let potentialPlayerBoxZ = new THREE.Box3( new THREE.Vector3(player.mesh.position.x - playerHalfWidth, player.mesh.position.y - playerHalfHeight, nextZ - playerHalfWidth), new THREE.Vector3(player.mesh.position.x + playerHalfWidth, player.mesh.position.y + playerHalfHeight, nextZ + playerHalfWidth) ); let collidedZ = false; chunks.forEach(chunk => { chunk.children.forEach(cube => { const cubeBox = new THREE.Box3().setFromObject(cube); if (potentialPlayerBoxZ.intersectsBox(cubeBox)) { collidedZ = true; } }); }); if (!collidedZ) { player.mesh.position.z = nextZ; // Applique le mouvement Z si pas de collision } else { player.velocity.z = 0; // Stoppe le mouvement Z si collision } // Si le joueur tombe sous la carte, le réinitialise if (player.mesh.position.y < -100) { player.mesh.position.set(0, 20, 0); // Téléporte le joueur en haut player.velocity.set(0, 0, 0); // Réinitialise sa vitesse } } /** * Met à jour la position et l'orientation de la caméra en fonction de la position du joueur * et du mode de vue (1ère ou 3ème personne). */ function updateCamera() { // Calcule la direction de regard de la caméra const lookAtVector = new THREE.Vector3(0, 0, -1); // Regarde initialement vers l'avant // Applique les rotations X et Y du joueur pour orienter le vecteur de regard lookAtVector.applyEuler(new THREE.Euler(player.rotation.x, player.rotation.y, 0, 'YXZ')); if (isFirstPerson) { // Pour la 1ère personne, la caméra est aux yeux du joueur // La hauteur des yeux est définie à 1 bloc au-dessus de la base du joueur camera.position.copy(player.mesh.position); camera.position.y += (PLAYER_HEIGHT / 2) + BLOCK_SIZE; // (centre du joueur) + (hauteur d'un bloc) } else { // Pour la 3ème personne, la caméra est derrière et légèrement au-dessus du joueur const thirdPersonOffset = new THREE.Vector3(0, 2, 5); // Décalage de base (Y: hauteur, Z: distance arrière) // Applique la rotation horizontale du joueur au décalage pour que la caméra suive thirdPersonOffset.applyAxisAngle(new THREE.Vector3(0, 1, 0), player.rotation.y); camera.position.copy(player.mesh.position).add(thirdPersonOffset); } // La caméra regarde vers le point situé devant le joueur, dans la direction du vecteur de regard camera.lookAt(player.mesh.position.clone().add(lookAtVector.multiplyScalar(10))); // Multiplier pour définir un point lointain } </script> </body> </html>
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.