<aside> 🧩

Prerequisiti

Aver completato le Parti 1-4 (Player, Weapon, Potion, __str__, @property, Eccezioni).
Saper organizzare il codice in file separati e gestire le importazioni (import).
Aver compreso in modo approfondito la teoria del Pattern MVC (Model, View, Controller) e le relative Regole di Comunicazione. </aside>

<aside> 🧠

Cosa imparerai con questo esercizio

Come applicare i principi del Refactoring per trasformare codice funzionante ma disordinato in codice strutturato.
L'importanza del Disaccoppiamento (Decoupling) forzato tra View e Model.
Come definire un’Interfaccia Pubblica (Contratto) tra due componenti software (Controller e View) in un contesto di lavoro di squadra.
Come creare un flusso di controllo robusto e gestito dal Controller. </aside>

<aside> 📢

Novità

Questo esercizio introduce una nuova metodologia di lavoro e tre nuovi elementi strutturali:

1. Metodologia: cooperative learning 🧑‍💻🤝

Lavorerete in coppia simulando un piccolo team di sviluppo:

Role 1: Backend/Logic Developer (focus su Controller e Model).
Role 2: Frontend/UI Developer (focus sulla View).

2. Nuove Classi e file

Introdurremo due nuove classi per gestire l’architettura:

GameController (nel nuovo file controller.py)
- Responsabile di ospitare il ciclo di gioco (while True:) e di coordinare il Model e la View.
ConsoleView (nel nuovo file view.py)
- Responsabile esclusivo di tutte le operazioni di input (input()) e output (print()).

3. Refactoring

Il codice esistente (Player, Weapon, ecc.) dovrà essere ripulito da tutti i comandi di print() e input() che violano la Regola 2 del Pattern MVC.

</aside>

Obiettivo

L’obiettivo principale è separare completamente la logica del gioco (Model) dalla sua presentazione (View). Alla fine dell’esercizio, l’applicazione non sarà più un singolo script nel main.py, ma un sistema modulare organizzato in tre livelli distinti, rendendola scalabile e mantenibile.

Questo esercizio è pensato per essere affrontato in un lavoro di gruppo da due studenti, ma se sei da solo non ti preoccupare, puoi affrontarlo lo stesso facendo prima uno e poi l’altro.

Specifiche del “Backend Specialist” (`GameController`)

Il ruolo del Backend Specialist è quello di implementare la Logica Applicativa. Deve assicurarsi che il cuore del gioco sia gestito correttamente, libero da dipendenze sull’interfaccia utente.

1. Ruolo e Responsabilità

Componente	File	Ruolo MVC	Dipendenze (importa)	Non contiene MAI
Model	`player.py`, `weapon.py`, etc.	Dati e Regole di Business	Nessuno	`print()`, `input()`
Controller	`controller.py`	Coordinamento e flusso di gioco	Model (`Player`, `Weapon`, ecc.) e View (`ConsoleView`)	Logica di formattazione del testo o in generale di output.

Il Controller è l’unico che può “chiamare” sia i metodi del Model che quelli della View.

2. Classe `GameController`

La classe GameController gestisce l’intero ciclo di gioco.

Metodo	Responsabilità	Dettagli
`__init__(self, view, player1, player2)`	Inizializzazione	Riceve un’istanza della View e i due Player come parametri. Salva tutti questi oggetti come attributi interni.
`start_game_loop(self)`	Ciclo principale	Esegue il `while True:` principale. Deve chiamare `view.show_welcome()` all’inizio e gestire i turni alternati fino alla fine del gioco.
`handle_turn(self, attacker, defender)`	Logica di Turno	Chiama i metodi del Model (`attacker.attack(defender)`) e poi chiama i metodi della View per mostrare l'esito (`self.view.show_attack_result(...)`).

Approfondimento facoltativo: Il Pattern Singleton

Specifiche del “Frontend Specialist” (`View`)

Il ruolo del Frontend Specialist è implementare l’Interfaccia e gestire tutte le comunicazioni con l’utente (mostrando output e richiedendo input), garantendo una presentazione chiara e accattivante, senza mai prendere decisioni sulla logica di gioco.