algorithm.txt

Ho spezzato il problema nelle seguenti parti:

1. funzione check_board(), che controlla se la scacchiera è piena:
    scorrendo tutta la scacchiera, SOLO ogni volta che trova un punto, controlla, 
    in base al giocatore del turno corrente, se in tutte le caselle adiacenti 
    c'è almeno una pedina dell'avversario, ritornando, 
    in caso di uno o più riscontri con tale condizione,
    una lista con le posizioni valide al piazzamento della pedina del giocatore corrente 
    
2. funzione check_winner(), che controlla chi dei 2 giocatori abbia vinto, oppure se c'è un pareggio:
    richiamata in dumbotello_rec ogni volta che la funzione check_board() ritorna una lista vuota, 
    conto le pedine di ogni giocatore e aggiorno il contatore corrispondente nella lista dei punteggi,
    (che sarà poi alla fine ritornata alla funzione dumbotello())


3. funzione check_position(), che controlla se la posizione con cui stiamo interagendo è valida:
    controlla se la posizione che stiamo gestendo per qualsivoglia motivo sborda,
    anche solo da uno dei 4 lati e/o angoli della scacchiera,
    ritornando True solo se la posizione non sborda da nessuna parte, altrimenti False
            
4. funzione place_piece(), che piazza la/le pedina/e in base alle nostre esigenze:
    controllando che la posizione sia valida con check_position() e che in quest'ultima ci sia una pedina avversaria,
    vado a mettere la pedina del giocatore corrente su quella posizione e su tutte le adiacenti
    che contengono pedine avversarie
                
5. funzione dumbotello_rec(), vero motore del programma nonchè funzione ricorsiva:
    richiamata ogni volta durante la costruzione dell'albero di gioco, 
    scorre la lista delle posizioni valide e per ogni posizione valida creo una copia della scacchiera
    e lavoro su quella copia, cosi da evitare conflitti di conteggio o di qualsiasi altro genere. 
    Richiamando la funzione place_piece() difatto svolgo il turno corrente,
    poi richiamo la funzione dumbotello_rec() passandogli la scacchiera aggiornata e il turno successivo,
    fino ad arrivare al corrispondente nodo foglia. A quel punto, viene richiamata 
    la funzione check_winner() che aggiorna la lista dei punteggi ritornandola anche,
    dopo aver sviluppato tutti i nodi foglia, alla funzione dumbotello()
                    
 6. funzione dumbotello(), che si occupa di chiamare la funzione ricorsiva e di stampare il risultato:
    leggo il contenuto del file di testo convertendolo in una matrice
    uso un dizionario per associare i giocatori ai loro simboli e per facilitarmi il cambio di 
    giocatore ad ogni turno. Richiamo la funzione check_board() per ottenere una prima lista 
    delle posizioni valide, poi richiamo la funzione dumbotello_rec() passandogli la scacchiera
    e il turno corrente, che sarà poi aggiornato ad ogni chiamata ricorsiva.
    Alla fine della costruzione dell'albero di gioco, la funzione dumbotello()
    stamperà i punteggi sotto forma di tupla, come richiesto dal testo del problema.