Lo so che mi sono imbarcato in una cosa più grande di me.
Io ho conoscenze praticamente nulle di programmazione, il massimo che conosco è VBA per excel.

Le mani me le sporcherei anche volentieri, ma con le mie conoscenze facile che strapperei i fiori e terrei le erbacce.

A differenza del VBA, per esempio, non riesco a fare scorrere una operazione alla volta, per capire dov'è l'inghippo.

Riesco solo a leggere, per esempio, che le collisioni tra bordo e ostacoli vengono gestite diversamente, ma cosa comportino le differenze per me è arabo.

Quindi contavo su un'anima pia che si divertisse a darci un occhio.

Se non è possibile mi tengo questa versione con i suoi bug e imparo a gestirli.

Ciao a tutti, sono nuovo del gruppo e sono una totale capra in programmazione in python. Tutto quello che troverete è stato fatto da chatGPT.
Voglio preparare un gioco che è destinato a due giocatori, un vedente (guida) e un cieco (sciatore; se non è cieco per davvero lo si benda o lo si fa sedere dietro allo schermo con solo la tastiera a disposizione).

La guida deve dare indicazioni destra e sinistra, in modo da schivare gli alberi e il bambino. Vengono rappresentate anche delle cunette di neve, decorative, non hanno influsso nel gioco.

La figura dello sciatore varia in funzione della direzione e della velocità del movimento: infatti, come si fa realmente in pista, si modula la voce se la curva deve essere dolce (un solo tocco del tasto) o secca (tasto tenuto premuto).

Le foto cambiano da uno sciatore in derapata o in carving. Sono presenti sul mio PC nella stessa cartella, per il momento solo bozze, ma se servono ditemi come allegarle.

Il codice contiene tutto ciò che mi serve. Però ha dei bug che chatGPT non riesce più a risolvere (nonostante ripetute richieste).

Quando c'è una collisione con il bordo o con uno dei due ostacoli dovrebbe apparire una schermata con tre scelte: rigiocare, tornare al menu iniziale, uscire (nella versione quasi funzionante che metto sono due, quella con tre scelte va in crash, al limite la metto in un secondo tempo).

Alla fine di ogni partita deve salvare in un file csv il nome dei due giocatori, data e ora, punteggio.

I bug sono i seguenti:

- il comportamento delle collisioni bordo / ostacoli sono diversi, dopo avere giustamente mostrato entrambi la stessa schermata.

- le cunette non appaiono al primo giro, eventualmente al secondo, se la collisione era con il bordo.

- la collisione con lo sciatore avviene troppo presto se questo si trova a sinistra dell'ostacolo e troppo tardi se si trova a destra (questa cosa penso di saperla risolvere giocando con le impostazioni).




Qualcuno di voi riesce a venirne a capo?




Ecco il codice:

import pygame
import random
import sys
import csv
from datetime import datetime

# Inizializza Pygame
pygame.init()

# Dimensioni finestra di gioco
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Simulatore di sci con i ciechi")

# Colori
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
GREEN = (0, 128, 0)
BLUE = (0, 0, 255)
LIGHT_BLUE = (173, 216, 230)
RED = (255, 0, 0)
YELLOW = (255, 255, 0)

# Clock
clock = pygame.time.Clock()

# Font
font = pygame.font.Font(None, 36)

# Caricamento immagini
player_images = {
    "right": pygame.image.load("DerapDes.gif"),
    "left": pygame.image.load("DerapSin.gif"),
    "fast_right": pygame.image.load("CarvDes.gif"),
    "fast_left": pygame.image.load("CarvSin.gif"),
}
bambino_images = {
    "right": pygame.image.load("SpazzDes.gif"),
    "left": pygame.image.load("SpazzSin.gif"),
}

# Caratteristiche del personaggio
player_width = 50  # Dimensioni del giocatore
player_height = 50
player_x = WIDTH // 2
player_y = HEIGHT - 150
player_speed = 3
player_direction = "right"  # "left", "fast_right", o "fast_left"

# Caratteristiche degli ostacoli
obstacles = []
cunette = []
bambino = None
TApp = 3000  # Millisecondi
DeltaTApp = 100  # Riduzione del tempo TApp
last_obstacle_time = pygame.time.get_ticks()

# Punteggio
score = 0


def input_names():
    """Permette di inserire i nomi di sciatore e guida."""
    sciatore = ""
    guida = ""
    active = "sciatore"
    while True:
        screen.fill(WHITE)
        draw_text("Inserisci il nome dello sciatore:", 50, 100, BLACK)
        draw_text(f"Sciatore: {sciatore}", 50, 150, BLUE)
        draw_text("Inserisci il nome della guida:", 50, 250, BLACK)
        draw_text(f"Guida: {guida}", 50, 300, BLUE)
        draw_text("Muovi lo sciatore con le frecce destra e sinistra.", 50, 400, BLACK)
        draw_text("Tenendo premuto il tasto esso si muoverà più veloce.", 50, 430, BLACK)
        draw_text("Evita gli ostacoli e i bordi.", 50, 460, BLACK)
        draw_text("Premi INVIO per iniziare.", 50, 500, RED)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_RETURN and sciatore and guida:
                    countdown()
                    return sciatore, guida
                if event.key == pygame.K_BACKSPACE:
                    if active == "sciatore" and sciatore:
                        sciatore = sciatore[:-1]
                    elif active == "guida" and guida:
                        guida = guida[:-1]
                elif event.key == pygame.K_TAB:
                    active = "guida" if active == "sciatore" else "sciatore"
                else:
                    if active == "sciatore":
                        sciatore += event.unicode
                    elif active == "guida":
                        guida += event.unicode

        pygame.display.flip()


def countdown():
    """Mostra un conto alla rovescia prima dell'inizio del gioco."""
    for i in range(1, 0, -1):
        screen.fill(WHITE)
        draw_text(str(i), WIDTH // 2, HEIGHT // 2, RED, 100)
        pygame.display.flip()
        pygame.time.delay(1000)


def draw_text(text, x, y, color=BLACK, size=36):
    """Disegna un testo sullo schermo."""
    font = pygame.font.Font(None, size)
    text_surface = font.render(text, True, color)
    screen.blit(text_surface, (x, y))


def draw_cunetta(x, y):
    """Disegna una cunetta come una mezzaluna."""
    pygame.draw.arc(screen, LIGHT_BLUE, (x, y, 30, 15), 0, 3.14, 2)


def draw_tree(x, y):
    """Disegna un abete sullo schermo."""
    pygame.draw.rect(screen, GREEN, (x + 15, y + 70, 10, 15))  # Tronco
    pygame.draw.polygon(screen, GREEN, [(x, y + 70), (x + 40, y + 70), (x + 20, y + 35)])  # Base
    pygame.draw.polygon(screen, GREEN, [(x + 5, y + 55), (x + 35, y + 55), (x + 20, y + 25)])  # Centro
    pygame.draw.polygon(screen, GREEN, [(x + 10, y + 40), (x + 30, y + 40), (x + 20, y + 10)])  # Punta


def save_score(sciatore, guida, score):
    """Salva il punteggio in un file CSV."""
    with open("punteggio.csv", "a", newline="") as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow([sciatore, guida, datetime.now().strftime("%Y-%m-%d %H:%M:%S"), score])


def reset_game():
    """Resetta le variabili del gioco."""
    global player_x, player_direction, obstacles, cunette, score, TApp, last_obstacle_time, bambino
    player_x = WIDTH // 2
    player_direction = "right"
    obstacles = []
    cunette = [(random.randint(0, WIDTH - 30), random.randint(0, HEIGHT - 30)) for _ in range(10)]
    bambino = None
    score = 0
    TApp = 3000
    last_obstacle_time = pygame.time.get_ticks()


def end_game_screen():
    """Mostra la schermata di fine partita."""
    while True:
        screen.fill(WHITE)
        draw_text("Partita Terminata!", WIDTH // 2 - 150, HEIGHT // 2 - 100, RED, 48)
        draw_text(f"Punteggio: {score}", WIDTH // 2 - 80, HEIGHT // 2 - 40, BLACK, 36)
        draw_text("Premi R per ricominciare o ESC per uscire.", WIDTH // 2 - 250, HEIGHT // 2 + 40, BLUE, 28)

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_r:
                    countdown()
                    reset_game()
                    return "restart"
                elif event.key == pygame.K_ESCAPE:
                    reset_game()
                    input_names()
                    
                    
        pygame.display.flip()


def move_bambino(bambino):
    """Gestisce il movimento del bambino."""
    x, y, direction = bambino
    y += 2
    if random.random() < 0.02:  # Cambia direzione casualmente
        direction = "right" if direction == "left" else "left"
    if direction == "right":
        x = min(WIDTH - 30, x + 1)
    else:
        x = max(0, x - 1)
    return (x, y, direction)


def move_cunette():
    """Aggiorna la posizione delle cunette."""
    global cunette
    cunette = [(x, y + 5 if y < HEIGHT else -15) for x, y in cunette]


# Input iniziale
sciatore_nome, guida_nome = input_names()

# Ciclo principale del gioco
running = True
while running:
    screen.fill(WHITE)

    # Eventi
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            save_score(sciatore_nome, guida_nome, score)
            pygame.quit()
            sys.exit()

    # Movimento personaggio
    keys = pygame.key.get_pressed()
    if player_direction == "right":
        player_x += 3 if not keys[pygame.K_RIGHT] else 9
    else:
        player_x -= 3 if not keys[pygame.K_LEFT] else 9

    if keys[pygame.K_LEFT] and player_direction == "right":
        player_direction = "left"
    elif keys[pygame.K_RIGHT] and player_direction == "left":
        player_direction = "right"


    # Controllo collisione con i bordi
    if player_x < 0 or player_x + player_width > WIDTH:
        save_score(sciatore_nome, guida_nome, score)
        if end_game_screen() == "restart":
            sciatore_nome, guida_nome = input_names()
        continue

    # Generazione nuovi ostacoli
    current_time = pygame.time.get_ticks()
    if current_time - last_obstacle_time > TApp:
        obstacles.append((random.randint(0, WIDTH - 30), -60))
        last_obstacle_time = current_time
        TApp = max(500, TApp - DeltaTApp)  # Diminuisce TApp fino a un minimo di 500ms

    # Generazione del bambino
    if bambino is None and random.random() < 0.01:
        bambino = (random.randint(0, WIDTH - 30), -60, "right")

    # Movimento delle cunette
    move_cunette()
    for x, y in cunette:
        draw_cunetta(x, y)


    # Movimento ostacoli
    new_obstacles = []
    for x, y in obstacles:
        y += 5
        if y < HEIGHT:
            new_obstacles.append((x, y))
            draw_tree(x, y)
            # Controllo collisione con il personaggio
            if pygame.Rect(player_x, player_y, player_width, player_height).colliderect((x, y + 10, 30, 60)):
                save_score(sciatore_nome, guida_nome, score)
                end_game_screen()
        else:
            score += 1
    obstacles = new_obstacles

    # Movimento del bambino
    if bambino:
        bambino = move_bambino(bambino)
        sx, sy, sdir = bambino
        screen.blit(bambino_imagessdir, (sx, sy))
        if pygame.Rect(player_x, player_y, player_width, player_height).colliderect((sx, sy, 50, 50)):
            save_score(sciatore_nome, guida_nome, score)
            end_game_screen()
        if sy > HEIGHT:
            bambino = None

    # Disegna il personaggio
    player_image_key = "fast_right" if keys[pygame.K_RIGHT] else "fast_left" if keys[pygame.K_LEFT] else player_direction
    screen.blit(player_imagesplayer image key, (player_x, player_y))

    # Mostra il punteggio
    draw_text(f"Punteggio: {score}", 10, 10)

    # Aggiorna schermo
    pygame.display.flip()
    clock.tick(30)