Skip to content
The Chat Archive
gemma-3-27b-it· Google LMArena Human Preference 140K

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

  1. User

    creami un simulatore di partite di calcio, 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

    Ok, ecco un simulatore di partite di calcio in Python con Pygame, che include le funzionalità richieste:

    import pygame
    import random
    
    # Inizializzazione Pygame
    pygame.init()
    
    # Dimensioni dello schermo
    larghezza = 800
    altezza = 600
    schermo = pygame.display.set_mode((larghezza, altezza))
    pygame.display.set_caption("Simulatore Partita di Calcio")
    
    # Colori
    bianco = (255, 255, 255)
    nero = (0, 0, 0)
    verde = (0, 255, 0)
    rosso = (255, 0, 0)
    blu = (0, 0, 255)
    
    # Colori personalizzabili
    colore_maglia_squadra1 = blu
    colore_maglia_squadra2 = rosso
    colore_palla = bianco
    
    # Nomi delle squadre personalizzabili
    nome_squadra1 = "Squadra A"
    nome_squadra2 = "Squadra B"
    
    # Classe Giocatore
    class Giocatore(pygame.sprite.Sprite):
        def __init__(self, squadra, x, y):
            super().__init__()
            self.squadra = squadra
            self.image = pygame.Surface([20, 40])
            self.image.fill(colore_maglia_squadra1 if squadra == 1 else colore_maglia_squadra2)
            self.rect = self.image.get_rect()
            self.rect.x = x
            self.rect.y = y
            self.velocita = 2
    
        def update(self):
            # Movimento casuale
            direzione = random.randint(0, 3)
            if direzione == 0:  # Su
                self.rect.y -= self.velocita
            elif direzione == 1:  # Giù
                self.rect.y += self.velocita
            elif direzione == 2:  # Sinistra
                self.rect.x -= self.velocita
            elif direzione == 3:  # Destra
                self.rect.x += self.velocita
    
            # Mantenere il giocatore all'interno del campo
            self.rect.x = max(0, min(self.rect.x, larghezza - self.rect.width))
            self.rect.y = max(0, min(self.rect.y, altezza - self.rect.height))
    
    # Classe Palla
    class Palla(pygame.sprite.Sprite):
        def __init__(self):
            super().__init__()
            self.image = pygame.Surface([20, 20])
            self.image.fill(colore_palla)
            self.rect = self.image.get_rect()
            self.rect.x = larghezza // 2 - self.rect.width // 2
            self.rect.y = altezza // 2 - self.rect.height // 2
            self.velocita_x = 3
            self.velocita_y = 3
    
        def update(self):
            self.rect.x += self.velocita_x
            self.rect.y += self.velocita_y
    
            # Rimbalzo sui bordi
            if self.rect.left <= 0 or self.rect.right >= larghezza:
                self.velocita_x *= -1
            if self.rect.top <= 0 or self.rect.bottom >= altezza:
                self.velocita_y *= -1
    
    # Creazione dei giocatori
    giocatori = pygame.sprite.Group()
    for i in range(5):
        giocatori.add(Giocatore(1, random.randint(0, larghezza - 20), random.randint(0, altezza // 2 - 20)))
        giocatori.add(Giocatore(2, random.randint(0, larghezza - 20), random.randint(altezza // 2, altezza - 20)))
    
    # Creazione della palla
    palla = Palla()
    palla_group = pygame.sprite.Group()
    palla_group.add(palla)
    
    # Punteggio
    punteggio_squadra1 = 0
    punteggio_squadra2 = 0
    
    # Funzione per visualizzare il punteggio
    def visualizza_punteggio(superficie, punteggio1, punteggio2, nome1, nome2):
        font = pygame.font.Font(None, 36)
        testo1 = font.render(f"{nome1}: {punteggio1}", True, bianco)
        testo2 = font.render(f"{nome2}: {punteggio2}", True, bianco)
        superficie.blit(testo1, (10, 10))
        superficie.blit(testo2, (larghezza - testo2.get_width() - 10, 10))
    
    # Funzione per visualizzare "GOAL!" con effetti speciali
    def goal_effetti(superficie):
        font = pygame.font.Font(None, 72)
        testo = font.render("GOAL!", True, bianco)
        testo_rect = testo.get_rect(center=(larghezza // 2, altezza // 2))
    
        # Sparkles
        for _ in range(50):
            x = random.randint(0, larghezza)
            y = random.randint(0, altezza)
            colore = random.choice([bianco, rosso, blu])
            pygame.draw.circle(superficie, colore, (x, y), random.randint(2, 5))
    
        # Fuochi d'artificio (semplificati)
        for _ in range(10):
            x = random.randint(0, larghezza)
            y = altezza
            colore = random.choice([rosso, blu, bianco])
            pygame.draw.line(superficie, colore, (x, y), (x, y - random.randint(20, 50)), random.randint(1, 3))
    
        superficie.blit(testo, testo_rect)
        pygame.display.flip()
        pygame.time.delay(1000)  # Mostra gli effetti per 1 secondo
    
    # Loop principale del gioco
    esecuzione = True
    clock = pygame.time.Clock()
    
    while esecuzione:
        for evento in pygame.event.get():
            if evento.type == pygame.QUIT:
                esecuzione = False
    
        # Aggiornamento degli oggetti
        giocatori.update()
        palla.update()
    
        # Controllo collisioni palla-giocatore (semplificato)
        for giocatore in giocatori:
            if palla.rect.colliderect(giocatore.rect):
                palla.velocita_x *= -1
                palla.velocita_y *= -1
    
        # Controllo goal (semplificato)
        if palla.rect.left <= 0:
            punteggio_squadra2 += 1
            palla = Palla()  # Resetta la palla al centro
            palla_group.empty()
            palla_group.add(palla)
            goal_effetti(schermo)
        elif palla.rect.right >= larghezza:
            punteggio_squadra1 += 1
            palla = Palla()  # Resetta la palla al centro
            palla_group.empty()
            palla_group.add(palla)
            goal_effetti(schermo)
    
        # Disegno
        schermo.fill(verde)  # Campo verde
        giocatori.draw(schermo)
        palla_group.draw(schermo)
        visualizza_punteggio(schermo, punteggio_squadra1, punteggio_squadra2, nome_squadra1, nome_squadra2)
    
        # Aggiornamento dello schermo
        pygame.display.flip()
    
        # Limitazione del frame rate
        clock.tick(60)
    
    # Chiusura Pygame
    pygame.quit()
    

    Come usare il codice:

    1. Installa Pygame: Se non hai Pygame, installalo con pip install pygame.
    2. Salva il codice: Salva il codice come un file Python (es., calcio.py).
    3. Esegui il codice: Esegui il file da terminale con python calcio.py.

    Funzionalità implementate:

    • Campo e giocatori: Un campo verde con giocatori che si muovono casualmente.
    • Palla: Una palla che rimbalza sui bordi del campo.
    • Collisioni: La palla cambia direzione quando colpisce un giocatore.
    • Goal: Quando la palla esce dal campo a sinistra o a destra, viene segnato un goal.
    • Effetti speciali goal: Appare la scritta "GOAL!" con sparkles e fuochi d'artificio.
    • Punteggio: Visualizzazione del punteggio delle due squadre.
    • Personalizzazione:
      • Colori: Puoi modificare colore_maglia_squadra1, colore_maglia_squadra2 e colore_palla per cambiare i colori delle maglie e della palla.
      • Nomi delle squadre: Puoi modificare nome_squadra1 e nome_squadra2 per cambiare i nomi delle squadre.

    Miglioramenti possibili:

    • Controllo dei giocatori: Aggiungere la possibilità di controllare i giocatori con i tasti freccia o WASD.
    • Intelligenza artificiale: Implementare un'IA semplice per far muovere i giocatori in modo più strategico.
    • Fisica più realistica: Migliorare la fisica della palla e dei giocatori per un comportamento più realistico.
    • Grafica: Utilizzare immagini più dettagliate per il campo, i giocatori e la palla.
    • Suono: Aggiungere effetti sonori per i goal, i tiri e le collisioni.
    • Menu: Creare un menu per personalizzare le impostazioni del gioco (colori, nomi delle squadre, difficoltà, ecc.).
    • Regole del gioco: Implementare regole più complete del calcio (falli, fuorigioco, ecc.).
    • Multiplayer: Aggiungere la possibilità di giocare in multiplayer.

    Spero che questo simulatore di calcio ti sia utile! Fammi sapere se hai altre domande o richieste.

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