Skip to content
TheChatArchiveThe Chat Archive
grok-3-mini-high· xAIHugging Face LMArena Human Preference 140K

creami un simulatore di partite di calcio, in html, con il campo ed i giocatori che…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    creami un simulatore di partite di calcio, in html, con il campo ed i giocatori che inseguono un pallone, io posso modificare la maglia dei giocatori ed il colore della palla, quando fanno goal, appare la scritta goal con delle sparkles e dei fuochi d'artificio. Io posso cambiare anche i nomi delle squadre, ma non i risultati

  2. Assistant

    Ecco un simulatore di partite di calcio completo, realizzato in HTML, CSS e JavaScript. Il simulatore include:

    • Un campo da calcio rappresentato su un canvas.
    • Giocatori che inseguono la palla con un movimento semplice (i giocatori si muovono verso la palla e la palla si sposta casualmente).
    • Possibilità di modificare:
      • Il colore della maglia per entrambe le squadre (usando input di tipo "color").
      • Il colore della palla (usando input di tipo "color").
      • I nomi delle squadre (usando input di testo).
    • Quando viene segnato un goal, appare la scritta "GOAL!" con effetti di sparkles (particelle brillanti) e fuochi d'artificio (particelle colorate che esplodono).
    • Il punteggio viene gestito automaticamente e aggiornato in tempo reale, ma non può essere modificato dall'utente.
    • Un pulsante per avviare/arrestare la simulazione.

    Il codice è self-contained e può essere copiato e incollato in un file HTML per funzionare. Ho usato requestAnimationFrame per un'animazione fluida. La logica di movimento è semplificata: i giocatori inseguono la palla, e la palla si muove casualmente con collisioni basiche. I goal vengono segnati quando la palla esce dai confini laterali del campo entro un range di y (simulando le aree di porta).

    Ecco il codice completo:

    <!DOCTYPE html>
    <html lang="it">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Simulatore di Partite di Calcio</title>
        <style>
            body {
                font-family: Arial, sans-serif;
                text-align: center;
                background-color: #f0f0f0;
            }
            #controls {
                margin: 20px;
            }
            label {
                margin: 10px;
            }
            #field {
                background-color: #228B22; /* Verde campo da calcio */
                border: 2px solid black;
                display: block;
                margin: 20px auto;
            }
            #scoreDisplay {
                font-size: 24px;
                margin: 10px;
            }
        </style>
    </head>
    <body>
        <h1>Simulatore di Partite di Calcio</h1>
        <div id="controls">
            <label>Nome Squadra A: <input type="text" id="teamAName" value="Squadra A"></label>
            <label>Nome Squadra B: <input type="text" id="teamBName" value="Squadra B"></label>
            <br>
            <label>Colore Maglia Squadra A: <input type="color" id="teamAColor" value="#FF0000"></label>
            <label>Colore Maglia Squadra B: <input type="color" id="teamBColor" value="#0000FF"></label>
            <br>
            <label>Colore Palla: <input type="color" id="ballColor" value="#FFFFFF"></label>
            <br>
            <button id="simulateBtn">Avvia Simulazione</button>
        </div>
        <div id="scoreDisplay">Punteggio: <span id="score">0 - 0</span></div>
        <canvas id="field" width="800" height="400"></canvas>
    
        <script>
            const canvas = document.getElementById('field');
            const ctx = canvas.getContext('2d');
            const teamANameInput = document.getElementById('teamAName');
            const teamBNameInput = document.getElementById('teamBName');
            const teamAColorInput = document.getElementById('teamAColor');
            const teamBColorInput = document.getElementById('teamBColor');
            const ballColorInput = document.getElementById('ballColor');
            const simulateBtn = document.getElementById('simulateBtn');
            const scoreSpan = document.getElementById('score');
    
            let simulating = false;
            let animationId;
            let scoreA = 0;
            let scoreB = 0;
            let ball = { x: 400, y: 200, radius: 10, color: '#FFFFFF', vx: (Math.random() - 0.5) * 4, vy: (Math.random() - 0.5) * 4 };
            let players = [];
            // Crea 5 giocatori per squadra
            for (let i = 0; i < 5; i++) {
                players.push({ x: 200, y: 80 + i * 60, radius: 15, color: '#FF0000', team: 'A' }); // Squadra A
                players.push({ x: 600, y: 80 + i * 60, radius: 15, color: '#0000FF', team: 'B' }); // Squadra B
            }
            let goalAnimation = false;
            let goalTimer = 0;
            let particles = [];
    
            // Funzione per disegnare tutto
            function draw() {
                ctx.clearRect(0, 0, canvas.width, canvas.height);
    
                // Disegna linee del campo (es. linea di centrocampo)
                ctx.strokeStyle = 'white';
                ctx.beginPath();
                ctx.moveTo(canvas.width / 2, 0);
                ctx.lineTo(canvas.width / 2, canvas.height);
                ctx.stroke();
    
                // Aggiorna colori dai input
                players.forEach(player => {
                    if (player.team === 'A') {
                        player.color = teamAColorInput.value;
                    } else {
                        player.color = teamBColorInput.value;
                    }
                });
                ball.color = ballColorInput.value;
    
                // Disegna giocatori
                players.forEach(player => {
                    ctx.fillStyle = player.color;
                    ctx.beginPath();
                    ctx.arc(player.x, player.y, player.radius, 0, Math.PI * 2);
                    ctx.fill();
                });
    
                // Disegna palla
                ctx.fillStyle = ball.color;
                ctx.beginPath();
                ctx.arc(ball.x, ball.y, ball.radius, 0, Math.PI * 2);
                ctx.fill();
    
                // Se animazione goal è attiva, disegna "GOAL!" e particelle
                if (goalAnimation) {
                    ctx.fillStyle = 'yellow';
                    ctx.font = '48px Arial';
                    ctx.fillText('GOAL!', canvas.width / 2 - 50, canvas.height / 2);
    
                    // Disegna particelle (sparkles e fuochi d'artificio)
                    particles.forEach(particle => {
                        ctx.fillStyle = particle.color;
                        ctx.fillRect(particle.x, particle.y, 3, 3); // Particelle piccole per effetto sparkle
                    });
    
                    // Aggiorna e filtra particelle
                    particles = particles.filter(p => p.life > 0);
                    particles.forEach(particle => {
                        particle.x += particle.vx;
                        particle.y += particle.vy;
                        particle.life -= 1;
                    });
    
                    goalTimer--;
                    if (goalTimer <= 0) {
                        goalAnimation = false;
                        particles = [];
                    }
                }
    
                // Aggiorna display punteggio e nomi squadre
                scoreSpan.textContent = `${teamANameInput.value} ${scoreA} - ${scoreB} ${teamBNameInput.value}`;
            }
    
            // Funzione per aggiornare posizioni e logica
            function update() {
                // Muovi giocatori verso la palla con un po' di random per realismo
                players.forEach(player => {
                    let dx = ball.x - player.x;
                    let dy = ball.y - player.y;
                    let dist = Math.sqrt(dx * dx + dy * dy);
                    if (dist > 5) {
                        player.x += (dx / dist) * 2 + (Math.random() - 0.5); // Velocità 2 con random
                        player.y += (dy / dist) * 2 + (Math.random() - 0.5);
                    }
    
                    // Limita giocatori entro i confini del campo
                    if (player.x < 0) player.x = 0;
                    if (player.x > canvas.width) player.x = canvas.width;
                    if (player.y < 0) player.y = 0;
                    if (player.y > canvas.height) player.y = canvas.height;
                });
    
                // Muovi palla con velocità attuale
                ball.x += ball.vx;
                ball.y += ball.vy;
    
                // Controllo collisioni con pareti e goal
                if (ball.x < 0) {
                    if (ball.y > canvas.height / 4 && ball.y < 3 * canvas.height / 4) {
                        // Goal per Squadra B
                        scoreB++;
                        goalEvent('B');
                    } else {
                        // Rimbalzo su lato sinistro
                        ball.vx *= -1;
                    }
                } else if (ball.x > canvas.width) {
                    if (ball.y > canvas.height / 4 && ball.y < 3 * canvas.height / 4) {
                        // Goal per Squadra A
                        scoreA++;
                        goalEvent('A');
                    } else {
                        // Rimbalzo su lato destro
                        ball.vx *= -1;
                    }
                }
                if (ball.y < 0 || ball.y > canvas.height) {
                    // Rimbalzo su alto e basso
                    ball.vy *= -1;
                }
    
                // Interazione palla-giocatori: se un giocatore tocca la palla, cambia direzione
                players.forEach(player => {
                    let dx = ball.x - player.x;
                    let dy = ball.y - player.y;
                    let dist = Math.sqrt(dx * dx + dy * dy);
                    if (dist < player.radius + ball.radius) {
                        ball.vx += (Math.random() - 0.5) * 2; // Cambia velocità random
                        ball.vy += (Math.random() - 0.5) * 2;
                    }
                });
    
                // Mantieni una velocità minima per la palla
                if (Math.abs(ball.vx) < 1) ball.vx += (Math.random() - 0.5) * 2;
                if (Math.abs(ball.vy) < 1) ball.vy += (Math.random() - 0.5) * 2;
            }
    
            // Funzione per evento goal
            function goalEvent(team) {
                goalAnimation = true;
                goalTimer = 60; // Durata animazione (1 secondo a 60fps)
                // Crea particelle per sparkles e fuochi d'artificio
                for (let i = 0; i < 100; i++) {
                    particles.push({
                        x: canvas.width / 2,
                        y: canvas.height / 2,
                        vx: (Math.random() - 0.5) * 5, // Velocità random per effetto esplosivo
                        vy: (Math.random() - 0.5) * 5,
                        life: 30 + Math.random() * 30, // Durata vita particella
                        color: `hsl(${Math.random() * 360}, 100%, 50%)` // Colore random per fuochi d'artificio
                    });
                }
                // Resetta palla al centro
                ball.x = canvas.width / 2;
                ball.y = canvas.height / 2;
                ball.vx = (Math.random() - 0.5) * 4;
                ball.vy = (Math.random() - 0.5) * 4;
            }
    
            // Loop di animazione
            function animate() {
                if (simulating) {
                    update();
                    draw();
                    animationId = requestAnimationFrame(animate);
                }
            }
    
            // Evento per il pulsante di simulazione
            simulateBtn.addEventListener('click', () => {
                simulating = !simulating;
                simulateBtn.textContent = simulating ? 'Arresta Simulazione' : 'Avvia Simulazione';
                if (simulating) {
                    animate(); // Avvia animazione
                } else {
                    cancelAnimationFrame(animationId); // Ferma animazione
                }
            });
    
            // Disegna iniziale (stato statico)
            draw();
        </script>
    </body>
    </html>
    

    Istruzioni per l'uso:

    1. Apri il file in un browser: Copia e incolla il codice in un file con estensione .html (es. simulatore_calcio.html) e aprilo con un browser web moderno (come Chrome o Firefox).
    2. Modifica le impostazioni:
      • Nomi squadre: Cambia i nomi nelle caselle di testo "Nome Squadra A" e "Nome Squadra B". I cambiamenti si applicano in tempo reale.
      • Colori maglie: Usa i selettori di colore per cambiare il colore della maglia della Squadra A e della Squadra B. I cambiamenti si applicano immediatamente.
      • Colore palla: Cambia il colore della palla usando il selettore dedicato.
    3. Avvia la simulazione: Clicca sul pulsante "Avvia Simulazione" per far muovere i giocatori e la palla. Clicca di nuovo su "Arresta Simulazione" per fermare tutto.
    4. Goal e animazioni: Quando la palla esce dai confini laterali entro l'area di porta (definita automaticamente), viene segnato un goal. Appare la scritta "GOAL!" con sparkles (particelle piccole) e fuochi d'artificio (esplosioni colorate). Il punteggio si aggiorna automaticamente.
    5. Limitazioni: Il movimento è semplificato e non basato su fisica reale. I giocatori inseguono la palla in modo basico, e la palla si muove casualmente con rimbalzi.

    Se hai bisogno di modifiche o miglioramenti (es. aggiungere più giocatori, migliorare la fisica o aggiungere altre feature), fammi sapere!

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