refactor stranger game

Author: 19Alma98

game04_1/images/sfondo-sottosopra.png

@@ -2,178 +2,263 @@
 import random
 import math
 
-TITLE = "Stranger Python"
-FONT_COLOR = (255, 255, 255)
-WIDTH = 800
-HEIGHT = 600
-CENTRO_X = WIDTH / 2
-CENTRO_Y = HEIGHT / 2
+# COSTANTI DI GIOCO
+
+TITOLO_GIOCO = "Stranger Python"
+COLORE_TESTO = (255, 255, 255)
+
+LARGHEZZA = 800
+ALTEZZA = 600
+
+LIVELLO_MASSIMO = 8
+
+# Coordinate che useremo per stampare a video il testo
+CENTRO_X = LARGHEZZA / 2
+CENTRO_Y = ALTEZZA / 2
 CENTRO = (CENTRO_X, CENTRO_Y)
 
-LIVELLO_FINALE = 8
+# Personaggi disponibili
+LISTA_PERSONAGGI = ["dustin", "lucas", "mike", "undici", "will"]
 
-PERSONAGGI = ["dustin", "lucas", "mike", "undici", "will"]
+# Timer casuale per attivare il Sottosopra
+TEMPO_MIN_SOTTOSOPRA = 3
+TEMPO_MAX_SOTTOSOPRA = 10
 
-game_over = False
-game_completato = False
+# VARIABILI DI STATO
+
+gioco_terminato = False
+gioco_completato = False
 livello_corrente = 1
-selezione_iniziale = True
+fase_scelta_personaggio = True
+
+personaggio_obiettivo = None
+personaggi_da_selezionare = []
+lista_personaggi_in_gioco = []  # gli attori che cadono a schermo
 
-personaggio_target = None
-personaggi_scelta = []
-stelle = []
+modalita_sottosopra = False
+timer_sottosopra = random.randint(TEMPO_MIN_SOTTOSOPRA, TEMPO_MAX_SOTTOSOPRA)
 
 
 def draw():
     screen.clear()
-    screen.blit("sfondo", (-150, -50))
 
-    if game_over:
+    # Sfondi diversi in base al mondo
+    if modalita_sottosopra:
+        screen.blit("sfondo-sottosopra", (-200, -50))
+    else:
+        screen.blit("sfondo", (-150, -50))
+
+    # GAME OVER
+    if gioco_terminato:
         mostra_messaggio("GAME OVER", "Prova di nuovo...")
         return
 
-    if game_completato:
+    # VITTORIA
+    if gioco_completato:
         mostra_messaggio("HAI VINTO!", "Complimenti!")
         return
 
-    if selezione_iniziale:
+    # SCHERMATA DI SCELTA PERSONAGGIO
+    if fase_scelta_personaggio:
         screen.draw.text(
             "Scegli il tuo personaggio",
             center=(CENTRO_X, 100),
             fontsize=40,
             color="white",
         )
-        for p in personaggi_scelta:
-            p.draw()
+        for personaggio in personaggi_da_selezionare:
+            personaggio.draw()
         return
 
-    for s in stelle:
-        s.draw()
+    # Disegna tutti i personaggi
+    for attore in lista_personaggi_in_gioco:
+        attore.draw()
+
+
+# LOGICA DI AGGIORNAMENTO
 
 
 def update():
-    global stelle, selezione_iniziale, game_over
+    global lista_personaggi_in_gioco, timer_sottosopra, modalita_sottosopra
 
-    if selezione_iniziale:
+    # Se siamo in una schermata di pausa
+    if fase_scelta_personaggio or gioco_terminato or gioco_completato:
         return
 
-    if len(stelle) == 0:
-        stelle = genera_stelle(livello_corrente)
+    # Se non ci sono attori sullo schermo → genera quelli del livello
+    if len(lista_personaggi_in_gioco) == 0:
+        lista_personaggi_in_gioco = genera_personaggi_in_caduta(livello_corrente)
         return
 
-    for s in stelle:
-        # Movimento verticale
-        s.y += s.vy
+    # Aggiorna movimento di ogni personaggio
+    for attore in lista_personaggi_in_gioco:
+        # Movimento verticale diverso nel Sottosopra
+        if modalita_sottosopra:
+            attore.y -= attore.velocita_y
+            if attore.y < -80:
+                attiva_game_over()
+        else:
+            attore.y += attore.velocita_y
+            if attore.y > ALTEZZA + 80:
+                attiva_game_over()
+
+        # Oscillazione orizzontale sinusoidale
+        oscillazione = math.sin(attore.timer * 0.1) * attore.ampiezza_oscillazione
+        attore.x += attore.velocita_x + oscillazione
+        attore.timer += 1
+
+        # Evita che escano dai bordi orizzontali
+        if attore.x < 0:
+            attore.x = 0
+            attore.velocita_x = -attore.velocita_x
+        if attore.x > LARGHEZZA:
+            attore.x = LARGHEZZA
+            attore.velocita_x = -attore.velocita_x
+
+        # Piccole variazioni casuali del movimento
+        if random.random() < 0.01:
+            attore.velocita_x = random.randint(-3, 3)
 
-        # Movimento orizzontale + oscillazione sinusoidale
-        oscillazione = math.sin(s.timer * 0.1) * s.osc_amp
-        s.x += s.vx + oscillazione
+    # Gestione timer Sottosopra
+    timer_sottosopra -= 1 / 60
+    if timer_sottosopra <= 0:
+        attiva_sottosopra()
+        timer_sottosopra = random.randint(TEMPO_MIN_SOTTOSOPRA, TEMPO_MAX_SOTTOSOPRA)
 
-        s.timer += 1
 
-        # Rimbalzo ai bordi
-        if s.x < 0:
-            s.x = 0
-            s.vx = -s.vx
-        if s.x > WIDTH:
-            s.x = WIDTH
-            s.vx = -s.vx
+# GENERAZIONE PERSONAGGI
 
-        # Cambio direzione casuale ogni tanto
-        if random.random() < 0.01:
-            s.vx = random.randint(-3, 3)
 
-        # Se tocca il fondo → game over
-        if s.y > HEIGHT:
-            gestisci_game_over()
+def genera_personaggi_in_caduta(numero_extra):
+    """Genera il personaggio obiettivo + altri personaggi casuali."""
+    lista_nomi = scegli_personaggi_livello(numero_extra)
+    nuovi_attori = []
 
+    for nome in lista_nomi:
+        attore = Actor(nome)
 
-def genera_stelle(numero_extra):
-    # lista: 1 target + numero_extra distrazioni
-    lista = ottieni_personaggi_da_creare(numero_extra)
-    nuove = []
+        # Posizione iniziale X
+        attore.x = random.randint(100, LARGHEZZA - 100)
 
-    for nome in lista:
-        a = Actor(nome)
-        a.x = random.randint(100, WIDTH - 100)
-        a.y = -50
+        # Posizione iniziale Y (alto o basso nel Sottosopra)
+        attore.y = -50 if not modalita_sottosopra else ALTEZZA + 50
 
-        # velocità verticale
-        a.vy = random.uniform(livello_corrente * 0.3, livello_corrente * 0.6)
+        # Velocità verticale basata sul livello
+        velocità_base = random.uniform(livello_corrente * 0.3, livello_corrente * 0.6)
+        attore.velocita_y = velocità_base * (1.3 if modalita_sottosopra else 1)
 
-        # velocità orizzontale
-        a.vx = random.randint(-3, 3)
+        # Velocità orizzontale
+        attore.velocita_x = random.randint(-3, 3)
 
-        # parametri oscillazione
-        a.osc_amp = random.uniform(1, 4)
-        a.timer = random.randint(0, 1000)
+        # Oscillazione sinusoidale
+        attore.ampiezza_oscillazione = random.uniform(1, 4)
+        attore.timer = random.randint(0, 1000)
 
-        nuove.append(a)
+        nuovi_attori.append(attore)
 
-    return nuove
+    return nuovi_attori
 
 
-def ottieni_personaggi_da_creare(num_extra):
-    lista = [personaggio_target]
-    altri = [p for p in PERSONAGGI if p != personaggio_target]
+def scegli_personaggi_livello(num_extra):
+    """Ritorna il personaggio obiettivo + altri casuali."""
+    lista = [personaggio_obiettivo]
+    altri = [p for p in LISTA_PERSONAGGI if p != personaggio_obiettivo]
 
     for _ in range(num_extra):
         lista.append(random.choice(altri))
 
     return lista
 
 
-def on_mouse_down(pos):
-    global selezione_iniziale, personaggio_target, livello_corrente, stelle
+# INPUT DEL MOUSE
+
 
-    if selezione_iniziale:
-        for p in personaggi_scelta:
-            if p.collidepoint(pos):
-                personaggio_target = p.image
-                selezione_iniziale = False
+def on_mouse_down(pos):
+    global fase_scelta_personaggio, personaggio_obiettivo, lista_personaggi_in_gioco
+
+    # Se siamo nella schermata di scelta
+    if fase_scelta_personaggio:
+        for attore in personaggi_da_selezionare:
+            if attore.collidepoint(pos):
+                personaggio_obiettivo = attore.image
+                fase_scelta_personaggio = False
                 return
 
-    for s in stelle:
-        if s.collidepoint(pos):
-            if s.image == personaggio_target:
-                click_su_target()
+    # Durante il gioco: verifica se si clicca il personaggio corretto
+    for attore in lista_personaggi_in_gioco:
+        if attore.collidepoint(pos):
+            if attore.image == personaggio_obiettivo:
+                avanza_livello()
             else:
-                gestisci_game_over()
+                attiva_game_over()
 
 
-def click_su_target():
-    global livello_corrente, stelle, game_completato
+# LOGICA DI LIVELLO / GAME OVER
 
-    if livello_corrente == LIVELLO_FINALE:
-        game_completato = True
+
+def avanza_livello():
+    """Gestisce il passaggio al livello successivo."""
+    global livello_corrente, lista_personaggi_in_gioco, gioco_completato
+
+    if livello_corrente == LIVELLO_MASSIMO:
+        gioco_completato = True
     else:
         livello_corrente += 1
-        stelle = []
+        lista_personaggi_in_gioco = []  # per rigenerare i nuovi personaggi
+
+
+def attiva_game_over():
+    """Mostra la schermata di fallimento."""
+    global gioco_terminato
+    gioco_terminato = True
 
 
-def gestisci_game_over():
-    global game_over
-    game_over = True
+# INTERFACCIA UTENTE
 
 
 def mostra_messaggio(titolo, sottotitolo):
-    screen.draw.text(titolo, fontsize=60, center=CENTRO, color=FONT_COLOR)
+    screen.draw.text(titolo, fontsize=60, center=CENTRO, color=COLORE_TESTO)
     screen.draw.text(
-        sottotitolo, fontsize=30, center=(CENTRO_X, CENTRO_Y + 30), color=FONT_COLOR
+        sottotitolo,
+        fontsize=30,
+        center=(CENTRO_X, CENTRO_Y + 30),
+        color=COLORE_TESTO,
     )
 
 
-def mostra_schermata_scelta():
-    global personaggi_scelta
-    personaggi_scelta = []
-    distanza = WIDTH / (len(PERSONAGGI) + 1)
+# SOTTOSOPRA
+
+
+def attiva_sottosopra():
+    """Attiva/disattiva la modalità Sottosopra e modifica la fisica."""
+    global modalita_sottosopra
+
+    modalita_sottosopra = not modalita_sottosopra
+
+    for attore in lista_personaggi_in_gioco:
+        attore.velocita_y *= 1.25  # più veloce nel Sottosopra
+        attore.y = ALTEZZA - attore.y  # ribalta asse verticale
+
+
+# SCHERMATA DI SCELTA
+
+
+def mostra_schermata_scelta_personaggio():
+    """Genera i personaggi da cliccare nella schermata iniziale."""
+    global personaggi_da_selezionare
+
+    personaggi_da_selezionare = []
+    spaziatura = LARGHEZZA / (len(LISTA_PERSONAGGI) + 1)
+
+    for indice, nome in enumerate(LISTA_PERSONAGGI):
+        attore = Actor(nome)
+        attore.x = (indice + 1) * spaziatura
+        attore.y = ALTEZZA / 2
+        personaggi_da_selezionare.append(attore)
 
-    for i, nome in enumerate(PERSONAGGI):
-        a = Actor(nome)
-        a.x = (i + 1) * distanza
-        a.y = HEIGHT / 2
-        personaggi_scelta.append(a)
 
+# Avvia schermata iniziale
+mostra_schermata_scelta_personaggio()
 
-mostra_schermata_scelta()
+# Avvio del gioco Pygame Zero
 pgzrun.go()