Skip to content
TheChatArchiveThe Chat Archive
grok-3-preview-02-24· xAIHugging Face LMArena Human Preference 140K

Coder avec Qwik, un générateur de planète dans un système solaire.

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Kimikimi-k2-0711-preview’s answer.
  1. User

    Coder avec Qwik, un générateur de planète dans un système solaire.

  2. 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 :

    1. Configurer un projet Qwik.
    2. Créer un modèle de données pour les planètes.
    3. Générer procéduralement des planètes.
    4. Afficher le système solaire avec Canvas.
    5. 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@latest
    

    Suivez 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.ts pour 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.tsx pour 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 start
    

    Ouvrez votre navigateur à l'adresse http://localhost:5173 pour 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é.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.