Progetto < PO

Tags: view all tags
<H1>Progetto di Programmazione a Oggetti (A.A. 2004-05)</H1>

----

%TOC%

----

<table width="80%" align="center">
<tbody>
<tr><td>
<font size="+2">[[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/po-0405.tgz][Sorgenti delle classi Java dell'interfaccia e <br>della specifica del progetto]]</font>

<font size="+1">Attenzione! &Egrave; stata aggiornata la classe [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/ArgomentiComando.java][<nop>ArgomentiComando]].</font>

In particolare,
sono stati modificati il metodo statico join e il costruttore della classe astratta <nop>ListaTesto. Nella precedente versione non si potevano avere oggetti delle sottoclassi di <nop>ListaTesto, ovvero di <nop>ListaCaseTesto, <nop>ListaMosseTesto e <nop>ListaPosPezziTesto, contenenti la lista vuota che, come stringa, corrisponde alla stringa vuota "". Adesso &egrave; possibile creare oggetti contenenti la lista vuota con new <nop>ListaCaseTesto("") e analogamente per le altre sottoclassi.
</td></tr>
<tr><td>
<hr>

<font size="+2">[[CompilazioneSorgenti][Alcuni suggerimenti per la compilazione dei sorgenti Java]]</font>
</td></tr>
<tr><td>
<hr>

<font size="+2">Gli studenti che vogliono, possono sviluppare una interfaccia grafica per il progetto di gioco degli scacchi.
Lo sviluppo dell'interfaccia grafica esonera dalla parte scritta dell'esame che pertnato verter&agrave; solo sulla discussione del progetto e dell'interfaccia.</font>
</td></tr></tbody>
</table>

----

Il progetto Java di quest'anno consiste nella implementazione di un package di classi per il gioco degli scacchi.

L'obiettivo &egrave; avere un'applicazione che permette di eseguire passo-passo le mosse di una partita di scacchi (verificandone la correttezza) ed in grado di restituire informazioni sulla situazione corrente della partita. Ad esempio, la classe corrispondente deve avere un metodo per eseguire una mossa ed aggiornare la posizione, dei metodi per ottenere la posizione dei pezzi sulla scacchiera, il giocatore che ha il tratto, il numero della mossa, le mosse che il giocatore con il tratto pu&ograve; giocare, e un metodo per verificare se il Re del giocatore che ha il tratto &egrave; sotto scacco o meno.

La parte di interfaccia viene fornita insieme alle specifiche del progetto. Gli studenti dovranno pertanto fornire una implemenatzione di una _interface_ data (l'interface [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/Partita.java][Partita]]). La classe che implementa tale interface si dovr&agrave; chiamare <nop>PartitaScacchi.java e dovr&agrave; avere due costruttori descritti nelle specifiche del progetto.

---++ Specifiche del progetto

---+++ I metodi di <nop>PartitaScacchi.java

Si deve fornire una classe <nop>PartitaScacchi.java che implementa l'interface [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/Partita.java][Partita.java]].

Le classi degli oggetti che i metodi di Partita ricevono e ritornano (a parte quelle base di Java) sono definite come classi annidate nella classe contenitore [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/ArgomentiComando.java][ArgomentiComando.java]]. 

Fondamentalmente si tratta di stringhe che rappresentano una delle seguenti informazioni

   * una casa della scacchiera (la classe <nop>CasaTesto), nella forma _rt_ dove _r_ &egrave; un carattere tra 'a' e 'h' che indica la colonna della casa e 't' un numero tra '1' e '8' che indica la traversa

   * la posizione di un pezzo sulla scacchiera (la classe <nop>PosPezzoTesto), nella forma _Xrt_ dove _X_ &egrave; una iniziale di pezzo tra Re, Donna, Torre, Alfiere, Cavallo e Pedone che indica il corrispondente pezzo e _rt_ una casa della scacchiera, se l'iniziale del pezzo &egrave; maiuscola si tratta di un pezzo del Bianco, se minuscola si tratta di un pezzo del Nero

   * la mossa di un pezzo (la classe <nop>MossaTesto), nella forma _rtps_ dove _rt_ &egrave; la casa di partenza e _ps_ la casa di arrivo, opppure nella forma _rtps=X_ nel caso di promozione di un pedone, dove _X_ &egrave; il pezzo a cui si intende promuovere il pedone (l'arrocco &egrave; indicato dalla coppia di case di partenza e di arrivo del Re)

   * liste di una delle precedenti informazioni (le classi <nop>ListaCasaTesto, <nop>ListaPosPezzoTesto, <nop>ListaMossaTesto), in pratica, sequenze di stringhe del precedente tipo separate da spazi bianchi

Le uniche operazioni che si possono eseguire sulle suddette classi sono:

   * chiamare il costruttore della classe su di una stringa che si suppone corretta rispetto all'informazione che si vuole memorizzare

   * riottenere la stringa memorizzata nell'istanza della classe mediante il metodo toString()

Se si cerca di costruire un oggetto di un certo tipo con una stringa sintatticamente errata, viene sollevata una eccezione della gerarchia di eccezioni con radice in <nop>NotazioneException. La classe <nop>NotazioneException e le sue sottoclassi sono definite come classi annidate all'interno della classe contenitore [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/EccezioniTesto.java][EccezioniTesto.java]].

I compiti che i metodi da implementare devono svolgere sono specificati nei commenti contenuti nel sorgente della classe
[[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/Partita.java][Partita.java]]. Si tratta di commenti nella sintassi di javadoc e possono quindi essere consultati in formato [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/doc/scacchi/main/Partita.html][html]].

L'esecuzione dei metodi di <nop>Partita pu&ograve; portare a degli errori (ad esempio, se si cerca di eseguire una mossa non valida). Le corrispondenti eccezioni sono definite e descritte nella classe 
[[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/main/EccezioniPartita.html][EccezioniPartita]].

---+++ I costruttori di <nop>PartitaScacchi.java

La classe <nop>PartitaScacchi.java deve avere due costuttori

   * <nop>PartitaScacchi(): che crea una nuova partita che comincia dalla posizione iniziale del gioco

   * <nop>PartitaScacchi(int&nbsp;n,&nbsp;ArgomentiComando.ListaPosPezziTesto&nbsp;l): che crea una nuova partita che comincia da una posizione data (sotto forma di lista di pezzi) e che comincia dalla mossa n-esima, assumendo che, se n &egrave; positivo il tratto &egrave; al Bianco, altrimenti il tratto &egrave; al Nero.

Per maggiori dettagli si veda una  [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/prova/PartitaScacchi.java][versione di prova di <nop>PartitaScacchi]].


---+++ L'interfaccia comandi ed il programma di prova

Le classi ed interfacce descritte nelle precedenti parti sono le sole strettamente necessarie per l'implementazione del progetto.

Per semplificare la verifica della correttezza della classe <nop>PartitaScacchi.java implementata, il package scacchi contiene una classe eseguibile [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/src/scacchi/Prova.java][<nop>Prova.java]]. 
Il main di tale classe implementa un ciclo di lettura, esecuzione e stampa del risultato di comandi. La sintassi dei comandi &egrave; la seguente

<table>
 <tr><td>  #  </td>

         <td>  chiede il numero della mossa  </td></tr>
 <tr><td>  @  </td>
         <td>  chiede quale giocatore ha il tratto  </td></tr>
 <tr><td>  e <em>mossa</em>  </td>

         <td>  esegue <em>mossa</em>  </td></tr>
 <tr><td>  l    </td>
         <td>  lista tutte le mosse della partita  </td></tr>
 <tr><td>  l <em>n</em>  </td>

         <td>  lista le ultime <em>n</em> mosse della partita  </td></tr>
 <tr><td>  i  </td>
         <td>  torna indietro di una semi-mossa  </td></tr>
 <tr><td>  i <em>n</em>  </td>

         <td>  torna indietro di <em>n</em> semi-mosse  </td></tr>
 <tr><td>  p  </td>
         <td>  posizione dei pezzi  </td></tr>
 <tr><td>  c <em>casa</em>  </td>

         <td>  case controllate dal pezzo in <em>casa</em>  </td></tr>
 <tr><td>  m  </td>
         <td>  mosse valide per il giocatore che ha il tratto
 <tr><td>  m <em>casa</em>  </td>

         <td>  mosse valide per il pezzo in <casa>  </td></tr>
 <tr><td>  n  </td>
         <td>  ricomincia una nuova partita  </td></tr>
 <tr><td>  n <em>i</em> <em>lista-pos-pezzi</em>  </td>

         <td>  ricomincia una nuova partita a partire dalla
               posizione fornita in <em>lista-pos-pezzi</em>,
               <em>i</em> indica il numero della mossa, se positivo il
               tratto &egrave; al BIANCO, se negativo &egrave; al NERO.
               </td></tr>
 </table>

Dopo aver lanciato il programma di prova, il primo comando deve creare una nuova partita (dalla poszione iniziale del gioco o da una fornita come argomento). In qualsiasi momento, l'esecuzione di un comando di nuova partita, termina la partita in corso e ne comincia una nuova.

Il programma di prov si basa su di una interfaccia comandi le cui classi sono contenute nel package scacchi.main. Una descrizione pi&ugrave; dettagliata di come &egrave; realizzata questa interfaccia si trova alla pagina [[InterfacciaComandi]]. Per quanto utile da un punto di vista didattico, la conoscenza dell'implementazione dell'interfaccia comandi non &egrave; necessaria ai fini dello sviluppo del progetto.

Oltre al programma di prova della classe <nop>PartitaScacchi del package scacchi.soluzione (quella che dovr&agrave; essere implementata per risolvere il progetto), la distribuzione dei file contiene anche un programma di prova dell'interfaccia nel pacakge scacchi.prova basata su di una versione di <nop>PartitaScacchi di prova che implementa i metodi richiesti in modo banale (ritornando valori costanti predefiniti) e che a ogni esecuzione di un metodo stampa un avviso con una descrizione del messaggio che ha attivato il metodo.


---+++ Organizzazione in package

Le classi (e le interfacce) che servono per la specifica del progetto insieme a quelli che implementano l'interfaccia comandi appartengono al package scacchi.main, la classe da implementare, insieme a tutte le altre classi e/o interfacce che si riterr&agrave; di scrivere per implementarla, dovranno appartenere al package scacchi.soluzione.

Nella distribuzione dei file che trovate in fondo a questa pagina, il package scacchi.soluzione contiene una versione dummy di <nop>PartitaScacchi nella quale i metodi non fanno nulla e ritornano valori 0 o null.

Il package scacchi.prova contiene una versione di prova di <nop>PartitaScacchi che verifica l'interfaccia dei comandi.


---+++ Documentazione del codice

I codice dovr&agrave; essere documentato inserendo commenti javadoc che spiegano il significato, lo scopo e l'utilizzp di tutte le classi, i metodi e i campi che verranno scritti (anche di quelli privati). La qualit&agrave; della documentazione avr&agrave; un peso non nullo nella valutazione del progetto.


---++ Termini di consegna

Sino ad una settimana prima dell'appello in cui si intende discutere il progetto.


---+++ Modalit&agrave; di consegna

Da definire...


---++ Informazioni sul gioco degli scacchi

Le regole ufficiali del gioco degli scacchi (traduzione italiana del regolamento della federazione internazionale di scacchi FIDE)
sono consultabili alla seguente pagina [[http://www.maskeret.com/micio/docfide.htm]].

Per quanto riguarda la realizzazione del progetto, le regole che interessano sono quelle sulla
[[http://www.maskeret.com/micio/docfide.htm#3][disposizione iniziale dei pezzi sulla scacchiera]]
e sul [[http://www.maskeret.com/micio/docfide.htm#4][movimento dei pezzi]].

Per quanto riguarda le mosse dei pezzi si richiama l'attenzione su:

   * la presa "en passant" (comma 3.7.(d))

   * la promozione (comma 3.7(e))

   * l'arrocco (comma 3.8(ii)), in particolare, si faccia attenzione alle situazioni che rendono l'arrocco illegale o temporaneamente proibito 

---++ Link utili

   * Un file tar-gzipped con tutti i sorgenti e la documentazione [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/po-0405.tgz]]

   * La documentazione delle classi fornite (include la documentazione degli elementi privati) [[http://www.dsi.uniroma1.it/~guerrini/ProgOgg/progetto/doc]]