Coder avec Qwik, un générateur de planète dans un système solaire.
- User
Coder avec Qwik, un générateur de planète dans un système solaire.
- Assistant
Créer un générateur de planètes dans un système solaire avec Qwik est un projet amusant et intéressant qui combine des concepts de développement web moderne, de génération procédurale et de visualisation. Voici un guide détaillé pour coder un tel projet. Nous allons utiliser Qwik pour sa performance et son rendu optimisé, et nous intégrerons une visualisation simple avec HTML5 Canvas pour simuler un système solaire.
Étapes du projet :
- Configurer un projet Qwik.
- Créer un modèle de données pour les planètes.
- Générer procéduralement des planètes.
- Afficher le système solaire avec Canvas.
- Ajouter des interactions utilisateur (par exemple, générer un nouveau système).
1. Configurer un projet Qwik
Si vous n'avez pas encore installé Qwik, commencez par créer un nouveau projet. Assurez-vous d'avoir Node.js installé, puis exécutez les commandes suivantes :
npm create qwik@latestSuivez les instructions pour configurer votre projet (choisissez un nom comme
solar-system-generator). Une fois le projet créé, entrez dans le répertoire et lancez le serveur de développement :cd solar-system-generator npm start
2. Créer un modèle de données pour les planètes
Nous allons définir une structure pour représenter une planète. Chaque planète aura des propriétés comme :
- Nom
- Taille (rayon)
- Distance au soleil
- Vitesse orbitale
- Couleur (pour la visualisation)
Créez un fichier
src/models/planet.tspour définir ce modèle :export interface Planet { name: string; radius: number; // Taille de la planète distance: number; // Distance au soleil orbitalSpeed: number; // Vitesse orbitale (en radians par frame) color: string; // Couleur de la planète angle: number; // Angle actuel dans l'orbite (en radians) }
3. Générer procéduralement des planètes
Nous allons créer une fonction pour générer un système solaire avec un nombre aléatoire de planètes, chacune ayant des propriétés générées procéduralement.
Créez un fichier
src/utils/planetGenerator.ts:import { Planet } from '../models/planet'; const PLANET_NAMES = [ 'Zorath', 'Kryon', 'Elara', 'Thalos', 'Nivara', 'Draconis', 'Aetheris', 'Lunara', ]; const COLORS = [ '#FF6347', // Rouge tomate '#4682B4', // Bleu acier '#FFD700', // Or '#32CD32', // Vert lime '#8A2BE2', // Violet ]; export function generateSolarSystem(numPlanets: number): Planet[] { const planets: Planet[] = []; let lastDistance = 50; // Distance initiale du soleil for (let i = 0; i < numPlanets; i++) { const name = PLANET_NAMES[Math.floor(Math.random() * PLANET_NAMES.length)]; const radius = Math.random() * 10 + 5; // Rayon entre 5 et 15 const distance = lastDistance + Math.random() * 50 + 20; // Distance croissante const orbitalSpeed = 0.01 / distance; // Vitesse orbitale inversement proportionnelle à la distance const color = COLORS[Math.floor(Math.random() * COLORS.length)]; planets.push({ name: `${name} ${i + 1}`, radius, distance, orbitalSpeed, color, angle: Math.random() * 2 * Math.PI, // Angle initial aléatoire }); lastDistance = distance; } return planets; }
4. Afficher le système solaire avec Canvas
Nous allons maintenant créer un composant Qwik pour afficher le système solaire. Nous utiliserons le Canvas HTML5 pour dessiner le soleil et les planètes en orbite.
Modifiez le fichier
src/routes/index.tsxpour inclure le composant principal :import { component$, useSignal, useVisibleTask$ } from '@builder.io/qwik'; import { generateSolarSystem } from '../utils/planetGenerator'; import type { Planet } from '../models/planet'; export default component$(() => { const planets = useSignal<Planet[]>([]); const canvasRef = useSignal<HTMLCanvasElement>(); // Générer un nouveau système solaire const generateNewSystem = () => { const numPlanets = Math.floor(Math.random() * 6) + 3; // Entre 3 et 8 planètes planets.value = generateSolarSystem(numPlanets); }; // Initialiser le système solaire au chargement useVisibleTask$(() => { generateNewSystem(); const canvas = canvasRef.value!; const ctx = canvas.getContext('2d')!; const centerX = canvas.width / 2; const centerY = canvas.height / 2; // Animation des planètes let animationFrameId: number; const animate = () => { // Effacer le canvas ctx.clearRect(0, 0, canvas.width, canvas.height); // Dessiner le soleil ctx.beginPath(); ctx.arc(centerX, centerY, 20, 0, 2 * Math.PI); ctx.fillStyle = '#FFD700'; // Couleur du soleil (or) ctx.fill(); ctx.closePath(); // Dessiner chaque planète planets.value.forEach((planet) => { // Mettre à jour l'angle pour simuler l'orbite planet.angle += planet.orbitalSpeed; // Calculer la position de la planète const x = centerX + planet.distance * Math.cos(planet.angle); const y = centerY + planet.distance * Math.sin(planet.angle); // Dessiner l'orbite ctx.beginPath(); ctx.arc(centerX, centerY, planet.distance, 0, 2 * Math.PI); ctx.strokeStyle = '#555'; ctx.stroke(); ctx.closePath(); // Dessiner la planète ctx.beginPath(); ctx.arc(x, y, planet.radius, 0, 2 * Math.PI); ctx.fillStyle = planet.color; ctx.fill(); ctx.closePath(); }); // Demander la prochaine frame d'animation animationFrameId = requestAnimationFrame(animate); }; animate(); // Nettoyer l'animation quand le composant est démonté return () => cancelAnimationFrame(animationFrameId); }); return ( <div> <h1>Générateur de Système Solaire</h1> <button onClick$={generateNewSystem}>Générer un nouveau système</button> <canvas ref={canvasRef} width={800} height={600} style={{ border: '1px solid black', marginTop: '20px' }} /> <div> <h2>Planètes générées :</h2> <ul> {planets.value.map((planet) => ( <li key={planet.name}> {planet.name} - Distance: {planet.distance.toFixed(2)} - Taille:{' '} {planet.radius.toFixed(2)} </li> ))} </ul> </div> </div> ); });Explications du code :
useSignal: Utilisé pour gérer l'état réactif des planètes et de la référence au canvas.useVisibleTask$: Permet d'exécuter du code côté client (par exemple, pour manipuler le canvas et lancer l'animation).- Canvas : Utilisé pour dessiner le soleil, les orbites et les planètes. Chaque planète est animée en mettant à jour son angle orbital.
- Bouton de génération : Permet de générer un nouveau système solaire avec des planètes aléatoires.
5. Ajouter des interactions utilisateur
Vous pouvez enrichir ce projet en ajoutant des fonctionnalités comme :
- Permettre à l'utilisateur de choisir le nombre de planètes.
- Ajouter des textures ou des anneaux aux planètes.
- Permettre de zoomer ou de déplacer la caméra dans le système solaire.
- Ajouter des informations supplémentaires sur chaque planète (par exemple, type : gazeuse, rocheuse, etc.).
Voici un exemple d'ajout pour permettre à l'utilisateur de choisir le nombre de planètes. Modifiez le composant principal pour inclure un champ de saisie :
import { component$, useSignal, useVisibleTask$ } from '@builder.io/qwik'; import { generateSolarSystem } from '../utils/planetGenerator'; import type { Planet } from '../models/planet'; export default component$(() => { const planets = useSignal<Planet[]>([]); const canvasRef = useSignal<HTMLCanvasElement>(); const numPlanetsInput = useSignal<number>(5); // Par défaut, 5 planètes // Générer un nouveau système solaire const generateNewSystem = () => { planets.value = generateSolarSystem(numPlanetsInput.value); }; // Initialiser le système solaire au chargement useVisibleTask$(() => { generateNewSystem(); const canvas = canvasRef.value!; const ctx = canvas.getContext('2d')!; const centerX = canvas.width / 2; const centerY = canvas.height / 2; let animationFrameId: number; const animate = () => { ctx.clearRect(0, 0, canvas.width, canvas.height); ctx.beginPath(); ctx.arc(centerX, centerY, 20, 0, 2 * Math.PI); ctx.fillStyle = '#FFD700'; ctx.fill(); ctx.closePath(); planets.value.forEach((planet) => { planet.angle += planet.orbitalSpeed; const x = centerX + planet.distance * Math.cos(planet.angle); const y = centerY + planet.distance * Math.sin(planet.angle); ctx.beginPath(); ctx.arc(centerX, centerY, planet.distance, 0, 2 * Math.PI); ctx.strokeStyle = '#555'; ctx.stroke(); ctx.closePath(); ctx.beginPath(); ctx.arc(x, y, planet.radius, 0, 2 * Math.PI); ctx.fillStyle = planet.color; ctx.fill(); ctx.closePath(); }); animationFrameId = requestAnimationFrame(animate); }; animate(); return () => cancelAnimationFrame(animationFrameId); }); return ( <div> <h1>Générateur de Système Solaire</h1> <div> <label> Nombre de planètes (3-10) : <input type="number" min="3" max="10" value={numPlanetsInput.value} onInput$={(e) => (numPlanetsInput.value = parseInt((e.target as HTMLInputElement).value)) } /> </label> <button onClick$={generateNewSystem}>Générer un nouveau système</button> </div> <canvas ref={canvasRef} width={800} height={600} style={{ border: '1px solid black', marginTop: '20px' }} /> <div> <h2>Planètes générées :</h2> <ul> {planets.value.map((planet) => ( <li key={planet.name}> {planet.name} - Distance: {planet.distance.toFixed(2)} - Taille:{' '} {planet.radius.toFixed(2)} </li> ))} </ul> </div> </div> ); });
6. Améliorations possibles
- Textures : Utilisez des images ou des dégradés pour rendre les planètes plus réalistes.
- Performance : Si vous avez beaucoup de planètes, envisagez d'utiliser WebGL (via Three.js, par exemple) pour de meilleures performances.
- Interactivité : Ajoutez la possibilité de cliquer sur une planète pour afficher des détails ou de zoomer sur une orbite spécifique.
- Effets visuels : Ajoutez des ombres, des anneaux, ou des lunes orbitant autour des planètes.
7. Lancer le projet
Une fois le code implémenté, lancez le projet avec :
npm startOuvrez votre navigateur à l'adresse
http://localhost:5173pour voir votre générateur de système solaire en action !
Ce projet est une excellente base pour explorer Qwik et les visualisations interactives. Vous pouvez le personnaliser davantage en fonction de vos besoins ou de votre créativité.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.