Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Java - Classifica
Forum - Java - Classifica

Avatar
Yuppie (Normal User)
Newbie


Messaggi: 1
Iscritto: 29/04/2010

Segnala al moderatore
Postato alle 12:13
Giovedì, 29/04/2010
Ciao a tutti
nel mio gioco in memory sto cercando di creare una tabella con dentro la classifica dei migliori dieci giocatori e che compaia al termine della partita se si vince, ma purtroppo mi compare solo una jframe con il contenuto vuoto e non capisco la motivazione. Metto il file zip e posto le parti di codice.
Main
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. /**
  4.  * @author Nicolò
  5.  */
  6.  
  7. /**
  8.  * In questo semplice main, viene creato un mazzo con le sue carte e viene passato a un oggetto della classe View
  9.  * che si prendere cura di farlo visualizzare.
  10.  */
  11. public class Main {
  12.  
  13.     public static void main(final String[] args) {
  14.         Mazzo mazzo = new Mazzo();
  15.         @SuppressWarnings("unused")
  16.         View v = new View(mazzo);
  17.  
  18.     }
  19.  
  20. }

Carta
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. /**
  4.  * @author Nicolò
  5.  */
  6.  
  7. import java.awt.Image;
  8. import java.awt.Toolkit;
  9.  
  10. /**
  11.  * Nella classe Carta vengono create funzioni che tendono a memorizzare lo stato della carta, ossia se è presente
  12.  * (COPERTA o VISIBILE) o se è stata rimossa dal tavolo, e a dirci la sue proprietà, tipo l'immagine
  13.  */
  14. public class Carta {
  15.  
  16.     /**
  17.      * Queste costanti ci informano dello stato della carta:
  18.      * - VISIBILE:  la carte è visibile con la sua immagine;
  19.      * - COPERTA: è visibile il retro della carta;
  20.      * - RIMOSSA: la carta è stata rimossa dal gioco.
  21.      */
  22.     static final int VISIBILE = 1;
  23.     static final int COPERTA = 0;
  24.     static final int RIMOSSA = -1;
  25.  
  26.     /**
  27.      * - stato: ci indica se la carta è stata è presente (coperta o girata) o se è stata rimossa dal gioco;
  28.      * - tipo: indica il seme della carta;
  29.      * - immagine: variabile di tipo Image contenente l'immagine del seme della carta;
  30.      * - retro: variabile di tipo image che contiene il retro della carta (uguale per tutte le carte).
  31.      */
  32.     private int stato;
  33.     private int tipo;
  34.     private Image immagine;
  35.     private Image retro;
  36.  
  37.     /**
  38.      * Costruttore della classe. Quando un oggetto di tipo Carta viene inizializzato richiede il seme (o tipo) della carta.
  39.      * Quindi imposta il tipo, poi carica l'immagine del rispettivo simbolo e infine imposta lo stato su COPERTA,
  40.      * poichè tutte le carte a inizio gioco mostrano il retro.
  41.      * @param simbolo
  42.      */
  43.     public Carta(int simbolo){
  44.         tipo = simbolo;
  45.         caricaImmagine(simbolo);
  46.         stato = Carta.COPERTA;
  47.     }
  48.  
  49.     /**
  50.      * Funzione che ritorna un immagine a seconda dello stato:
  51.      * - l'immagine se lo stato è VISIBILE;
  52.      * - il retro se lo stato è COPERTA;
  53.      * - fa return null se lo stato è RIMOSSA.
  54.      * @return
  55.      */
  56.     public Image Immagine(){
  57.         if (stato == Carta.VISIBILE)
  58.             return immagine;
  59.         else
  60.             if(stato == Carta.COPERTA)
  61.                 return retro;
  62.             else
  63.                 return null;
  64.     }
  65.  
  66.     /**
  67.      * Funzione utilizzata per girare la carta, quindi può modificare lo stato da COPRTA a VISIBILE e viciversa,
  68.      * ma non può impostarlo su RIMOSSA.
  69.      */
  70.     public void volta(){
  71.         if (stato == Carta.VISIBILE)
  72.             stato = Carta.COPERTA;
  73.         else
  74.             if(stato == Carta.COPERTA)
  75.                 stato = Carta.VISIBILE;
  76.     }
  77.  
  78.     /**
  79.      * Funzione che imposta lo stato della carta su RIMOSSA. In sostanza la funzione lo scopo di questa funzione è quella di rimuovere dal gioco la carta.
  80.      */
  81.     public void rimuovi(){
  82.         stato = Carta.RIMOSSA;
  83.     }
  84.  
  85.     /**
  86.      *Funzione similie alla funzione rimuovi: in sostanza il compito di questa funzione è quella di riassegnare lo stato
  87.      * COPERTA alla carta facendola tornare quindi visibile in gioco.
  88.      */
  89.     public void riassegna(){
  90.         stato = Carta.COPERTA;
  91.     }
  92.  
  93.     /**
  94.      * Funzione  che ha il compito di caricare le immagini per poi passarle al mediatracker nell classe Mazzo
  95.      * e quindi renderle visibili. Alla funzione viene passato una variabile di tipo int che rappresenta il seme
  96.      * della carta e quindi indica alla funzione quale immagine caricare.
  97.      * @param n
  98.      */
  99.     public void caricaImmagine(int n){
  100.         Toolkit kit = Toolkit.getDefaultToolkit();
  101.         immagine = kit.getImage("carta"+n+".jpg");
  102.         retro = kit.getImage("carta_retro.jpg");
  103.     }
  104.  
  105.     /**
  106.      *Funzione il cui semplice compito è quello di fare un return simbolo della carta in esame.
  107.      * @return
  108.      */
  109.     public int simbolo() {
  110.         return tipo;
  111.     }
  112.  
  113.     /**
  114.      * Funzione booleana che effettua un comparazione tra la carta che si sta valutando e un altra passata come parametro.
  115.      * Ritorna true se le carte sono uguali, false in caso contrario.
  116.      *
  117.      * @param compara
  118.      * @return
  119.      */
  120.     public boolean Uguale(Carta compara) {
  121.         if (compara.simbolo() == tipo)
  122.             return true;
  123.         else
  124.             return false;
  125.     }
  126.  
  127.     /**
  128.      * Funzione booleana che controlla se la carta analizzata è stata rimossa o è ancora in gioco.
  129.      * Ritorna true se le carta è stata rimossa, false in caso contrario.
  130.      * @return
  131.      */
  132.     public boolean Rimossa() {
  133.         if (stato == Carta.RIMOSSA)
  134.             return true;
  135.         else
  136.             return false;
  137.     }
  138.  
  139.     /**
  140.      * Funzione booleana che controlla se la carta analizzata è visibile oppure se è coperta o rimossa.
  141.      * Ritorna true se le carta è visibile, false in caso contrario.
  142.      * @return
  143.      */
  144.     public boolean Visibile(){
  145.         if(stato == Carta.VISIBILE)
  146.             return true;
  147.         else
  148.             return false;
  149.     }
  150. }

Mazzo
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. /**
  4.  * @author Nicolò
  5.  * Nella classe Mazzo vengono creati 16 oggetti di tipo Carta, i quali vengono istanziati con i relativi semi e le relative proprietà.
  6.  * In questa classe vengono poi mescolate le carte.
  7.  */
  8. public class Mazzo {
  9.  
  10.     private Carta carte[];
  11.  
  12.     /**
  13.      * Costruttore della classe Mazzo. Qui viene istanziato un vettore di 16 carte che cosituiscono a tutti gli effetti un mazzo.
  14.      * In seguito le carte vengono mescolate con l'apposita funzione mescola().
  15.      */
  16.     public Mazzo(){
  17.         carte = new Carta[16];
  18.         mescola();
  19.     }
  20.  
  21.     /**
  22.      * Funzione che viene richiamata nel costruttore per mescolare la carte del mazzo. A ogni indice da 1 a 16 viene assegnato un sign booleano che viene messo a false
  23.      * per tutti gli indici. In seguito usando un math.random() si sceglie a caso uno dei 16 indici e se il suo sign è a false
  24.      * allora alll'elemento carta corrispondente a quel numero non è stata ancora dato un seme. Se invece sign è true il ciclo Do..While ripete l'operazione
  25.      * fino a trovare un indice libero.
  26.      */
  27.     public void mescola(){
  28.         boolean sign[] = new boolean[16];
  29.         int indice;
  30.  
  31.         for(int i = 0; i < 16; i++)
  32.             sign[i] = false;
  33.         for(int i = 0; i < 2; i++)
  34.             for(int s = 0; s < 8; s++){
  35.                 do{
  36.                     indice = (int)(Math.random()*16);
  37.                     if (indice == 16) indice = 15;
  38.                 } while(sign[indice]);
  39.                 carte[indice] = new Carta(s);
  40.                 sign[indice] = true;
  41.             }
  42.  
  43.  
  44.     }
  45.  
  46.     /**
  47.      * Semplice funzione che fa il return della carta con le sue relative caratteristiche. Alla funzione viene passato il numero della carta che si intende vedere.
  48.      * @param i
  49.      * @return
  50.      */
  51.     public Carta Carta(int i){
  52.         return carte[i];
  53.     }
  54. }

Classifica
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileOutputStream;
  8. import java.io.ObjectInputStream;
  9. import java.io.ObjectOutputStream;
  10. import java.io.Serializable;
  11. import java.util.Vector;
  12.  
  13. /**
  14.  *  Classe che astrae la lista di records.
  15.  *  <p>
  16.  *  La lista è implementata tramite il metodo dei riferimenti.
  17.  *
  18.  *  @author Nicolò Torreggiani
  19.  */
  20. public class Classifica implements Serializable{
  21.         /**
  22.          *
  23.          */
  24.         private static final long serialVersionUID = 1L;
  25.  
  26.         private static final int MAX_RECORDS = 10;
  27.  
  28.         // La radice della lista.
  29.         private Record radice;
  30.  
  31.         // Numero di elementi in lista
  32.         private int numero;
  33.  
  34.         private Vector listeners;
  35.  
  36.         /**
  37.          * Funzione statica che consente di ricavare da una stringa i dati di un record.
  38.          *
  39.          * @param stringa                                       La stringa da cui ricavare i dati del record.
  40.          * @return                                                      Un oggetto Record corrispondente ai dati della stringa, il cui puntatore al record successivo è nullo.
  41.          * @throws IllegalArgumentException     Questa eccezione viene lanciata se non è possibile ricavare tutti i dati dalla stringa.
  42.          */
  43.         public static Record analizzaRecord(String stringa) throws IllegalArgumentException {
  44.                 String nome;
  45.                 int mosse;
  46.  
  47.                 // Divide la stringa
  48.                 String parti[] = stringa.split(",");
  49.  
  50.                 // Controlla l'esistenza effettiva delle stringhe
  51.                 try {
  52.                         if (parti[0] == null || parti[1] == null)
  53.                                 throw new IllegalArgumentException();
  54.                 } catch (ArrayIndexOutOfBoundsException e) {
  55.                         throw new IllegalArgumentException();
  56.                 }
  57.  
  58.                 // Ricava il nome
  59.                 nome = parti[0];
  60.  
  61.                 // Prova a ricavare i numeri
  62.                 try {
  63.                         mosse = Integer.parseInt(parti[1]);
  64.                 } catch (NumberFormatException e) {
  65.                         throw new IllegalArgumentException();
  66.                 }
  67.  
  68.                 return new Record(nome, mosse, null);
  69.         }
  70.  
  71.         /**
  72.          * Costruttore della lista. Imposta le variabili e la radice.
  73.          */
  74.         public Classifica() {
  75.                 numero = 0;
  76.                 radice = new Record(null, 0, null);
  77.                 listeners = new Vector();
  78.         }
  79.  
  80.         /**
  81.          * Aggiunge un record alla lista in modo ordinato. L'ordine è decrescente.
  82.          *
  83.          * @param record Il record da aggiungere.
  84.          */
  85.         public void Aggiungi(Record record) {
  86.                 Record puntatore = radice;
  87.  
  88.  
  89.                 // Scorriamo la lista in cerca del posto giusto
  90.                 while (puntatore.successivo != null) {
  91.                         if (record.Compara(puntatore.successivo) <= 0)
  92.                                 break;
  93.                         puntatore = puntatore.successivo;
  94.                 }
  95.  
  96.                 // Inseriamo il record nel posto giusto
  97.                 record.successivo = puntatore.successivo;
  98.                 puntatore.successivo = record;
  99.  
  100.                 // Aumentiamo il numero di records
  101.                 numero++;
  102.  
  103.                 // Controlliamo che non si sia superato il limite
  104.                 if (numero > Classifica.MAX_RECORDS) {
  105.                         RimuoviUltimo();
  106.                 }
  107.         }
  108.  
  109.         /**
  110.          * Versione alternativa dell'aggiunta di un record. I parametri sono direttamente i dati del record.
  111.          *
  112.          * @param nome          Nome del giocatore che ha effettuato il record.
  113.          * @param punteggio Punteggio del record.
  114.          * @param altezza       Altezza del record.
  115.          */
  116.         //public void Aggiungi(String nome, int punteggio, int altezza) {
  117.         //      Aggiungi(new Record(nome, punteggio, altezza, null));
  118.         //}
  119.  
  120.         public int Numero() {
  121.                 return numero;
  122.         }
  123.  
  124.         /**
  125.          * Consente di ottenere il record indice-esimo.
  126.          *
  127.          * @param indice                                                        L'indice del record che si vuole ottenere.
  128.          * @return                                                                      Il record indice-esimo.
  129.          * @throws ArrayIndexOutOfBoundsException       Se l'indice è scorretto viene lanciata una ArrayIndexOutOfBoundsException.
  130.          */
  131.         public Record Record(int indice) throws ArrayIndexOutOfBoundsException {
  132.                 Record puntatore = radice;
  133.  
  134.                 // Controlliamo che l'indice sia corretto
  135.                 if (indice < 0 || indice >= numero)
  136.                         throw new ArrayIndexOutOfBoundsException();
  137.  
  138.                 // Scorriamo fino al record desiderato
  139.                 for (int i = 0; i <= indice; i++)
  140.                         puntatore = puntatore.successivo;
  141.  
  142.                 return puntatore;
  143.         }
  144.  
  145.         // Rimuove l'ultimo record, se si è superato il limite
  146.         private void RimuoviUltimo() {
  147.                 Record puntatore = radice;
  148.  
  149.                 // Se non ci sono elementi si esce
  150.                 if (radice.successivo == null)
  151.                         return;
  152.  
  153.                 // Scorre fino al penultimo
  154.                 while (puntatore.successivo.successivo != null)
  155.                         puntatore = puntatore.successivo;
  156.  
  157.                 // Tronca il collegamento con l'ultimo
  158.                 puntatore.successivo = null;
  159.  
  160.                 // Diminuisce il numero
  161.                 numero--;
  162.         }
  163.  //Salva la rubrica nell'aposito file
  164.         public void save(){
  165.                 //Per evitare che qualche listener sia un oggetto di una
  166.                 //classe non serializabile, svuotima la lista dei listener
  167.                 //prima di salvare e poi la ripristiniamo
  168.                 Vector tempListeners = listeners;
  169.                 listeners = new Vector();
  170.                 try{
  171.  
  172.                         ObjectOutputStream out =
  173.                         new ObjectOutputStream(
  174.                         new BufferedOutputStream(
  175.                         new FileOutputStream(file)));
  176.                         out.writeObject(this);
  177.                         out.close();
  178.                 }
  179.                 catch (Exception e){
  180.                         System.out.print("An Exception has been raised while saving the file " + file);
  181.                         System.out.println(e);
  182.                 }
  183.                 listeners = tempListeners;
  184.         }
  185.  
  186.         public void carica(){
  187.  
  188.                 Classifica migliori;
  189.                 Object o = null;
  190.                         try{
  191.                             ObjectInputStream in =
  192.                             new ObjectInputStream(
  193.                             new BufferedInputStream(
  194.                             new FileInputStream(file)));
  195.                             o = in.readObject();
  196.                 }
  197.                 catch (Exception e){
  198.                         System.out.print("An exception has been raised while reading the  file " + file + "\n" + e);
  199.                 }
  200.  
  201.                 if((o != null) && (o instanceof Classifica))
  202.                         migliori = (Classifica)o;
  203.         }
  204. }

Record
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. import java.io.Serializable;
  4.  
  5. /**
  6.  * Un elemento della lista dei records.
  7.  * <p>
  8.  * Questa classe è utilizzata soltanto dalla ListaRecords. Contiene allo stesso tempo i dati del record e un puntatore al record successivo.
  9.  * <p>
  10.  * La classe implementa l'interfaccia Serializable. Infatti i records sono salvati come oggetti nel file dei records.
  11.  *
  12.  * @author Nicolò Torreggiani
  13.  */
  14. public class Record implements Serializable {
  15.         /**
  16.          *
  17.          */
  18.         private static final long serialVersionUID = 1L;
  19.         /**
  20.          * Nome del giocatore che ha effettuato il record.
  21.          */
  22.         public String nome;
  23.         /**
  24.          * Numero di mosse fatte dal giocatore
  25.          */
  26.         public int mosse;
  27.  
  28.         /**
  29.          * Puntatore al record successivo. Viene impostato dalla lista quindi è transient.
  30.          */
  31.         transient public Record successivo;
  32.  
  33.         /**
  34.          * Costruttore del record.
  35.          *
  36.          * @param n Nome del giocatore che ha effettuato il record.
  37.          * @param m numero di mosse
  38.          * @param s Puntatore al record successivo.
  39.          */
  40.         public Record(String n, int m, Record s) {
  41.                 nome = n;
  42.                 mosse = m;
  43.                 successivo = s;
  44.         }
  45.  
  46.         //
  47.         // Confronta due records.
  48.  
  49.         // @param record Il record da confrontare con questo.
  50.         // @return 0 se sono uguali, >0 se questo record ha usato più mosse per vincere di quello di confronto, <0 altrimenti.
  51.         //                      Poi compare le i nomi dei due record: 0  sono uguali, se < 0 la prima stringa precede la seconda, se > 0 al contrario
  52.  
  53.         public int Compara(Record record) {
  54.                 int risultato;
  55.  
  56.                 // Prima il numero di mosse
  57.                 risultato = this.mosse - record.mosse;
  58.  
  59.                 // Poi il nome
  60.                 if (risultato == 0)
  61.                         risultato = this.nome.compareTo(record.nome);
  62.  
  63.                 return risultato;
  64.         }
  65. }

View
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. import java.awt.Graphics;
  4. import java.awt.event.MouseEvent;
  5. import java.awt.event.MouseListener;
  6. import javax.swing.JFrame;
  7. import javax.swing.JPanel;
  8. import java.awt.MediaTracker;
  9. import java.awt.event.ActionEvent;
  10. import java.awt.event.ActionListener;
  11. import javax.swing.JDialog;
  12. import javax.swing.JMenu;
  13. import javax.swing.JMenuBar;
  14. import javax.swing.JMenuItem;
  15. import javax.swing.JOptionPane;
  16.  
  17. /**
  18.  * @author Nicolò
  19.  * La classe View estende JPanel e implementa il MouseListener. L'oggetto di tipo View che verrà creato riceverà
  20.  * come parametro un oggetto di tipo mazzo, poichè si dovrà occupare di visualizzarlo correttamente e dovrà occuparsi
  21.  * di rendere visibili tutte le azioni e le modifiche che verranno fatte su di esso tramite il MousePressed.
  22.  */
  23. public class View extends JPanel implements MouseListener{
  24.     /**
  25.          *
  26.          */
  27.         private static final long serialVersionUID = 1L;
  28.         private final Mazzo mazzo;
  29.         private JFrame frame;
  30.         private MediaTracker segugio;
  31.         private int preselezionata;
  32.         private Contatore contatore;
  33.         private int soluzione;
  34.         private int difficoltà;
  35.         private String posizione;
  36.         private int mosse;
  37.         private Classifica classifica;
  38.         private GUI_classifica fenetre;
  39.  
  40.     /**
  41.      * Costruttore della classe View, riceve come variabile un oggetto di tipo Mazzo (ovviamente con le carte al suo interno già mescolate).
  42.      * In seguito viene inizializzato il MediaTracker che si dovrà occupare di rendere visualizzabili le carti nel pannello, due variabili contatore
  43.      * e soluzione, utilizzate rispettivamente per contare il numero di mosse utilizzate per terminare il gioco
  44.      * e per vedere se il giocatore ha indovinato tutte le coppie.
  45.      * @param m
  46.      */
  47.     public View (Mazzo m){
  48.         mazzo = m;
  49.         segugio = new MediaTracker(this);
  50.         preselezionata = -1;
  51.         contatore = new Contatore(0);
  52.         soluzione = 0;
  53.         classifica = new Classifica();
  54.  
  55.  
  56.         // Viene creato il frame e due JOpitonPane per chiedere al giocatore la difficoltà a cui vuole giocare
  57.         // e per avveritrlo delle mosse a sua disposizione.
  58.         frame = new JFrame("Memory 1.0 - Nicolò Torreggiani ");
  59.         frame.setBounds(450, 200, 400, 420);
  60.         frame.setResizable(false);
  61.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  62.         frame.addMouseListener(this);
  63.         frame.getContentPane().add(this);
  64.         frame.setVisible(true);
  65.         Object[] options = {"Facile", "Media", "Difficile"};
  66.         int n = JOptionPane.showOptionDialog(frame, "Scegli la difficoltà:", "Difficoltà",
  67.         JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE,
  68.         null,options, options[1]);
  69.         switch(n){
  70.             case 0: difficoltà = 56; break;
  71.             case 1: difficoltà = 36; break;
  72.             case 2: difficoltà = 24; break;
  73.             default: System.exit(0);
  74.         }
  75.         JOptionPane.showMessageDialog(frame,"Ha inizio una nuova partita!!\nRicorda: hai un massimo di " + difficoltà + " mosse per poter scoprire tutte le coppie!!\nBuon divertimento!!","Nuova partita",JOptionPane.PLAIN_MESSAGE);
  76.  
  77.         Segui();
  78.         this.repaint();
  79.         }
  80.  
  81.     /**
  82.      * Funzione che si occupa di prendere tutte le immagini e disegnarle.
  83.      * @param g
  84.      */
  85.     @Override
  86.     public void paint(Graphics g) {
  87.  
  88.         int i = 0;
  89.         g.clearRect(0,0, 400, 400);
  90.  
  91.         for (int x = 0; x < 4; x++){
  92.             for(int y = 0; y < 4; y++){
  93.                 g.drawImage(mazzo.Carta(i).Immagine(), x*100 + 13, y*100, this);
  94.                 i++;
  95.             }
  96.         }
  97.     }
  98.  
  99.     @Override
  100.     /**
  101.      * Creata poichè si ricorre a dei componenti SWING.
  102.      */
  103.     public void paintComponent(Graphics g){
  104.         paint(g);
  105.     }
  106.  
  107.     /**
  108.      * Funzione il cui scopo e quello di prendere le carte disegnate passarle al Media Tracker che poi si occupera della visulizzazione.
  109.      * Prima viene passato il retro di tutte le carte, poi vengono volte a vengono passate le immagini dei vari semi. Infine tornano a essere volatate poichè
  110.      */
  111.     public void Segui(){
  112.         int id = 0;
  113.         for(int i = 0; i < 16; i++){
  114.             segugio.addImage(mazzo.Carta(i).Immagine(), id);
  115.             mazzo.Carta(i).volta();
  116.             id++;
  117.             segugio.addImage(mazzo.Carta(i).Immagine(), id);
  118.             mazzo.Carta(i).volta();
  119.             id++;
  120.         }
  121.         try{
  122.             segugio.waitForAll();
  123.         } catch(Exception e){}
  124.     }
  125.  
  126.     public void reset(){
  127.         mazzo.mescola();
  128.         for(int i = 0; i < 16; i++){
  129.             if(mazzo.Carta(i).Rimossa())
  130.                 mazzo.Carta(i).riassegna();
  131.         }
  132.  
  133.         contatore.setVal(0);
  134.         soluzione = 0;
  135.         Object[] options = {"Facile", "Media", "Difficile"};
  136.         int n = JOptionPane.showOptionDialog(frame, "Scegli la difficoltà:", "Difficoltà",
  137.         JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE,
  138.         null,options, options[1]);
  139.         switch(n){
  140.             case 0: difficoltà = 56; break;
  141.             case 1: difficoltà = 36; break;
  142.             case 2: difficoltà = 24; break;
  143.             default: System.exit(0);
  144.         }
  145.         JOptionPane.showMessageDialog(frame,"Ha inizio una nuova partita!!\nRicorda: hai un massimo di " + difficoltà + " mosse per poter scoprire tutte le coppie!!\nBuon divertimento!!","Nuova partita",JOptionPane.PLAIN_MESSAGE);
  146.  
  147.         this.repaint();
  148.  
  149.     }
  150.  
  151.     public void mouseClicked(MouseEvent e) {
  152.         int indice;
  153.         int x, y;
  154.         x = e.getX() / 100;
  155.         y = (e.getY()-25) / 100;
  156.         indice = 4 * x + y;
  157.  
  158.         // Controllo che non sia stata rimossa
  159.         if(!mazzo.Carta(indice).Rimossa()) {
  160.             // Controllo che sia la prima carta selezionata
  161.             if(preselezionata == -1) {
  162.                 preselezionata = indice;
  163.                 mazzo.Carta(indice).volta();
  164.                 contatore.inc();
  165.             } else{
  166.                 // Controllo che non sia la stessa carta
  167.                 if(preselezionata == indice){
  168.                     System.out.println("E' la stessa carta");
  169.                     //preselezionata = -1;
  170.                     //mazzo.Carta(indice).volta();
  171.                     //contatore.inc();
  172.                 } else {
  173.                     mazzo.Carta(indice).volta();
  174.                     this.paint(this.getGraphics());
  175.                     try {
  176.                         Thread.sleep(2000);
  177.                     } catch (InterruptedException ex) {
  178.                     }
  179.                     // Controllo che le due carte siano dello stesso tipo
  180.                     if(mazzo.Carta(preselezionata).Uguale(mazzo.Carta(indice))){
  181.                         System.out.println("Uguali");
  182.                         mazzo.Carta(preselezionata).rimuovi();
  183.                         mazzo.Carta(indice).rimuovi();
  184.                         preselezionata = -1;
  185.                         contatore.inc();
  186.                         soluzione++;
  187.                     } else{
  188.                         System.out.println("Diverse");
  189.                         mazzo.Carta(preselezionata).volta();
  190.                         mazzo.Carta(indice).volta();
  191.                         preselezionata = -1;
  192.                         contatore.inc();
  193.                     }
  194.                 }
  195.             }
  196.         }
  197.         this.repaint();
  198.         if((contatore.getVal()) > difficoltà){
  199.             JOptionPane.showMessageDialog(frame,"Hai perso!", "Fine Partita", JOptionPane.WARNING_MESSAGE);
  200.             JOptionPane option = new JOptionPane ("Giocare una nuova partita?", JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION);
  201.             JDialog dialog = option.createDialog(frame,"Nuova partita");
  202.             dialog.pack();
  203.             dialog.setVisible(true);
  204.             int n = ((Integer)option.getValue()).intValue();
  205.             switch(n){
  206.                 case 0: reset();break;
  207.                 case 1: System.exit(0);
  208.             }
  209.         }
  210.         if(soluzione == 8){
  211.             JOptionPane.showMessageDialog(frame,"Hai vinto in " + contatore.getVal() + " mosse!!", "Complimenti!!", JOptionPane.INFORMATION_MESSAGE);
  212.             posizione = JOptionPane.showInputDialog("Nome:");
  213.             mosse = contatore.getVal();
  214.             classifica.Aggiungi(new Record(posizione, mosse, null));
  215.             fenetre = new GUI_classifica(classifica);
  216.             fenetre.Mostra();
  217.             try {
  218.                  Thread.sleep(10000);
  219.             } catch (InterruptedException ex) {
  220.               }
  221.             fenetre.Nascondi();
  222.             System.out.println(posizione + "" + mosse);
  223.             JOptionPane option = new JOptionPane ("Giocare una nuova partita?", JOptionPane.QUESTION_MESSAGE, JOptionPane.YES_NO_OPTION);
  224.             JDialog dialog = option.createDialog(frame,"Nuova partita");
  225.             dialog.pack();
  226.             dialog.setVisible(true);
  227.             int n = ((Integer)option.getValue()).intValue();
  228.             switch(n){
  229.                 case 0: reset();break;
  230.                 case 1: System.exit(0);
  231.             }
  232.  
  233.         }
  234.  
  235.     }
  236.  
  237.     public void mousePressed(MouseEvent e) {}
  238.  
  239.     public void mouseReleased(MouseEvent e) {}
  240.  
  241.     public void mouseEntered(MouseEvent e) {}
  242.  
  243.     public void mouseExited(MouseEvent e) {}
  244.  
  245.  
  246. }

Contatore
Codice sorgente - presumibilmente Java
  1. package memory;
  2.  
  3. /**
  4.  * Classe che crea un oggetto in grado di essere incrementato, decrementato, settato a un valore diverso durante il suo utilizzo
  5.  * e che è in grado di fare un return del suo valore.
  6.  */
  7. public class Contatore {
  8.  
  9.     private int valore;
  10.  
  11.     public Contatore(){
  12.         valore = 0;
  13.     }
  14.  
  15.     public Contatore(int valore){
  16.         this.valore = valore;
  17.     }
  18.  
  19.     public void setVal(int valore){
  20.         this.valore = valore;
  21.     }
  22.  
  23.     public void inc(){
  24.         valore++;
  25.     }
  26.  
  27.     public int getVal(){
  28.         return valore;
  29.     }
  30. }

GUI_classifica
Codice sorgente - presumibilmente Java
  1. /*
  2.  * To change this template, choose Tools | Templates
  3.  * and open the template in the editor.
  4.  */
  5.  
  6. package memory;
  7.  
  8. // Oggetti grafici swing
  9. import javax.swing.JLabel;
  10. import javax.swing.JPanel;
  11. import javax.swing.JFrame;
  12. import javax.swing.SwingConstants;
  13.  
  14. // Oggetti awt
  15. import java.awt.Color;
  16. import java.awt.Font;
  17. import java.awt.GridLayout;
  18.  
  19. /**
  20.  *  Grafica per visualizzare i records.
  21.  *  <p>
  22.  *  La classe estende l'oggetto grafico JPanel per comodità (nessun metodo è sovrascritto).
  23.  *
  24.  *  @author Massimiliano Zanoli
  25.  *  @version 0.1
  26.  */
  27. public class GUI_classifica extends JPanel {
  28.         private static final long serialVersionUID = 1L;
  29.  
  30.         // Elementi grafici
  31.         private JFrame finestra;
  32.         private JLabel records[][];
  33.         private JLabel intestazione;
  34.         private JLabel autore;
  35.         private JLabel mosse;
  36.  
  37.         // Dati
  38.         private String font;
  39.         private int larghezza;
  40.         private int altezza;
  41.         private int numero;
  42.  
  43.         // Colori dei font
  44.         private Color titolo;
  45.         private Color dati;
  46.         private Color nome;
  47.         private Color sfondo;
  48.  
  49.         /**
  50.          * Il costruttore necessita di un'istanza della classe Struttura come riferimento, da cui ricavare i dati.
  51.          *
  52.          * @param riferimento La Struttura di riferimento.
  53.          */
  54.         public GUI_classifica(Classifica classifica) {
  55.  
  56.                 // Ottengo i dati
  57.                 font = "Comic Sans MS";
  58.                 numero = classifica.Numero();
  59.                 larghezza = 300;
  60.                 altezza = 300;
  61.  
  62.                 // Creo i colori
  63.                 titolo = new Color(0, 255, 0);
  64.                 dati = new Color(0, 128, 0);
  65.                 nome = new Color(64, 255, 192);
  66.                 sfondo = Color.WHITE;
  67.                 System.out.println("sono al gruppo 1");
  68.  
  69.                 // Creo la finestra
  70.                 finestra = new JFrame("Classifica");
  71.                 finestra.setBounds(0, 0, larghezza, altezza);
  72.                 finestra.setResizable(false);
  73.                 finestra.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
  74.                 finestra.getContentPane().add(this);
  75.                 System.out.println("sono al gruppo 2");
  76.  
  77.                 // Creo il titolo
  78.                 intestazione = new JLabel("Classifica");
  79.                 intestazione.setForeground(titolo);
  80.                 intestazione.setFont(new Font(font, Font.BOLD, 20));
  81.                 intestazione.setHorizontalAlignment(SwingConstants.CENTER);
  82.                 System.out.println("sono al gruppo 3");
  83.  
  84.                 autore = new JLabel("Giocatore:");
  85.                 autore.setForeground(dati);
  86.                 autore.setFont(new Font(font, Font.BOLD, 16));
  87.                 autore.setHorizontalAlignment(SwingConstants.CENTER);
  88.                 System.out.println("sono al gruppo 4");
  89.  
  90.                 mosse = new JLabel("Mosse:");
  91.                 mosse.setForeground(dati);
  92.                 mosse.setFont(new Font(font, Font.BOLD, 16));
  93.                 mosse.setHorizontalAlignment(SwingConstants.CENTER);
  94.                 System.out.println("sono al gruppo 5");
  95.  
  96.                 // Creo le etichette con i records
  97.  
  98.                 records = new JLabel[numero][2];
  99.                 for (int i = 0; i < numero; i++) {
  100.                         records[i][0] = new JLabel(classifica.Record(i).nome);
  101.                         records[i][1] = new JLabel("" + classifica.Record(i).mosse);
  102.                         System.out.println(records[i][0].getText());
  103.                         System.out.println(records[i][1].getText());
  104.  
  105.                         for (int c = 0; c < 2; c++) {
  106.                                 records[i][c].setForeground(nome);
  107.                                 records[i][c].setFont(new Font(font, Font.PLAIN, 16));
  108.                                 records[i][c].setHorizontalAlignment(SwingConstants.CENTER);
  109.                                
  110.                         }
  111.                 }
  112.                 System.out.println("sono al gruppo 6");
  113.  
  114.  
  115.                 // Messa a punto del pannello
  116.                 this.setBackground(Color.WHITE);
  117.                 this.setLayout(new GridLayout(numero + 2, 2));
  118.                 this.add(new JLabel());
  119.                 this.add(intestazione);
  120.                 this.add(new JLabel());
  121.                 this.add(autore);
  122.                 this.add(mosse);
  123.                 for (int r = 0; r < numero; r++) {
  124.                         for (int c = 0; c < 2; c++) {
  125.                                 this.add(records[r][c]);
  126.                         }
  127.                 }
  128.                 System.out.println("sono al gruppo 7");
  129.         }
  130.  
  131.         /**
  132.          * Visualizza la finestra dei records.
  133.          */
  134.         public void Mostra() {
  135.                 finestra.setVisible(true);
  136.         }
  137.  
  138.         /**
  139.          * Nasconde la finestra dei records.
  140.          */
  141.         public void Nascondi() {
  142.                 finestra.setVisible(false);
  143.         }
  144.  
  145. }


Nell'oggetto classifica segna un paio di errori ma non dovrebbero influire nel problema che ho io.



Yuppie ha allegato un file: Memory.zip (105033 bytes)
Clicca qui per scaricare il file
PM Quote