Linguaggi e Modelli Computazionali LS

1. MaraffoneLang Un linguaggio per descrivere partite di Maraffone: il gioco più popolare in Romagna! Linguaggi e Modelli Computazionali LS Alessio Della Motta Anno Accademico 2007/2008

2. Obiettivo del Progetto • Sviluppare un semplice linguaggio che permetta la descrizione dello svolgimento di una partita di Maraffone, un gioco di carte molto diffuso in Romagna. • Realizzare un valutatore o interprete in grado di calcolare i punteggi parziali e complessivi della partita, controllando al contempo il corretto svolgimento delle diverse fasi e dei turni di gioco.

3. Le Regole del Maraffone

4. Grammatica: Formalismo G = <VT, VN, P, S>

5. Grammatica: Proprietà • Le produzioni della grammatica sono nella forma: A ::= α, A Є VN,αЄ (VT U VN)*. • La grammatica è di Tipo 2 (context-free) secondo la classificazione di Chomsky. • La grammatica non contiene Self-Embedding, perciò il linguaggio generato sarà di Tipo 3 (regolare). • LL(1), così da garantire il determinismo dell’analisi ricorsiva discendente.

6. Grammatica: Tokens Tokens per nomi e numeri: <CIFRA_NON_NULLA:["1"-"9"]> <CIFRA: <CIFRA_NON_NULLA> | "0"> <NUM: <CIFRA_NON_NULLA>(<CIFRA>)*> <CARATTERE: ["a"-"z", "A"-"Z", "_"]> <NOME:<CARATTERE> (<CARATTERE> | <CIFRA>)*> Tokens per carte e dichiarazioni: <SEME: "Denari" | "Coppe" | "Spade" | "Bastoni"> <VALORE_CARTA: "Tre" | "Due" | "Asso" | "Re" | "Cavallo" | "Fante" | "Sette" | "Sei" | "Cinque" | "Quattro"> <DICHIARAZIONE: "Busso" | "Striscio" | "Volo">

7. Grammatica: Non-Terminali(1) Scopo S della grammatica: Scope ::= "MARAFFONE" "{" Coppie Soglia ( Partita )+ "}" Il linguaggio deve contenere forzatamente le indicazioni delle squadre, della soglia ed una o più partite. Questa scelta è dovuta al fatto che non esiste un Maraffone senza due squadre ed almeno una partita . Descrizione delle coppie, della soglia e delle partite: Coppie::="COPPIE:"<NOME> "&"<NOME> ","<NOME> "&"<NOME> "." Soglia::="SOGLIA:"<NUM> "." Partita::="PARTITA" "{" DistribuzioneCarteBriscolaMani"}" Per quanto riguarda le parentesi graffe, non vi è self-embedding: una sola parentesi iniziale ed una sola finale in entrambi i casi. Nessun livello di nesting di cui tenere conto.

8. Grammatica: Non-Terminali(2) Distribuzione delle carte ai giocatori: DistribuzioneCarte::="DISTRIBUZIONE CARTE:"Consegna";"Consegna";"Consegna";"Consegna"." Consegna::=<NOME>"RICEVE"ListaCarteRicevute ListaCarteRicevute::=CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola"," CartaRomagnola Ogni giocatore deve ricevere esattamente 10 carte, non una di più e non una di meno... Decisione della briscola: Briscola::="BRISCOLA DECISA DA" <NOME> "A"<SEME> "."

9. Grammatica: Non-Terminali(3) Descrizione delle mani di una partita: Mani::=Mano ManoManoManoManoManoManoManoManoMano Mano::="MANO:"GiocataDiMano","Giocata","Giocata","Giocata"." CartaRomagnola::=<VALORE_CARTA>"di"<SEME> GiocataDiMano::=<NOME>("DICHIARA"<DICHIARAZIONE>)? "GIOCA"CartaRomagnola Giocata::=<NOME>"GIOCA"CartaRomagnola Le mani in una partita devono essere obbligatoriamente dieci. Solo il giocatore di mano (ovvero il primo a giocare nella mano) può decidere se fare o meno una dichiarazione.

10. Grammatica: Osservazioni • La grammatica può non essere elegante in alcuni suoi punti, ad esempio la produzione: Mani → Mano Mano ... Mano. • Possibile alternativa: Mani → (Mano)+ • In questo caso, però, la struttura sintatticadel linguaggio si correla direttamente ad un requisito semantico ben preciso (ovvero il fatto che occorrano dieci mani per fare una partita). Per questo motivo si è deciso di specificare dieci volte il non-terminale Mano, rendendo così sintatticamente errate frasi che descrivano partite con un numero di mani diverso da dieci. • Non sono presenti ε-rulese si verifica facilmente come gli starter-set siano disgiunti, rendendo così la grammatica LL(1).

11. Strumenti Utilizzati • Linguaggio: Java (jdk1.6.0_03). • Ambiente di sviluppo: NetBeans IDE 6.0. • Generazione automatica parser: JavaCC 4.0. • Generazione classi che rappresentano l’albero sintattico ed implementazione di Visitor generici che effettuano la visita depth-first: Java Tree Builder 1.3.2.

12. Architettura: Packages Il package Parser è stato generato in automatico da JavaCC; i package Visitor e SyntaxTree sono stati generati da JTB; il package GUI è stato parzialmente implementato da NetBeans IDE.

13. Package Maraffone (1a)

14. Package Maraffone (1b) • Classe CircularList generica che estende la classe Vector e implementa le funzionalità di una coda circolare. Sarà utile al gestore dei turni (vedi dopo). • Enumerativi Seme e ValoreCarta per descrivere una carta, che sarà rappresentata dall’omonima classe Carta. • Un’eccezione apposita MaraffoneException scatenata da errori semantici che possono avvenire durante la valutazione.

15. Package Maraffone (2a)

16. Package Maraffone (2b) • Un giocatore è rappresentato da un’istanza della classe Giocatore, al quale durante un Maraffone saranno assegnate diverse mandate di carte (una per ogni partita) rappresentate anch’esse dall’apposita classe Mandata. • Una Squadra è composta da due giocatori e mantiene un certo insieme di carte che saranno quelle accumulate durante una specifica partita. • L’ambiente di gioco è rappresentato dalla classe Tavolo, tramite la quale sarà possibile svolgere tutte le azioni semantiche necessarie: ad esempio la giocata di una carta da parte di un giocatore, la dichiarazione della briscola, la presa di una squadra e così via. • La classe Tavolo contiene un GestoreTurno al quale è delegato il compito di gestire il corretto ordine di gioco dei giocatori.

17. Architettura: Visitor Sono stati implementati due visitor per ottenere due distinte interpretazioni: • MaraffoneVisitor: • Percorre l’albero ed istanzia tutti gli oggetti necessari (giocatori, squadre, ecc.), tra cui un Tavolo che rappresenterà l’ambiente di gioco. Tramite questo si eseguiranno tutte le operazioni di gioco, facendo i necessari controlli semantici, e si otterranno i risultati parziali e complessivi del Maraffone. • MaraffoneTreeVisitor: • Costruisce una struttura a TreeNode atta a rappresentare l’albero sintattico. Non vengono fatti controlli semantici, quindi se un testo è conforme alla sintassi del linguaggio e non alla semantica del gioco, l’albero verrà generato ugualmente.

18. Interfaccia Grafica Risultato della visita del visitor MaraffoneVisitor Risultato della visita del visitor MaraffoneTreeVisitor

19. Architettura: Test • Alcuni test utilizzando JUnit. • Ad esempio per testare il funzionamento della classe CircularList. • Un maggior numero di Test operativi tramite esempi costruiti ad-hoc, in modo da osservare se il linguaggio gestiva correttamente le varie tipologie di situazioni anomale.

20. Limiti e Sviluppi Futuri • Non sono state implementate esattamente tutte le regole, come ad esempio l’obbligo ci chiamare la briscolao la possibilità di chiamarsi fuori. • Non ci sono controlli sulla veridicità delledichiarazioni del primo giocatore di una mano, anche se ciò non è strettamente necessario in quanto un giocatore può bluffare. • Linguaggio verboso; sarebbero utili tool di generazione automatica (possibilmente in modo grafico) di testi del linguaggio. • Implementazione del gioco via rete, ad esempio tramite quattro client ed un server centrale che, mano a mano che il gioco avanza, compila un testo del linguaggio e genera i risultati alla fine della partita.