I found my old code!HEADmaster

57 files changed, 2417 insertions, 0 deletions

diff --git a/JBriscola/all_versions/0.3/0.3.1/src/Frame.java b/JBriscola/all_versions/0.3/0.3.1/src/Frame.java
new file mode 100755
index 0000000..21c4858
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/Frame.java
@@ -0,0 +1,523 @@
+/*
+Copyright 2009 Sebastiano Tronto <sebastiano@luganega.org>
+
+This file is part of JBriscola.
+
+    JBriscola is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    JBriscola is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with JBriscola; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+import javax.swing.*;
+import javax.sound.sampled.*;
+import java.io.*;
+import java.net.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class Frame extends JFrame {
+        
+        /* Booleana per determinare se disegnare il mazzo di carte o no (se
+         * è l'ultima mano). */
+        public static boolean mazzo;
+        
+        public static Main main;
+        
+        /* Menu, bottoni, pannelli e componenti vari. */
+        public static Pannello pannello;
+        public static JPanel pannello2;
+        public static JButton button;
+        public static JMenuBar barraMenu;
+        public static JMenu file, puntoInterrogativo;
+        public static JMenuItem nuovaPartita, nuovaPartitaAiTrenta, opzioni, esci, informazioni, punti, aggiornamenti, trucchi, tastiRapidi, briscola;
+        
+        /* Immagini delle carte. */
+        public static ImageIcon retro1, retro2, ultimaCarta;
+        public static ImageIcon[] giocata = new ImageIcon[2];
+        public static ImageIcon[] carteInMano = new ImageIcon[3];
+        public static ImageIcon[] carteCPU = new ImageIcon[3];
+        public static ImageIcon[] arrayCarteMescolate = new ImageIcon[40];
+        public static ImageIcon[][] arrayCarte = new ImageIcon[10][4];
+        
+        public Frame() {
+                
+                super( "Tronto's JBriscola " + main.version );
+                
+                mazzo = true;
+                main = new Main();
+                pannello = new Pannello();
+                pannello2 = new JPanel( new FlowLayout() );
+                
+                button = new JButton( main.stringaBottonePrendi );
+                button.addActionListener( new ActionListener() {
+                        
+                        /* Quando viene premuto il bottone per prendere/lasciare le carte,
+                         * valuta innanzitutto se il giocatore ha giocato, poi a chi
+                         * darle ed eventualmente, se è finita la partita, a caricare
+                         * il suono adatto. */
+                        public void actionPerformed( ActionEvent e ) {
+                                
+                                if ( giocata[0] != null && giocata[1] != null )
+                                        main.mano++;
+                                        
+                                try {
+                                        main.chiPrende();
+                                } catch ( Exception ex ) {
+                                        /* Avvisa di giocare una carta. */
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaPrimaGioca, "JBriscola " + main.version, JOptionPane.WARNING_MESSAGE );
+                                }
+                                
+                                /* Avvisa che si è arrivati alla quartultima mano. */
+                                if ( main.mano == 16 )
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaUltime4, "JBriscola " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                                
+                                /* Non disegna più la briscola e il mazzo se sono già state
+                                * pescate tutte le carte. */
+                                if ( main.mano == 17 ) {
+                                        mazzo = false;
+                                        ultimaCarta = null;
+                                        pannello.repaint();
+                                        Frame.this.repaint();
+                                }
+
+                                /* Mostra il punteggio e carica i suoni se è finita la partita. */
+                                if ( main.mano == 20 ||
+                                   ( main.aiTrenta &&
+                                 ( ( main.punteggio >= 30 || main.punteggioCPU >= 30 ) ) ) ) {
+                                
+                                        String titolo = "";
+                                        String suonoFinale = "";
+                                
+                                        if ( main.punteggio > main.punteggioCPU ) {
+                                                titolo = main.stringaVinto;
+                                                suonoFinale = "sounds/perso.wav";
+                                        }
+                                        if ( main.punteggio < main.punteggioCPU ) {
+                                                titolo = main.stringaPerso;
+                                                suonoFinale = "sounds/vinto.wav";
+                                        }
+                                        if ( main.punteggio == main.punteggioCPU ) {
+                                                titolo = main.stringaPareggio;
+                                                suonoFinale = "sounds/pareggio.wav";
+                                        }
+                                
+                                        if ( main.sound ) {
+                                                try {
+                                                        AudioFileFormat aff = AudioSystem.getAudioFileFormat( ClassLoader.getSystemResource( suonoFinale ) );
+                                                        AudioInputStream ais = AudioSystem.getAudioInputStream( ClassLoader.getSystemResource( suonoFinale ) );
+                                                        AudioFormat af = aff.getFormat();
+                                                        DataLine.Info info = new DataLine.Info( Clip.class, ais.getFormat(), ( (int) ais.getFrameLength() * af.getFrameSize() ) );
+                                                        Clip ol = ( Clip ) AudioSystem.getLine( info );
+                                                        ol.open(ais);
+                                                        ol.loop( 0 );
+                                                } catch ( Exception ex ) {
+                                                System.err.println( e );
+                                                }
+                                        }
+                                
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaGiocatore + main.punteggio + main.stringaComputer + main.punteggioCPU, titolo, JOptionPane.INFORMATION_MESSAGE );
+                                        
+                                        main.pulisciTavolo();
+                                        
+                                }
+                                if ( main.toccaAllaCPU )
+                                        if ( main.aiTrenta )
+                                                main.giocaCPUAiTrenta();
+                                        else
+                                                main.giocaCPU();
+                        }
+                } );
+                button.addKeyListener( new KeyAdapter() {
+                        /* Aggiunge il keyListener per le scorciatoie da tastiera. Dato
+                         * che il bottone prendi/lascia è l'unico componente effettivo
+                         * della finestra, avrà obbligatoriamente il focus ed è necessario
+                         * che sia lui a gestire gli eventi della tastiera. */
+                        public void keyReleased( KeyEvent key ) {
+
+                                if ( main.keys ) {
+                                        switch ( key.getKeyCode() ) {
+                                                case KeyEvent.VK_1:
+                                                        if ( mettiCarta( 231, 500 ) ) {
+                                                                if ( !main.CPUHaGiocato )
+                                                                        if ( main.aiTrenta )
+                                                                                main.giocaCPUAiTrenta();
+                                                                        else
+                                                                                main.giocaCPU();
+                                                        }
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_2:
+                                                        if ( mettiCarta( 301, 500 ) ) {
+                                                                if ( !main.CPUHaGiocato )
+                                                                        if ( main.aiTrenta )
+                                                                                main.giocaCPUAiTrenta();
+                                                                        else
+                                                                                main.giocaCPU();
+                                                        }
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_3:
+                                                        if ( mettiCarta( 371, 500 ) ) {
+                                                                if ( !main.CPUHaGiocato )
+                                                                        if ( main.aiTrenta )
+                                                                                main.giocaCPUAiTrenta();
+                                                                        else
+                                                                                main.giocaCPU();
+                                                        }
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F1:
+                                                        JOptionPane.showMessageDialog( Frame.this, main.stringaTasti2, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F2:
+                                                        if ( main.mano == 20 ) {
+                                                                main.aiTrenta = false;
+                                                                main.mischia();
+                                                                pannello.repaint();
+                                                                repaint();
+                                                        }
+                                                        else {
+                                                                int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroIniziare, "JBriscola " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                                                if ( selezione == JOptionPane.YES_OPTION ) {
+                                                                        main.aiTrenta = false;
+                                                                        main.mischia();
+                                                                        pannello.repaint();
+                                                                        repaint();
+                                                                }
+                                                        }
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F3:
+                                                        OptionFrame optionFrame = new OptionFrame();
+                                                        optionFrame.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
+                                                        optionFrame.setResizable( false );
+                                                        optionFrame.setAlwaysOnTop( true );
+                                                        optionFrame.setSize( 300, 200 );
+                                                        optionFrame.setLocation( (Toolkit.getDefaultToolkit().getScreenSize().width - 300) / 2, (Toolkit.getDefaultToolkit().getScreenSize().height - 150) / 2);
+                                                        optionFrame.setVisible( true );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F4:
+                                                        JOptionPane.showMessageDialog( Frame.this, main.stringaGiocatore + main.punteggio + main.stringaComputer + main.punteggioCPU, main.stringaPunteggio, JOptionPane.INFORMATION_MESSAGE );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F5:
+                                                        JOptionPane.showMessageDialog( Frame.this, main.stringaInformazioni2, main.stringaInformazioni, JOptionPane.PLAIN_MESSAGE );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F6:
+                                                        String latest = main.version;
+                                                        try {
+                                                                URL latestIs = new URL( "http://porkynator.altervista.org/jbriscola-latest.is" );
+                                                                BufferedReader latestIsReader = new BufferedReader( new InputStreamReader( latestIs.openStream() ) );
+                                                                latest = latestIsReader.readLine();
+                                                        } catch ( Exception ex ) {
+                                                                JOptionPane.showMessageDialog( Frame.this, main.stringaNoInternet, "JBriscola - " + main.version, JOptionPane.ERROR_MESSAGE );
+                                                        }
+                                                        if ( latest.equals( main.version ) )
+                                                                JOptionPane.showMessageDialog( Frame.this, main.stringaAggiornamentiNo, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                                                        else
+                                                                JOptionPane.showMessageDialog( Frame.this, main.stringaAggiornamentiSi + "\n" + main.version + " ==> " + latest + "\n\n" + main.stringaScarica, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F7:
+                                                        if ( main.mano == 20 ) {
+                                                                main.aiTrenta = true;
+                                                                main.mischia();
+                                                                pannello.repaint();
+                                                                repaint();
+                                                        }
+                                                        else {
+                                                                int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroIniziare, "JBriscola " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                                                if ( selezione == JOptionPane.YES_OPTION ) {
+                                                                        main.aiTrenta = true;
+                                                                        main.mischia();
+                                                                        pannello.repaint();
+                                                                        repaint();
+                                                                }
+                                                        }
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_F8:
+                                                        main.trucco( JOptionPane.showInputDialog( Frame.this, main.stringaInserisciCodice, "JBriscola - " + main.version, JOptionPane.PLAIN_MESSAGE ) );
+                                                        break;
+                                                        
+                                                case KeyEvent.VK_Q:
+                                                        int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroUscire, "JBriscola  " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                                        if ( selezione == JOptionPane.YES_OPTION )
+                                                                Frame.this.dispose();
+                                                        break;
+                                        }
+                                }
+                        }
+                } );
+                
+                barraMenu = new JMenuBar();
+                
+                file = new JMenu( "File" );
+                
+                nuovaPartita = new JMenuItem( main.stringaNuovaPartita );
+                nuovaPartita.addActionListener( new ActionListener() {
+                        /* Avvia una nuova partita, chiedendo prima conferma se ce n'è
+                         * già una in corso. */
+                        public void actionPerformed( ActionEvent e ) {
+                                if ( main.mano == 20 ) {
+                                        main.aiTrenta = false;
+                                        main.mischia();
+                                        pannello.repaint();
+                                        repaint();
+                                }
+                                
+                                else {
+                                        int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroIniziare, "JBriscola " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                        if ( selezione == JOptionPane.YES_OPTION ) {
+                                                main.aiTrenta = false;
+                                                main.mischia();
+                                                pannello.repaint();
+                                                repaint();
+                                        }
+                                }
+                        }
+                });
+                
+                nuovaPartitaAiTrenta = new JMenuItem( main.stringaNuovaPartitaAiTrenta );
+                nuovaPartitaAiTrenta.addActionListener( new ActionListener() {
+                        /* Avvia una nuova partita ai 30, chiedendo prima conferma se
+                         * ce n'è già una in corso. */
+                        public void actionPerformed( ActionEvent e ) {
+                                if ( main.mano == 20 ) {
+                                        main.aiTrenta = true;
+                                        main.mischia();
+                                        pannello.repaint();
+                                        repaint();
+                                }
+                                
+                                else {
+                                        int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroIniziare, "JBriscola " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                        if ( selezione == JOptionPane.YES_OPTION ) {
+                                                main.aiTrenta = true;
+                                                main.mischia();
+                                                pannello.repaint();
+                                                repaint();
+                                        }
+                                }
+                        }
+                });
+                
+                trucchi = new JMenuItem( main.stringaTrucchi );
+                trucchi.addActionListener( new ActionListener() {
+                        public void actionPerformed( ActionEvent e ) {
+                                /* Esegue il trucco */
+                                main.trucco( JOptionPane.showInputDialog( Frame.this, main.stringaInserisciCodice, "JBriscola - " + main.version, JOptionPane.PLAIN_MESSAGE ) );
+                        }
+                } );
+                
+                opzioni = new JMenuItem( main.stringaOpzioni );
+                opzioni.addActionListener( new ActionListener() {
+                        /* Apre una OptionFrame per modificare le opzioni. */
+                        public void actionPerformed( ActionEvent e ) {
+                                
+                                OptionFrame optionFrame = new OptionFrame();
+                                optionFrame.setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
+                                optionFrame.setResizable( false );
+                                optionFrame.setAlwaysOnTop( true );
+                                optionFrame.setSize( 300, 200 );
+                                optionFrame.setLocation( (Toolkit.getDefaultToolkit().getScreenSize().width - 300) / 2, (Toolkit.getDefaultToolkit().getScreenSize().height - 150) / 2);
+                                optionFrame.setVisible( true );
+                        }
+                });
+                
+                esci = new JMenuItem( main.stringaEsci );
+                esci.addActionListener( new ActionListener() {
+                        /* Ciede conferma prima di uscire. */
+                        public void actionPerformed( ActionEvent e ) {
+                                int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroUscire, "JBriscola  " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                if ( selezione == JOptionPane.YES_OPTION )
+                                        Frame.this.dispose();
+                        }
+                });
+                
+                file.add( nuovaPartita );
+                file.add( nuovaPartitaAiTrenta );
+                file.add( trucchi );
+                file.add( opzioni );
+                file.addSeparator();
+                file.add( esci );
+                
+                puntoInterrogativo = new JMenu( "?" );
+                
+                informazioni = new JMenuItem( main.stringaInformazioni );
+                informazioni.addActionListener( new ActionListener() {
+                        /* Visualizza le informazioni. */
+                        public void actionPerformed( ActionEvent e ) {
+                                JOptionPane.showMessageDialog( Frame.this, main.stringaInformazioni2, main.stringaInformazioni, JOptionPane.PLAIN_MESSAGE );
+                        }
+                } );
+                
+                tastiRapidi = new JMenuItem( main.stringaTasti );
+                tastiRapidi.addActionListener( new ActionListener() {
+                        /* Visualizza i tasti rapidi. */
+                        public void actionPerformed( ActionEvent e ) {
+                                JOptionPane.showMessageDialog( Frame.this, main.stringaTasti2, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                        }
+                } );
+                
+                briscola = new JMenuItem( main.stringaBriscola );
+                briscola.addActionListener( new ActionListener() {
+                        /* Visualizza il seme di briscola corrente. */
+                        public void actionPerformed( ActionEvent e ) {
+                                JOptionPane.showMessageDialog( Frame.this, main.stringaBriscola + ": " + main.semi[main.semeBriscola], "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                        }
+                });
+                
+                punti = new JMenuItem( main.stringaPunteggio );
+                punti.addActionListener( new ActionListener() {
+                        /* Visualizza il punteggio. */
+                        public void actionPerformed( ActionEvent e ) {
+                                JOptionPane.showMessageDialog( Frame.this, main.stringaGiocatore + main.punteggio + main.stringaComputer + main.punteggioCPU, main.stringaPunteggio, JOptionPane.INFORMATION_MESSAGE );
+                        }
+                } );
+                
+                aggiornamenti = new JMenuItem( main.stringaAggiornamenti );
+                aggiornamenti.addActionListener( new ActionListener() {
+                        /* Cerca aggiornamenti sul sito http://porkynator.altervista.org,
+                         * confrontando la versione del programma con quella scritta nel
+                         * file jbriscola-latest.is (online). */
+                        public void actionPerformed( ActionEvent e ) {
+                                String latest = main.version;
+                                try {
+                                        URL latestIs = new URL( "http://porkynator.altervista.org/jbriscola-latest.is" );
+                                        BufferedReader latestIsReader = new BufferedReader( new InputStreamReader( latestIs.openStream() ) );
+                                        latest = latestIsReader.readLine();
+                                } catch ( Exception ex ) {
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaNoInternet, "JBriscola - " + main.version, JOptionPane.ERROR_MESSAGE );
+                                }
+                                if ( latest.equals( main.version ) )
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaAggiornamentiNo, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                                else
+                                        JOptionPane.showMessageDialog( Frame.this, main.stringaAggiornamentiSi + "\n" + main.version + " ==> " + latest + "\n\n" + main.stringaScarica, "JBriscola - " + main.version, JOptionPane.INFORMATION_MESSAGE );
+                        }
+                } );
+                
+                puntoInterrogativo.add( punti );
+                puntoInterrogativo.add( briscola );
+                puntoInterrogativo.add( tastiRapidi );
+                puntoInterrogativo.add( informazioni );
+                puntoInterrogativo.add( aggiornamenti );
+                
+                barraMenu.add( file );
+                barraMenu.add( puntoInterrogativo );
+                
+                setJMenuBar( barraMenu );
+                
+                /* Inizializza le immagini del retro delle carte. */
+                retro1 = new ImageIcon( ClassLoader.getSystemResource( "img/retro1.jpg" ) );
+                retro2 = new ImageIcon( ClassLoader.getSystemResource( "img/retro2.jpg" ) );
+                
+                /* Inizializza tutte le immagini delle carte scorrendo l'array bidimensionale. */
+                for (int i = 0; i < 10; i++)
+                        for (int j = 0; j < 4; j++)
+                                arrayCarte[i][j] = new ImageIcon( ClassLoader.getSystemResource( "img/" + (i+1) + "-" + (j+1) + ".jpg" ) );
+                
+                /* Mischia le carte. */
+                main.mischia();
+                
+                /* Aggiunge i vari componenti. */
+                pannello2.add( button );
+                setLayout( new BorderLayout() );
+                add( pannello, BorderLayout.CENTER );
+                add( pannello2, BorderLayout.SOUTH );
+                
+                /* Chiama il metodo mettiCarta se l'utente clicca. */
+                addMouseListener(
+                        new MouseAdapter() {
+                                public void mouseClicked ( MouseEvent e ) {
+                                        if ( mettiCarta( e.getX(), e.getY() ) ) {
+                                                if ( !main.CPUHaGiocato )
+                                                        if ( main.aiTrenta )
+                                                                main.giocaCPUAiTrenta();
+                                                        else
+                                                                main.giocaCPU();
+                                        }
+                                }
+                        }
+                );
+                
+                /* Chiede conferma prima di uscire quando viene chiusa la finestra. */
+                addWindowListener(
+                        new WindowAdapter() {
+                                public void windowClosing( WindowEvent e ) {
+                                        int selezione = JOptionPane.showOptionDialog( Frame.this, main.stringaVuoiDavveroUscire, "JBriscola  " + main.version, JOptionPane.YES_NO_OPTION,  JOptionPane.QUESTION_MESSAGE, null, new String[] { main.stringaSi, main.stringaNo }, main.stringaNo );
+                                        if ( selezione == JOptionPane.YES_OPTION )
+                                                System.exit( 0 );
+                                }
+                        }
+                );
+        }
+        
+        /* Se il giocatore ha cliccato su una carta la gioca e riproduce un suono casuale. */
+        public boolean mettiCarta( int x, int y ) {
+                
+                if ( !main.toccaAllaCPU && giocata[0] == null ) {
+                        if ( main.sound && 
+                                ( ( x > 230 && x < 290 && y > 340 && y < 566 && carteInMano[0] != null ) ||
+                                  ( x > 300 && x < 360 && y > 340 && y < 566 && carteInMano[1] != null ) || 
+                                  ( x > 370 && x < 430 && y > 340 && y < 566 && carteInMano[2] != null ) ) ) {
+                                try {
+                                        
+                                        double a = Math.random() * 6;
+                                        int i = (int) a;
+                                        
+                                        AudioFileFormat aff = AudioSystem.getAudioFileFormat( ClassLoader.getSystemResource("sounds/" + i + ".wav") );
+                                        AudioInputStream ais = AudioSystem.getAudioInputStream( ClassLoader.getSystemResource("sounds/" + i + ".wav") );
+                                        AudioFormat af = aff.getFormat();
+                                        DataLine.Info info = new DataLine.Info( Clip.class, ais.getFormat(), ( (int) ais.getFrameLength() * af.getFrameSize() ) );
+                                        Clip ol = ( Clip ) AudioSystem.getLine( info );
+                                        
+                                        ol.open(ais);
+                                        ol.loop( 0 );
+                                        
+                                } catch ( Exception e ) {
+                                        System.err.println( e );
+                                }
+                        }
+                        
+                        if ( x > 230 && x < 290 && y > 340 && y < 566 && carteInMano[0] != null ) {
+                                giocata[0] = carteInMano[0];
+                                carteInMano[0] = null;
+                                pannello.repaint();
+                                return true;
+                        }
+                        
+                        if ( x > 300 && x < 360 && y > 340 && y < 566 && carteInMano[1] != null ) {
+                                giocata[0] = carteInMano[1];
+                                carteInMano[1] = null;
+                                pannello.repaint();
+                                return true;
+                        }
+                        
+                        if ( x > 370 && x < 430 && y > 340 && y < 566 && carteInMano[2] != null ) {
+                                giocata[0] = carteInMano[2];
+                                carteInMano[2] = null;
+                                pannello.repaint();
+                                return true;
+                        }
+                }
+                
+                return false;
+        }
+}
+
+
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/Main.java b/JBriscola/all_versions/0.3/0.3.1/src/Main.java
new file mode 100755
index 0000000..467e724
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/Main.java
@@ -0,0 +1,1637 @@
+/*
+Copyright 2009 Sebastiano Tronto <sebastiano@luganega.org>
+
+This file is part of JBriscola.
+
+    JBriscola is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    JBriscola is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with JBriscola; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+import java.io.*;
+import java.util.*;
+import javax.swing.*;
+import java.awt.*;
+
+public class Main {
+        
+        /*Costanti per i semi e i valori delle carte*/
+        public static final int COPPE = 0;
+        public static final int BASTONI = 1;
+        public static final int DENARI = 2;
+        public static final int SPADE = 3;
+        public static final int RE = 0; 
+        public static final int ASSO = 1;
+        public static final int DUE = 2;
+        public static final int TRE = 3;
+        public static final int QUATTRO = 4;
+        public static final int CINQUE = 5;
+        public static final int SEI = 6;
+        public static final int SETTE = 7;
+        public static final int FANTE = 8;
+        public static final int CAVALLO = 9;
+        
+        /* semeBriscola serve a determinare quale il seme di briscola (0 coppe,
+         * 1 bastoni, 2 denari, 3 spade).
+         * punteggio è il punteggio del giocatore, punteggioCPU quello della CPU
+         * mano tiene il conto della mano a cui si è arrivati.
+         * cartaDaPescare è la carta che la CPU deve raccogliere dal mazzo
+         * cartaDaGiocare (può assumere valore compraso tra 0 e 2) è la carta
+         * che la cpu deve giocare. */
+        public static int semeBriscola, punteggio, punteggioCPU, mano, cartaDaPescare, cartaDaGiocare;
+        
+        /* toccaAllaCPU determina se è il turno del computer o del giocatore,
+         * CPUHaGiocato se il computer ha già giocato in questo turno e
+         * haGiocatoPrima se la prima mossa del turno è stata del giocatore
+         * (true) o della CPU (false).
+         * aiTrenta serve per determinare se la partida che si sta giocando è
+         * normale o ai 30.
+         * carteScoperte serve se viene attivato il trucco per mostrare le
+         * carte della CPU.
+         * sound e keys riguardano le opzioni (souno si o no, tasti rapidi si
+         * o no) salvate nel file di configurazione. */
+        public static boolean toccaAllaCPU = false;
+        public static boolean CPUHaGiocato = false;
+        public static boolean haGiocatoPrima = true;
+        public static boolean aiTrenta = false;
+        public static boolean carteScoperte = false;
+        public static boolean sound = true;
+        public static boolean keys = true;
+        
+        /* frame è la finestra principale del gioco, color il colore dello sfondo.
+         * lang, soundString e keysString servono a leggere le opzioni dal file
+         * di configurazione. */
+        public static Frame frame;
+        public static Color color = new Color( 0, 150, 0 );
+        public static String lang, soundString, keysString;
+
+        /* Tutte le stringhe che vengono utilizzate durante il gioco sono
+         * inizializzate qui, per poter essere tradotte in altre lingue. */
+        public static String version = "0.3.1";
+        public static String semi[] = { "Bastoni", "Coppe", "Denari", "Spade" };
+        public static String stringaBriscola = "Briscola";
+        public static String stringaBottonePrendi = "Prendi/Lascia carte";
+        public static String stringaPrimaGioca = "Prima Gioca!";
+        public static String stringaUltime4 = "Ultima carta - Occhio alla briscola!";
+        public static String stringaVinto = "Hai Vinto!";
+        public static String stringaPerso = "Hai Perso";
+        public static String stringaPareggio = "Pareggio";
+        public static String stringaGiocatore = "Giocatore: ";
+        public static String stringaComputer = "\nComputer: ";
+        public static String stringaNuovaPartita = "Nuova Partita";
+        public static String stringaNuovaPartitaAiTrenta = "Nuova Partita Ai 30";
+        public static String stringaVuoiDavveroIniziare = "Vuoi davvero iniziare una nuova partita?";
+        public static String stringaVuoiDavveroUscire = "Vuoi davvero uscire?";
+        public static String stringaSi = "Si";
+        public static String stringaNo = "No";
+        public static String stringaOpzioni = "Opzioni...";
+        public static String stringaEsci = "Esci";
+        public static String stringaImpossibileConfigurare = "Impossibile modificare il file di configurazione.\nSegnalare il bug a: sebastiano@luganega.org\n\nEccezione:\n";
+        public static String stringaLingua = "Lingua";
+        public static String stringaAnnulla = "Annulla";
+        public static String stringaIt = "Italiano";
+        public static String stringaLa = "Latino";
+        public static String stringaBL = "Dialetto Bellunese";
+        public static String stringaBV = "Dialetto Basso Veneto";
+        public static String stringaEN = "Inglese";
+        public static String stringaModificaOpzioni = "Modifica Opzioni";
+        public static String stringaInformazioni = "Informazioni";
+        public static String stringaInformazioni2 = "JBriscola e' un gioco di briscola per pc scritto in java ideato\ne realizzato da Sebastiano Tronto. Il gioco viene rilasciato sotto licenza GNU/Gpl versione 2 o successive; questo permette\npotenzialmente a chiunque di modificare il gioco partendo dal codice sorgente del programma. Se non avete ricevuto i sorgenti\nassieme al gioco, potete richiedermeli con un'e-mail a sebastiano@luganega.org.\n\nJBriscola version " + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+        public static String stringaSuono = "Effetti Sonori";
+        public static String stringaPunteggio = "Punteggio";
+        public static String stringaSfondo = "Sfondo";
+        public static String stringaTasti = "Tasti rapidi";
+        public static String stringaAggiornamenti = "Cerca aggiornamenti";
+        public static String stringaTrucchi = "Trucchi";
+        public static String stringaInserisciCodice = "Inserisci il codice:";
+        public static String stringaTruccoAttivato = "Trucco attivato!";
+        public static String stringaTruccoSbagliato = "Trucco non valido";
+        public static String stringaCheCartaVuoi = "E allora che carta vuoi?";
+        public static String stringaAggiornamentiSi = "Aggiornamento disponibile: ";
+        public static String stringaAggiornamentiNo = "Nessun aggiornamento disponibile";
+        public static String stringaScarica = "E' possibile scaricare la versione più recente\ndal sito http://porkynator.altervista.org/programmi.html";
+        public static String stringaNoInternet = "Errore: nessuna connessione internet";
+        public static String stringaTasti2 = "1    Gioca la prima carta\n2    Gioca la seconda carta\n3    Gioca la terza carta\nF1   Visualizza questo messaggio\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+
+        public static void main( String args[] ) {
+                
+                /* Chiama il metodo settaOpzioni per leggere le impostazioni
+                 * dell'utente da un eventuale file di configurazione */
+                settaOpzioni();
+                
+                /* Crea la finestra principale del gioco e la posiziona al centro
+                 * dello schermo. */
+                frame = new Frame();
+                frame.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE );
+                frame.setResizable( false );
+                frame.setSize( 600, 600 );
+                frame.setLocation( (Toolkit.getDefaultToolkit().getScreenSize().width - 600) / 2, (Toolkit.getDefaultToolkit().getScreenSize().height - 600) / 2);
+                frame.setVisible( true );
+        }
+        
+        /* Algoritmo per mischiare il mazzo: prende due carte a caso e le
+         * inverte di posto, utilizzando una variabile aux. Ripete il procedimento
+         * per 391 volte. */
+        public void mischia() {
+                
+                ImageIcon aux;
+                
+                mano = 0;
+                punteggio = 0;
+                punteggioCPU = 0;
+                cartaDaPescare = 6;
+                frame.mazzo = true;
+                toccaAllaCPU = false;
+                CPUHaGiocato = false;
+                haGiocatoPrima = true;
+                frame.mazzo = true;
+                
+                /* Inizializza l'array di carte mescolate ordinato */
+                for ( int i = 0, k = 0; i < 10; i++ )
+                        for ( int j = 0; j < 4; j++, k++ )
+                                frame.arrayCarteMescolate[k] = frame.arrayCarte[i][j];
+                
+                /* Mescola le carte utilizzando il metodo sopra citato */
+                for ( int i = 0; i < 391; i++ ) {
+                        double a = Math.random() * 40;
+                        int x = (int) a;
+                        double b = Math.random() * 40;
+                        int y = (int) b;
+                        aux = frame.arrayCarteMescolate[x];
+                        frame.arrayCarteMescolate[x] = frame.arrayCarteMescolate[y];
+                        frame.arrayCarteMescolate[y] = aux;
+                }
+                
+                /* Imposta il seme della briscola */
+                semeBriscola = seme( frame.arrayCarteMescolate[39] );
+                
+                /* Distribuisce le carte */
+                frame.carteInMano[0] = frame.arrayCarteMescolate[0];
+                frame.carteInMano[1] = frame.arrayCarteMescolate[1];
+                frame.carteInMano[2] = frame.arrayCarteMescolate[2];
+                frame.carteCPU[0] = frame.arrayCarteMescolate[3];
+                frame.carteCPU[1] = frame.arrayCarteMescolate[4];
+                frame.carteCPU[2] = frame.arrayCarteMescolate[5];
+                frame.ultimaCarta = frame.arrayCarteMescolate[39];
+                frame.giocata[0] = null;
+                frame.giocata[1] = null;
+        }
+        
+        /* Viene chiamato a fine partita. */
+        public void pulisciTavolo() {
+                
+                punteggio = 0;
+                punteggioCPU = 0;
+                cartaDaPescare = 6;
+                toccaAllaCPU = false;
+                CPUHaGiocato = false;
+                haGiocatoPrima = true;
+                
+                frame.mazzo = false;
+                frame.ultimaCarta = null;
+                for ( int i = 0; i < 3; i++ ) {
+                        frame.carteCPU[i] = null;
+                        frame.carteInMano[i] = null;
+                }
+                
+                frame.pannello.repaint();
+                frame.repaint();
+                
+        }
+        
+        /* Fa giocare la CPU. Questo metodo contiene l'intelligenza artificiale
+         * del gioco. Ho preferito non commentare molto il corpo del metodo per
+         * due motivi; il primo è che abbastanza intuitivo: basta sapere che i
+         * vari metodi vaiLiscio(), vaiTaglio() ecc... tentano di fare ciò che
+         * ovviamente dice il loro nome, se ci riescono restituiscono true,
+         * in caso contrario false.*/
+        public void giocaCPU() {
+                
+                /* Nelle prime 16 mani ragiona in maniera diversa*/
+                if ( mano < 16 ) {
+                        
+                        /* Valuta cosa fare se il giocatore non ha ancora giocato. */
+                        if ( frame.giocata[0] == null ) {
+                                if ( vaiPunti() );
+                                else if ( vaiLiscio() );
+                                else if ( vaiTaglio() );
+                                else if ( vaiBriscolaAlta() );
+                                else if ( vaiCarico() );
+                                else if ( vaiTre() );
+                                else if ( vaiAsso() );
+                                else;
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( haLisciato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoPunti() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haTagliato() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoBriscolaAlta() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoTre() ) {
+                                        if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoAsso() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                } else if ( haCaricato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                }
+                        }
+                }
+                
+                /* Nella penultima mano (prima di pescare l'ultima carta) */
+                else if ( mano == 16 ) {
+                        
+                        /* Valuta cosa fare se il giocatore non ha ancora giocato. */
+                        if ( frame.giocata[0] == null ) {
+                                if ( valore( frame.ultimaCarta ) == TRE || valore( frame.ultimaCarta ) == ASSO ) {
+                                        if ( vaiCarico() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiAsso() );
+                                        else;
+                                } else {
+                                        if ( vaiPunti() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiAsso() );
+                                        else;
+                                }
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( valore( frame.ultimaCarta ) == TRE || valore( frame.ultimaCarta ) == ASSO ) {
+                                        if ( haCaricato() ) {
+                                                if ( vaiSopra() );
+                                                else if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiAsso() );
+                                                else if ( vaiCarico() );
+                                        }
+                                } else {
+                                        if ( haLisciato() ) {
+                                                if ( vaiSopra() );
+                                                else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                                else if ( vaiAsso() );
+                                        } else if ( haMessoPunti() ) {
+                                                if ( vaiSopra() );
+                                                else if ( vaiLiscio() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                                else if ( vaiAsso() );
+                                        } else if ( haTagliato() ) {
+                                                if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                                else if ( vaiAsso() );
+                                        } else if ( haMessoBriscolaAlta() ) {
+                                                if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                                else if ( vaiAsso() );
+                                        } else if ( haMessoTre() ) {
+                                                if ( vaiAsso() );
+                                                else if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                        } else if ( haMessoAsso() ) {
+                                                if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiCarico() );
+                                                else if ( vaiTre() );
+                                        } else if ( haCaricato() ) {
+                                                if ( vaiSopra() );
+                                                else if ( vaiTre() );
+                                                else if ( vaiBriscolaAlta() );
+                                                else if ( vaiAsso() );
+                                                else if ( vaiTaglio() );
+                                                else if ( vaiLiscio() );
+                                                else if ( vaiPunti() );
+                                                else if ( vaiCarico() );
+                                        }
+                                }
+                        }
+                        
+                } else if ( mano == 17 ) {
+                        
+                        /* Valuta cosa fare se il giocatore non ha ancora giocato. */
+                        if ( frame.giocata[0] == null ) {
+                                if ( hoAsso() ) {
+                                        if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiCarico() );
+                                } else {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                }
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( haLisciato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoPunti() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haTagliato() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoBriscolaAlta() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoTre() ) {
+                                        if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoAsso() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                } else if ( haCaricato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                }
+                        }
+                        
+                } else if ( mano == 18 ) {
+                        
+                        /* Valuta cosa fare se il giocatore non ha ancora giocato. */
+                        if ( frame.giocata[0] == null ) {
+                                if ( vaiAsso() );
+                                else if ( vaiCarico() );
+                                else if ( vaiBriscolaAlta() );
+                                else if ( vaiTaglio() );
+                                else if ( vaiPunti() );
+                                else if ( vaiLiscio() );
+                                else if ( vaiTre() );
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( haLisciato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoPunti() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haTagliato() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoBriscolaAlta() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiAsso() );
+                                } else if ( haMessoTre() ) {
+                                        if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoAsso() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                } else if ( haCaricato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                }
+                        }
+                        
+                /* All'ultima mano è inutile ragionare, dato che ha una sola carta */
+                } else {
+                        if ( vaiTre() );
+                        else if ( vaiBriscolaAlta() );
+                        else if ( vaiAsso() );
+                        else if ( vaiTaglio() );
+                        else if ( vaiLiscio() );
+                        else if ( vaiPunti() );
+                        else if ( vaiCarico() );
+                }
+                
+                /* Gioca la carta e aggiorna la finestra con il metodo repaint() */
+                frame.giocata[1] = frame.carteCPU[cartaDaGiocare];
+                frame.carteCPU[cartaDaGiocare] = null;
+                frame.pannello.repaint();
+                
+                CPUHaGiocato = true;
+                
+                if ( frame.giocata[0] == null )
+                        toccaAllaCPU = false;
+        }
+        
+        /* Fa giocare una partita ai 30. È analogo al metodo precedente, cambia
+         * solo la tecnica di gioco, quindi non è commentato. */
+        public void giocaCPUAiTrenta() {
+                
+                if ( punteggio <= 20 ) {
+                        
+                        if ( frame.giocata[0] == null ) {
+                                if ( vaiPunti() );
+                                else if ( vaiLiscio() );
+                                else if ( vaiTaglio() );
+                                else if ( vaiBriscolaAlta() );
+                                else if ( vaiCarico() );
+                                else if ( vaiTre() );
+                                else if ( vaiAsso() );
+                                else;
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( haLisciato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoPunti() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiCarico() );
+                                } else if ( haTagliato() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoBriscolaAlta() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoTre() ) {
+                                        if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoAsso() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                } else if ( haCaricato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                }
+                        }
+                }
+                        
+                else {
+                        
+                        if ( frame.giocata[0] == null ) {
+                                if ( vaiLiscio() );
+                                else if ( vaiPunti() );
+                                else if ( vaiTaglio() );
+                                else if ( vaiBriscolaAlta() );
+                                else if ( vaiAsso() );
+                                else if ( vaiTre() );
+                                else if ( vaiCarico() );
+                                else;
+                        }
+                        
+                        /* Valuta cosa fare quando invece il giocatore ha giocato */
+                        else {
+                                if ( haLisciato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoPunti() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                } else if ( haTagliato() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoBriscolaAlta() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoTre() ) {
+                                        if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                } else if ( haMessoAsso() ) {
+                                        if ( vaiLiscio() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiCarico() );
+                                        else if ( vaiTre() );
+                                } else if ( haCaricato() ) {
+                                        if ( vaiSopra() );
+                                        else if ( vaiTre() );
+                                        else if ( vaiBriscolaAlta() );
+                                        else if ( vaiTaglio() );
+                                        else if ( vaiAsso() );
+                                        else if ( vaiLiscio() );
+                                        else if ( vaiPunti() );
+                                        else if ( vaiCarico() );
+                                }
+                        }
+                }
+                
+                /* Gioca la carta e aggiorna la finestra con il metodo repaint() */
+                frame.giocata[1] = frame.carteCPU[cartaDaGiocare];
+                frame.carteCPU[cartaDaGiocare] = null;
+                frame.pannello.repaint();
+                
+                CPUHaGiocato = true;
+                
+                if ( frame.giocata[0] == null )
+                        toccaAllaCPU = false;
+        }
+        
+        /* Determina se ha preso la CPU o il giocatore */
+        public void chiPrende() {
+
+                /* Chiama il metodo giocatorePrende( boolean giocatore ) con parametro
+                 * true se ha preso il giocatore, false se ha preso la CPU */
+                giocatorePrende(   ( (seme( frame.giocata[0] ) == semeBriscola) && (seme( frame.giocata[1] ) != semeBriscola) )
+        || ( (seme( frame.giocata[0] ) == seme( frame.giocata[1] )) && laPrimaEPiuAlta( valore( frame.giocata[0] ), valore( frame.giocata[1] )) )
+        || ( (seme( frame.giocata[1] ) != semeBriscola) && (seme( frame.giocata[0] ) != seme( frame.giocata[1] )) && haGiocatoPrima ) );
+        }
+        
+        /* Confronta due carte per decidere quale ha più valore di presa.
+         * Restituisce true se è la prima, false se è la seconda */
+        public boolean laPrimaEPiuAlta( int prima, int seconda ) {
+                int a, b;
+                switch ( prima ) {
+                        case 0:
+                                a = 10;
+                                break;
+                        case 1:
+                                a = 12;
+                                break;
+                        case 3:
+                                a = 11;
+                                break;
+                        default:
+                                a = prima;
+                                break;
+                }
+                switch ( seconda ) {
+                        case 0:
+                                b = 10;
+                                break;
+                        case 1:
+                                b = 12;
+                                break;
+                        case 3:
+                                b = 11;
+                                break;
+                        default:
+                                b = seconda;
+                                break;
+                }
+                return a > b;
+        }
+        
+        /* Viene chiamato con parametro true se ha preso il giocatore, false se
+         * ha preso la CPU */
+        public void giocatorePrende( boolean giocatore ) {
+                if ( giocatore ) {
+                        toccaAllaCPU = CPUHaGiocato = false;
+                        haGiocatoPrima = true;
+                }
+                else {
+                        toccaAllaCPU = true;
+                        CPUHaGiocato = haGiocatoPrima = false;
+                }
+                daiPunti( giocatore );
+        }
+        
+        /* Da i punti (true al giocatore, false alla CPU) e fa pescare le carte*/
+        public void daiPunti( boolean giocatore ) {
+                
+                int punti = 0;
+                
+                switch( valore( frame.giocata[0] ) ) {
+                        case 0:
+                                punti += 4;
+                                break;
+                        case 1:
+                                punti += 11;
+                                break;
+                        case 3:
+                                punti += 10;
+                                break;
+                        case 8:
+                                punti += 2;
+                                break;
+                        case 9:
+                                punti += 3;
+                                break;
+                        default:
+                                break;
+                }
+                switch( valore( frame.giocata[1] ) ) {
+                        case 0:
+                                punti += 4;
+                                break;
+                        case 1:
+                                punti += 11;
+                                break;
+                        case 3:
+                                punti += 10;
+                                break;
+                        case 8:
+                                punti += 2;
+                                break;
+                        case 9:
+                                punti += 3;
+                                break;
+                        default:
+                                break;
+                }
+                
+                frame.giocata[0] = frame.giocata[1] = null;
+                
+                if ( giocatore ) {
+                        punteggio += punti;
+                        if ( mano < 18 ) {
+                                if ( frame.carteInMano[0] == null )
+                                        frame.carteInMano[0] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteInMano[1] == null )
+                                        frame.carteInMano[1] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteInMano[2] == null )
+                                        frame.carteInMano[2] = frame.arrayCarteMescolate[cartaDaPescare];
+                                cartaDaPescare++;
+                                if ( frame.carteCPU[0] == null )
+                                        frame.carteCPU[0] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteCPU[1] == null )
+                                        frame.carteCPU[1] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteCPU[2] == null )
+                                        frame.carteCPU[2] = frame.arrayCarteMescolate[cartaDaPescare];
+                                cartaDaPescare++;
+                        }
+                }
+                
+                else {
+                        punteggioCPU += punti;
+                        if ( mano < 18 ) {
+                                if ( frame.carteCPU[0] == null )
+                                        frame.carteCPU[0] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteCPU[1] == null )
+                                        frame.carteCPU[1] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteCPU[2] == null )
+                                        frame.carteCPU[2] = frame.arrayCarteMescolate[cartaDaPescare];
+                                cartaDaPescare++;
+                                if ( frame.carteInMano[0] == null )
+                                        frame.carteInMano[0] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteInMano[1] == null )
+                                        frame.carteInMano[1] = frame.arrayCarteMescolate[cartaDaPescare];
+                                if ( frame.carteInMano[2] == null )
+                                        frame.carteInMano[2] = frame.arrayCarteMescolate[cartaDaPescare];
+                                cartaDaPescare++;
+                        }
+                }
+                
+                /* Aggiorna la finestra */
+                frame.pannello.repaint();
+                frame.repaint();
+        }
+        
+        /* Vari metodi che determinano che tipo di carta ha giocato il giocatore.*/
+        public boolean haLisciato() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) != semeBriscola) &&
+                                 (valore( frame.giocata[0] ) != RE ) && (valore( frame.giocata[0] ) != ASSO ) &&
+                                 (valore( frame.giocata[0] ) != TRE ) && (valore( frame.giocata[0] ) < FANTE ) );
+        }
+        
+        public boolean haMessoPunti() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) != semeBriscola) &&
+                                 ( (valore( frame.giocata[0] ) == RE ) || (valore( frame.giocata[0] ) == FANTE ) ||
+                                 (valore( frame.giocata[0] ) == CAVALLO ) ) );
+        }
+                
+        public boolean haTagliato() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) == semeBriscola) &&
+                                 (valore( frame.giocata[0] ) == RE) && (valore( frame.giocata[0] ) != ASSO) &&
+                                 (valore( frame.giocata[0] ) == TRE) && (valore( frame.giocata[0] ) <= SETTE) );
+        }
+        
+        public boolean haMessoBriscolaAlta() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) == semeBriscola) &&
+                                 ( (valore( frame.giocata[0] ) == RE ) || (valore( frame.giocata[0] ) == FANTE ) ||
+                                 (valore( frame.giocata[0] ) == CAVALLO ) ) );
+        }
+        
+        public boolean haMessoTre() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) == semeBriscola) &&
+                                 (valore( frame.giocata[0] ) == TRE) );
+        }
+        
+        public boolean haMessoAsso() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) == semeBriscola) &&
+                                 (valore( frame.giocata[0] ) == ASSO) );
+        }
+        
+        public boolean haCaricato() {
+                return ( (frame.giocata[0] != null) && (seme( frame.giocata[0] ) != semeBriscola) &&
+                                 ( (valore( frame.giocata[0] ) == ASSO) || (valore( frame.giocata[0] ) == TRE) ) );
+        }
+        
+        /* I metodi seguenti cercano di andare liscio - dare punti - mettere
+         * un taglio - ecc... e restituiscono true se hanno avuto successo,
+         * false altrimenti. */
+        public boolean vaiLiscio() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) &&
+                                         (valore( frame.carteCPU[i] ) != RE) && (valore( frame.carteCPU[i] ) != ASSO) &&
+                                         (valore( frame.carteCPU[i] ) != TRE) && (valore( frame.carteCPU[i] ) < FANTE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        
+        public boolean vaiPunti() {
+                /* Cerca di dare punti, cercando di darne il meno possibile (meglio
+                 * un fante di re). */
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) && (valore( frame.carteCPU[i] ) == FANTE ) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) && (valore( frame.carteCPU[i] ) == CAVALLO ) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) && (valore( frame.carteCPU[i] ) == RE ) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiTaglio() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( seme( frame.carteCPU[i] ) == semeBriscola &&
+                                         (valore( frame.carteCPU[i] ) != RE) && (valore( frame.carteCPU[i] ) != ASSO) &&
+                                         (valore( frame.carteCPU[i] ) != TRE) && (valore( frame.carteCPU[i] ) < FANTE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiBriscolaAlta() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) && (valore( frame.carteCPU[i] ) == FANTE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) && (valore( frame.carteCPU[i] ) == CAVALLO) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) && (valore( frame.carteCPU[i] ) == RE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiTre() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( seme( frame.carteCPU[i] ) == semeBriscola && (valore( frame.carteCPU[i] ) == TRE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiAsso() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( seme( frame.carteCPU[i] ) == semeBriscola && (valore( frame.carteCPU[i] ) == ASSO) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiCarico() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) && (valore( frame.carteCPU[i] ) == TRE) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) && (valore( frame.carteCPU[i] ) == ASSO) ) {
+                                        cartaDaGiocare = i;
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean vaiSopra() {
+                /* Innanzitutto controlla se il giocatore ha giocato (non dovrebbe
+                 * essere possibile, in quanto quando questo metodo viene chiamato
+                 * tale condizione è già stata verificata, ma è sempre meglio un
+                 * controllo in più che uno in meno) e restituisce false in caso
+                 * contrario */
+                if ( frame.giocata[0] == null )
+                        return false;
+                        
+                /* Tre variabili intere che serviranno a valutare quali delle tre
+                 * carte è meglio giocare, se più di una può andare sopra. */
+                int a = -1;
+                int b = -1;
+                int c = -1;
+                
+                /* Tre booleane che verificano quali delle tre carte possono
+                 * andare sopra. */
+                boolean laPrimaPuoAndareSopra = false;
+                boolean laSecondaPuoAndareSopra = false;
+                boolean laTerzaPuoAndareSopra = false;
+                
+                /* Se il giocatore ha giocato un asso, restituisce direttamente false. */
+                if ( valore( frame.giocata[0] ) == ASSO )
+                        return false;
+                
+                /* Valuta quali delle tre carte possono andare sopra, dopo essersi
+                 * accertato di averle: nelle ultime mani non si hanno tutte le carte
+                 * in mano, e noi non vogliamo una NullPointerException sul più bello
+                 * di una partita, vero?! */
+                if ( frame.carteCPU[0] != null ) {
+                        a = valore( frame.carteCPU[0] );
+                        if ( (seme( frame.carteCPU[0] ) == seme( frame.giocata[0] )) && laPrimaEPiuAlta( a, valore( frame.giocata[0] ) ) )
+                                laPrimaPuoAndareSopra = true;
+                }
+                
+                if ( frame.carteCPU[1] != null ) {      
+                        b = valore( frame.carteCPU[1] );
+                        if ( (seme( frame.carteCPU[1] ) == seme( frame.giocata[0] )) && laPrimaEPiuAlta( b, valore( frame.giocata[0] ) ) )
+                                laSecondaPuoAndareSopra = true;
+                }
+                
+                if ( frame.carteCPU[2] != null ) {
+                        c = valore( frame.carteCPU[2] );
+                        if ( (seme( frame.carteCPU[2] ) == seme( frame.giocata[0] )) && laPrimaEPiuAlta( c, valore( frame.giocata[0] ) ) )
+                                laTerzaPuoAndareSopra = true;
+                }
+                
+                /* Se nessuna carta può andare sopra, restituisce false. Se una
+                 * sola delle tre può andare sopra la imposta come carta da giocare. */
+                if ( !laPrimaPuoAndareSopra && !laSecondaPuoAndareSopra && !laTerzaPuoAndareSopra )
+                        return false;
+                else if ( laPrimaPuoAndareSopra && !laSecondaPuoAndareSopra && !laTerzaPuoAndareSopra )
+                        cartaDaGiocare = 0;
+                else if ( !laPrimaPuoAndareSopra && laSecondaPuoAndareSopra && !laTerzaPuoAndareSopra )
+                        cartaDaGiocare = 1;
+                else if ( !laPrimaPuoAndareSopra && !laSecondaPuoAndareSopra && laTerzaPuoAndareSopra )
+                        cartaDaGiocare = 2;
+                        
+                /* Se più di una carta può andare sopra, valuta quale è più alta. */
+                else if ( laPrimaPuoAndareSopra && laSecondaPuoAndareSopra && !laTerzaPuoAndareSopra )
+                        if ( laPrimaEPiuAlta( a, b ) )
+                                cartaDaGiocare = 0;
+                        else
+                                cartaDaGiocare = 1;
+                else if ( !laPrimaPuoAndareSopra && laSecondaPuoAndareSopra && laTerzaPuoAndareSopra )
+                        if ( laPrimaEPiuAlta( b, c ) )
+                                cartaDaGiocare = 1;
+                        else
+                                cartaDaGiocare = 2;
+                else if ( laPrimaPuoAndareSopra && !laSecondaPuoAndareSopra && laTerzaPuoAndareSopra )
+                        if ( laPrimaEPiuAlta( a, c ) )
+                                cartaDaGiocare = 0;
+                        else
+                                cartaDaGiocare = 2;
+                else if ( laPrimaPuoAndareSopra && laSecondaPuoAndareSopra && laTerzaPuoAndareSopra )
+                        if ( laPrimaEPiuAlta( a, b ) )
+                                if ( laPrimaEPiuAlta( a, c ) )
+                                        cartaDaGiocare = 0;
+                                else
+                                        cartaDaGiocare = 2;
+                        else
+                                if ( laPrimaEPiuAlta( b, c ) )
+                                        cartaDaGiocare = 1;
+                                else
+                                        cartaDaGiocare = 2;
+                
+                /* Controlla che la carta con cui sta cercando di andare sopra
+                 * sia una figura o un carico. Non vogliamo mica prendere delle
+                 * scartelle con delle scartelle, giusto?! */
+                if ( ( valore( frame.carteCPU[cartaDaGiocare] ) != RE ) && ( valore( frame.carteCPU[cartaDaGiocare] ) != ASSO ) &&
+                         ( valore( frame.carteCPU[cartaDaGiocare] ) != TRE ) && ( valore( frame.carteCPU[cartaDaGiocare] ) <= SETTE ) )
+                        return false;
+
+                return true;
+        }
+        
+        /* I metodi seguenti valutano le carte che la CPU ha in mano. */
+        public boolean hoCarico() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) != semeBriscola) &&
+                                         ( ( valore( frame.carteCPU[i] ) == ASSO ) || ( valore( frame.carteCPU[i] ) == TRE ) ) ) {
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean hoAsso() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) && (valore( frame.carteCPU[i] ) == ASSO ) ) {
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean hoTre() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) && (valore( frame.carteCPU[i] ) == TRE ) ) {
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean hoBriscolaAlta() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) &&
+                                         ( (valore( frame.carteCPU[i] ) == RE) || (valore( frame.carteCPU[i] ) == FANTE) || (valore( frame.carteCPU[i] ) == CAVALLO) ) ) {
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+        public boolean hoTaglio() {
+                for ( int i = 0; i < 3; i++ ) {
+                        if ( frame.carteCPU[i] != null ) {
+                                if ( (seme( frame.carteCPU[i] ) == semeBriscola) &&
+                                         (valore( frame.carteCPU[i] ) < FANTE ) && (valore( frame.carteCPU[i] ) != TRE )
+                                         && (valore( frame.carteCPU[i] ) != ASSO ) && (valore( frame.carteCPU[i] ) != RE ) ) {
+                                        return true;
+                                }
+                        }
+                }
+                
+                return false;
+        }
+
+        /* Restituisce il seme della carta passata come parametro */
+        public static int seme( ImageIcon carta ) {
+                char aux[] = carta.toString().toCharArray();
+                return aux[aux.length-5] - 49;
+        }
+
+        /* Restituisce il valore della carta */
+        public static int valore( ImageIcon carta ) {
+                char aux[] = carta.toString().toCharArray();
+                return aux[aux.length-7] - 48;
+        }
+        
+        /* I vari trucchi del gioco. */
+        public static void trucco( String trucco ) {
+                
+                byte[] truccoByte = trucco.getBytes();
+                char[] truccoChar = new char[ truccoByte.length ];
+                for ( int i = 0; i < truccoChar.length; i++ )
+                        truccoChar[i] = (char)truccoByte[i];
+                        
+                String attivato = stringaTruccoSbagliato;
+                
+                /* Carta che vuoi dove vuoi. Esempio: x251 sostituisce
+                 * la terza carta (2) con il 6 (5) di coppe (1). */
+                if ( truccoChar[0] == 'x' && truccoChar.length == 4 ) {
+                
+                        attivato = stringaTruccoAttivato;
+                        
+                        String aS = "" + truccoChar[1];
+                        String xS = "" + truccoChar[2];
+                        String yS = "" + truccoChar[3];
+                        
+                        int a, x, y;
+                        
+                        try {
+                                
+                                a = Integer.parseInt( aS );
+                                x = Integer.parseInt( xS );
+                                y = Integer.parseInt( yS );
+                                
+                                frame.carteInMano[a] = frame.arrayCarte[x][y];
+                                
+                        } catch ( Exception e ) {
+                                attivato = stringaTruccoSbagliato;
+                        }
+                }
+                
+                /* Mostra le carte del computer. */
+                if ( trucco.equalsIgnoreCase( "Kill Devil Hill" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        carteScoperte = true;
+                        
+                }
+                
+                /* Scambia le carte con il computer. */
+                if ( trucco.equalsIgnoreCase( "Darkside of Aquarius" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        ImageIcon aux = null;
+                        
+                        for ( int i = 0; i < 3; i++ ) {
+                                
+                                aux = frame.carteInMano[i];
+                                frame.carteInMano[i] = frame.carteCPU[i];
+                                frame.carteCPU[i] = aux;
+                                
+                        }
+                }
+                
+                /* Cambia il seme di briscola con uno a caso, senza dire quale.
+                 * L'ultima carta non cambia. È possibile comunque capire
+                 * qual'è la briscola dal menu ?->Briscola*/
+                if ( trucco.equalsIgnoreCase( "Change of Heart" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        semeBriscola = (int) ( Math.random() * 4 );
+                        
+                }
+                
+                /* Asso Tre e Re di Briscola tutti in mano (anche in caso di doppioni). */
+                if ( trucco.equalsIgnoreCase( "Tears of The Dragon" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        frame.carteInMano[0] = frame.arrayCarte[9][semeBriscola];
+                        frame.carteInMano[1] = frame.arrayCarte[2][semeBriscola];
+                        frame.carteInMano[2] = frame.arrayCarte[0][semeBriscola];
+                        
+                }
+                
+                /* Tre assi di briscola. */
+                if ( trucco.equalsIgnoreCase( "Navigate The Seas of The Sun" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        frame.carteInMano[0] = frame.arrayCarte[0][semeBriscola];
+                        frame.carteInMano[1] = frame.arrayCarte[0][semeBriscola];
+                        frame.carteInMano[2] = frame.arrayCarte[0][semeBriscola];
+                        
+                }
+                
+                /* Fa finire la partita al prossimo piglio. */
+                if ( trucco.equalsIgnoreCase( "Omega" ) ) {
+                        
+                        attivato = stringaTruccoAttivato;
+                        
+                        mano = 19;
+                        
+                }
+                
+                JOptionPane.showMessageDialog( frame, attivato, "JBriscola - " + version, JOptionPane.INFORMATION_MESSAGE );
+                frame.pannello.repaint();
+                frame.repaint();
+                
+        }
+        
+        /* Imposta le opzioni dell'utente cercando di leggerle dal file di configurazione. */
+        public static void settaOpzioni() {
+                
+                /* Impostazioni predefinite. */
+                lang = "it";
+                soundString = "suono=si";
+                keysString = "tasti=si";
+                int r = 0;
+                int g = 150;
+                int b = 0;
+                
+                /* Cerca di leggere il file per impostare le opzioni. */
+                Scanner scanner = null;
+                File file = new File( "JBriscolaConfig.txt" );
+                if ( file.exists() ) {
+                        try {
+                                scanner = new Scanner( file );
+                        } catch ( FileNotFoundException e ) { }
+                        try {
+                                lang = scanner.next();
+                                soundString = scanner.next();
+                                keysString = scanner.next();
+                                r = scanner.nextInt();
+                                g = scanner.nextInt();
+                                b = scanner.nextInt();
+                        } catch ( NoSuchElementException e ) { }
+                }
+                
+                /* Modifica le opzioni. */
+                if ( lang.equals( "it" ) ) {
+                        semi[0] = "Bastoni";
+                        semi[1] = "Coppe";
+                        semi[2] = "Denari";
+                        semi[3] = "Spade";
+                        stringaBriscola = "Briscola";
+                        stringaBottonePrendi = "Prendi/Lascia carte";
+                        stringaPrimaGioca = "Prima Gioca!";
+                        stringaUltime4 = "Ultima carta - Occhio alla briscola!";
+                        stringaVinto = "Hai Vinto!";
+                        stringaPerso = "Hai Perso";
+                        stringaPareggio = "Pareggio";
+                        stringaGiocatore = "Giocatore: ";
+                        stringaComputer = "\nComputer: ";
+                        stringaNuovaPartita = "Nuova Partita";
+                        stringaNuovaPartitaAiTrenta = "Nuova Partita Ai 30";
+                        stringaVuoiDavveroIniziare = "Vuoi davvero iniziare una nuova partita?";
+                        stringaVuoiDavveroUscire = "Vuoi davvero uscire?";
+                        stringaSi = "Si";
+                        stringaNo = "No";
+                        stringaOpzioni = "Opzioni...";
+                        stringaEsci = "Esci";
+                        stringaImpossibileConfigurare = "Impossibile modificare il file di configurazione.\nSegnalare il bug a: sebastiano@luganega.org\n\nEccezione:\n";
+                        stringaLingua = "Lingua";
+                        stringaAnnulla = "Annulla";
+                        stringaIt = "Italiano";
+                        stringaLa = "Latino";
+                        stringaBL = "Dialetto Bellunese";
+                        stringaBV = "Dialetto Basso Veneto";
+                        stringaEN = "Inglese";
+                        stringaModificaOpzioni = "Modifica Opzioni";
+                        stringaInformazioni = "Informazioni";
+                        stringaInformazioni2 = "JBriscola e' un gioco di briscola per pc scritto in java ideato\ne realizzato da Sebastiano Tronto. Il gioco viene rilasciato sotto licenza GNU/Gpl versione 2 o successive; questo permette\npotenzialmente a chiunque di modificare il gioco partendo dal codice sorgente del programma. Se non avete ricevuto i sorgenti\nassieme al gioco, potete richiedermeli con un'e-mail a sebastiano@luganega.org.\n\nJBriscola version" + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+                        stringaSuono = "Effetti sonori";
+                        stringaPunteggio = "Punteggio";
+                        stringaSfondo = "Sfondo";
+                        stringaTasti = "Tasti rapidi";
+                        stringaAggiornamenti = "Cerca aggiornamenti";
+                        stringaTrucchi = "Trucchi";
+                        stringaInserisciCodice = "Inserisci il codice:";
+                        stringaTruccoAttivato = "Trucco attivato!";
+                        stringaTruccoSbagliato = "Trucco non valido";
+                        stringaCheCartaVuoi = "E allora che carta vuoi?";
+                        stringaAggiornamentiSi = "Aggiornamento disponibile: ";
+                        stringaAggiornamentiNo = "Nessun aggiornamento disponibile";
+                        stringaScarica = "E' possibile scaricare la versione più recente\ndal sito http://porkynator.altervista.org/programmi.html";
+                        stringaNoInternet = "Errore: nessuna connessione internet";
+                        stringaTasti2 = "1    Gioca la prima carta\n2    Gioca la seconda carta\n3    Gioca la terza carta\nF1   Visualizza questo messaggio\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+                }
+                else if ( lang.equals( "la" ) ) {
+                        semi[0] = "BACULI";
+                        semi[1] = "CALICES";
+                        semi[2] = "DENARII";
+                        semi[3] = "GLADII";
+                        stringaBriscola = "BRISCOLA";
+                        stringaBottonePrendi = "CAPIS/RELINQVIS CHARTAS";
+                        stringaPrimaGioca = "ANTE CHARTAM PONE!";
+                        stringaUltime4 = "CHARTA POSTREMA - INTVERE BRISCOLAM!";
+                        stringaVinto = "VICISTI!";
+                        stringaPerso = "PERDIDISTI";
+                        stringaPareggio = "AEQVATIO!";
+                        stringaGiocatore = "LVSOR: ";
+                        stringaComputer = "\nCOMPVTER: ";
+                        stringaNuovaPartita = "NOVA LVSO";
+                        stringaNuovaPartitaAiTrenta = "NOVA LVSO XXX";
+                        stringaVuoiDavveroIniziare = "NOVAM LVSIONEM INCIPERE?";
+                        stringaVuoiDavveroUscire = "EXIRE?";
+                        stringaSi = "ID VOLO";
+                        stringaNo = "NOLO";
+                        stringaOpzioni = "OPTIONES...";
+                        stringaEsci = "EXIRE";
+                        stringaImpossibileConfigurare = "CONFIGVRATIONIS FILE SCRIBERE NON POTVI.\nERROREM ME CERTIOREM FACITE: sebastiano@luganega.org\n\nEXCEPTIO:\n";
+                        stringaLingua = "LINGVA";
+                        stringaAnnulla = "ABROGA";
+                        stringaIt = "ITALICA";
+                        stringaLa = "LATINA";
+                        stringaBL = "BELLUNI";
+                        stringaBV = "VENETIAE";
+                        stringaEN = "ANGLICVS";
+                        stringaModificaOpzioni = "OPTIONES NOVARE";
+                        stringaInformazioni = "INFORMATIONES";
+                        stringaInformazioni2 = "JBriscola EST LVDVM BRISCOLAE COMPVTERI, JAVA SCRIPTVM, EXCOGITATVM\nFACTVMQUE A SEBASTIANO TRONTO. IPSVM LUDVM REICITUR LICENTIA GNU/Gpl VERSIONE 2 AVT POSTERIORIBUS; ID\nOMNIBVS LVDVM MUTARE CODICE IPSIVS INCIPIENDO LICET. SI CODICES CUM\nLVDO NON PERVENIT, EOS POSCERE POTESTIS E-MAILE sebastiano@luganega.org.\n\nJBriscola version " + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+                        stringaSuono = "SONVS";
+                        stringaPunteggio = "NVMERI";
+                        stringaSfondo = "COLOR";
+                        stringaTasti = "TASTI RAPIDI";
+                        stringaAggiornamenti = "VERSIONEM RECENTIOREM QVAERERE";
+                        stringaTrucchi = "CODICES";
+                        stringaInserisciCodice = "CODICEM INSCRIBE:";
+                        stringaTruccoAttivato = "CODEX INCIPIVIT!";
+                        stringaTruccoSbagliato = "ERROR CODICIS";
+                        stringaCheCartaVuoi = "QUAM CHARTAM VOLIS?";
+                        stringaNoInternet = "ERROR: INTERNETIS CONIVCTIO NON EST";
+                        stringaAggiornamentiSi = "VERSIO RECENTIOR EST: ";
+                        stringaAggiornamentiNo = "VERSIO RECENTIOR NON EST";
+                        stringaScarica = "VERSIONEM RECENTIOREM CEPTA ESSE POTEST:\nhttp://porkynator.altervista.org/programmi.html";
+                        stringaTasti2 = "1    PONE CHARTAM PRIMAM\n2    PONE CHARTAM SECUNDAM\n3    PONE CHARTAM TERTIAM\nF1   HEAC INFORMATIONES\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+                }
+                if ( lang.equals( "bl" ) ) {
+                        semi[0] = "Bastoi";
+                        semi[1] = "Coppe";
+                        semi[2] = "Danari";
+                        semi[3] = "Spade";
+                        stringaBriscola = "Briscola";
+                        stringaBottonePrendi = "Cio' su/lasa le carte";
+                        stringaPrimaGioca = "Prima Duga!";
+                        stringaUltime4 = "Ultima carta - Ocio a la briscola!";
+                        stringaVinto = "Te ha vint!";
+                        stringaPerso = "Te ha pers";
+                        stringaPareggio = "Pari";
+                        stringaGiocatore = "Dugador: ";
+                        stringaComputer = "\nComputer: ";
+                        stringaNuovaPartita = "Taca n'altra partida";
+                        stringaNuovaPartitaAiTrenta = "Taca na partida ai 30";
+                        stringaVuoiDavveroIniziare = "Utu sul serio scuminziar n'altra partida?";
+                        stringaVuoiDavveroUscire = "Utu sul serio stusar su?";
+                        stringaSi = "Si";
+                        stringaNo = "No";
+                        stringaOpzioni = "Opzioni...";
+                        stringaEsci = "Stusa su";
+                        stringaImpossibileConfigurare = "No ghe ho riva' a scrivere al file de configurazion.\nMandeme na mail a: sebastiano@luganega.org\n\nEcezion:\n";
+                        stringaLingua = "Lengua";
+                        stringaAnnulla = "Annulla";
+                        stringaIt = "Italian";
+                        stringaLa = "Latin";
+                        stringaBL = "Dialeto de Belun";
+                        stringaBV = "Dialeto de la basa";
+                        stringaEN = "Inglese";
+                        stringaModificaOpzioni = "Modifica Opzioni";
+                        stringaInformazioni = "Informazioni";
+                        stringaInformazioni2 = "JBriscola le' an dugo de briscola par computer scrit in java, pensa' e realiza'\n da Sebastiano Tronto. Al dugo l'e' sotto licenza GNU/Gpl versione 2 o sucesive; questo ol dir che chi che ol\n(se l'e' bon) al pol modificar al dugo coi codici sorgenti del programa. Se no i ve ha dat i sorgenti\nasieme al dugo, pote' domandarmeli co na e-mail a sebastiano@luganega.org.\n\nJBriscola version " + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+                        stringaSuono = "Efeti sonori";
+                        stringaPunteggio = "Varda i punti";
+                        stringaSfondo = "Sfondo";
+                        stringaTasti = "Tasti rapidi";
+                        stringaAggiornamenti = "Varda se ghe ne' na version pi nova";
+                        stringaTrucchi = "Truchi";
+                        stringaInserisciCodice = "Scrivi al codice:";
+                        stringaTruccoAttivato = "Truco ativa'!";
+                        stringaTruccoSbagliato = "Truco sbaia'";
+                        stringaCheCartaVuoi = "Che carta utu alora?";
+                        stringaAggiornamentiSi = "Ghe ne' na version pi nova: ";
+                        stringaAggiornamentiNo = "No ghe ne na version pi nova";
+                        stringaScarica = "Te pol scaricar le version pi nova\ndal sito http://porkynator.altervista.org/programmi.html";
+                        stringaNoInternet = "Erore: no te se su internet";
+                        stringaTasti2 = "1    Duga la prima carta\n2    Duga la seconda carta\n3    Duga la terza carta\nF1   Tasti rapidi\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+                }
+                if ( lang.equals( "bv" ) ) {
+                        semi[0] = "Bastoni";
+                        semi[1] = "Coppe";
+                        semi[2] = "Danari";
+                        semi[3] = "Spade";
+                        stringaBriscola = "Briscola";
+                        stringaBottonePrendi = "Ciapa su/lasa e carte";
+                        stringaPrimaGioca = "Prima Zuga!";
+                        stringaUltime4 = "Ultima carta - Ocio a la briscola!";
+                        stringaVinto = "Ti ga vinto!";
+                        stringaPerso = "Ti ga perso";
+                        stringaPareggio = "Pari";
+                        stringaGiocatore = "Zugador: ";
+                        stringaComputer = "\nComputer: ";
+                        stringaNuovaPartita = "N'altra Partida";
+                        stringaNuovaPartitaAiTrenta = "Na Partida ai 30";
+                        stringaVuoiDavveroIniziare = "Ti vol sul serio scuminziar n'altra partida?";
+                        stringaVuoiDavveroUscire = "Ti vol sul serio stusar su?";
+                        stringaSi = "Si";
+                        stringaNo = "No";
+                        stringaOpzioni = "Opzioni...";
+                        stringaEsci = "Stusa su";
+                        stringaImpossibileConfigurare = "No ghe son riusito a scrivere al file de configurazione.\nMandeme na mail a: sebastiano@luganega.org\n\nEcezion:\n";
+                        stringaLingua = "Lengua";
+                        stringaAnnulla = "Annulla";
+                        stringaIt = "Italian";
+                        stringaLa = "Latin";
+                        stringaBL = "Dialeto Belumat";
+                        stringaBV = "Dialeto Veneto";
+                        stringaEN = "Inglese";
+                        stringaModificaOpzioni = "Modifica Opzioni";
+                        stringaInformazioni = "Informasioni";
+                        stringaInformazioni2 = "JBriscola xe an zugo de briscola par computer scrito in java, pensato e realisato\n da Sebastiano Tronto. Al zugo xe sotto licenza GNU/Gpl versione 2 o sucesive; questo vol dire che chi che\nvol (se xe bono) al pol modificare al zugo coi codici sorgenti del programa. Se no i ve ha dato i sorgenti\nasieme al zugo, pote' domandarmeli co na e-mail a sebastiano@luganega.org.\n\nJBriscola version " + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+                        stringaSuono = "Efeti sonori";
+                        stringaPunteggio = "Varda i punti";
+                        stringaSfondo = "Sfondo";
+                        stringaTasti = "Tasti rapidi";
+                        stringaAggiornamenti = "Varda se ghe xe na versione pi nova";
+                        stringaTrucchi = "Truchi";
+                        stringaInserisciCodice = "Scrivi al codice:";
+                        stringaTruccoAttivato = "Truco ativa'!";
+                        stringaTruccoSbagliato = "Truco sbaia'";
+                        stringaCheCartaVuoi = "Che carta utu alora?";
+                        stringaAggiornamentiSi = "Ghe xe na versione pi nova: ";
+                        stringaAggiornamentiNo = "No ghe xe na versione pi nova";
+                        stringaScarica = "Te pol scaricar le versione pi nova\ndal sito http://porkynator.altervista.org/programmi.html";
+                        stringaNoInternet = "Erore: no ti xe su internet";
+                        stringaTasti2 = "1    Zuga la prima carta\n2    Zuga la seconda carta\n3    Zuga la terza carta\nF1   Tasti rapidi\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+                }
+                if ( lang.equals( "en" ) ) {
+                        semi[0] = "Sticks";
+                        semi[1] = "Cups";
+                        semi[2] = "Golds";
+                        semi[3] = "Swords";
+                        stringaBriscola = "Briscola";
+                        stringaBottonePrendi = "Take/leave cards";
+                        stringaPrimaGioca = "Play your card before!";
+                        stringaUltime4 = "Last card - keep your eye on the briscola!";
+                        stringaVinto = "You won!";
+                        stringaPerso = "You lost";
+                        stringaPareggio = "Sixty - sixty!";
+                        stringaGiocatore = "Palyer: ";
+                        stringaComputer = "\nComputer: ";
+                        stringaNuovaPartita = "New Game";
+                        stringaNuovaPartitaAiTrenta = "New Game - 30 Points";
+                        stringaVuoiDavveroIniziare = "Do you really want to start a new game?";
+                        stringaVuoiDavveroUscire = "Do you really want to exit?";
+                        stringaSi = "Yes";
+                        stringaNo = "No";
+                        stringaOpzioni = "Options...";
+                        stringaEsci = "Exit";
+                        stringaImpossibileConfigurare = "Couldn't write to the configuration file.\nPlease report the bug to: sebastiano@luganega.org\n\nException:\n";
+                        stringaLingua = "Lang";
+                        stringaAnnulla = "Cancel";
+                        stringaIt = "Italian";
+                        stringaLa = "Latin";
+                        stringaBL = "Belluno dialect";
+                        stringaBV = "Venice dialect";
+                        stringaEN = "English";
+                        stringaModificaOpzioni = "Change options";
+                        stringaInformazioni = "Information";
+                        stringaInformazioni2 = "JBriscola is a briscola pc game written in java, meant\nand made by Sebastiano Tronto. The game is protected by the GNU/General public licence version 2 or later.\n\nJBriscola version" + version + "\nCopyright 2009 Sebastiano Tronto, license GNU/Gpl 2.0 or later\nE-mail: sebastiano@luganega.org";
+                        stringaSuono = "Sound";
+                        stringaPunteggio = "Score";
+                        stringaSfondo = "Background";
+                        stringaTasti = "Hot keys";
+                        stringaAggiornamenti = "Check updates";
+                        stringaTrucchi = "Cheats";
+                        stringaInserisciCodice = "Insert cheat:";
+                        stringaTruccoAttivato = "Cheat actived!";
+                        stringaTruccoSbagliato = "Wrong cheat";
+                        stringaCheCartaVuoi = "So what card do you want?";
+                        stringaAggiornamentiSi = "Update available: ";
+                        stringaAggiornamentiNo = "No updates available";
+                        stringaScarica = "You can get the latest version from the site\nhttp://porkynator.altervista.org/programmi.html";
+                        stringaNoInternet = "Error: no internet connection";
+                        stringaTasti2 = "1    Play the first card\n2    Play the second card\n3    Play the third card\nF1   Get this message\nF2   " + stringaNuovaPartita + "\nF3   " + stringaOpzioni + "\nF4   " + stringaPunteggio + "\nF5   " + stringaInformazioni + "\nF6   " + stringaAggiornamenti + "\nF7   " + stringaNuovaPartitaAiTrenta + "\nF8   " + stringaTrucchi + "\nq    " + stringaEsci;
+                }
+                sound = ( soundString.equals( "suono=si" ) );
+                keys = ( keysString.equals( "tasti=si" ) );
+                color = new Color( r, g, b );
+                if ( frame != null ) {
+                        frame.pannello.repaint();
+                        frame.pannello2.repaint();
+                        frame.repaint();
+                }
+        }
+}
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/OptionFrame.java b/JBriscola/all_versions/0.3/0.3.1/src/OptionFrame.java
new file mode 100755
index 0000000..d89745b
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/OptionFrame.java
@@ -0,0 +1,169 @@
+/*
+Copyright 2009 Sebastiano Tronto <sebastiano@luganega.org>
+
+This file is part of JBriscola.
+
+    JBriscola is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    JBriscola is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with JBriscola; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+import java.util.Formatter;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class OptionFrame extends JFrame {
+        
+        public static Main main = new Main();
+        public static Formatter formatter;
+        public static JButton ok, annulla, scegliColore;
+        public static JLabel lingua, sfondo;
+        public static JComboBox selezionaLingua;
+        public static JCheckBox suono, tastiRapidi;
+        public static JPanel[] pannello = new JPanel[6];
+        
+        public OptionFrame() {
+                
+                super( "JBriscola - " + main.stringaModificaOpzioni );
+                
+                ok = new JButton( "OK" );
+                ok.addActionListener( new ActionListener() {
+                        
+                        /* Quando le modifiche vengono confermate premendo ok, viene scritto
+                         * il file di configurazione (o aggiornato) se possibile, e modificate
+                         * le impostazioni attuali. */
+                        public void actionPerformed( ActionEvent e ) {
+                                
+                                try {
+                                        formatter = new Formatter( "JBriscolaConfig.txt" );
+                                } catch ( Exception ex ) {
+                                        JOptionPane.showMessageDialog( OptionFrame.this, main.stringaImpossibileConfigurare + ex, "JBriscola - " + main.version, JOptionPane.ERROR_MESSAGE );
+                                }
+                                
+                                String lang;
+                                
+                                switch ( selezionaLingua.getSelectedIndex() ) {
+                                        case 0:
+                                                lang = "it";
+                                                break;
+                                        case 1:
+                                                lang = "la";
+                                                break;
+                                        case 2:
+                                                lang = "bl";
+                                                break;
+                                        case 3:
+                                                lang = "bv";
+                                                break;
+                                        case 4:
+                                                lang = "en";
+                                                break;
+                                        default:
+                                                lang = "it";
+                                                break;
+                                }
+                                
+                                String suonosiono, tastisiono;
+                                
+                                if ( suono.isSelected() )
+                                        suonosiono = "suono=si";
+                                else
+                                        suonosiono = "suono=no";
+                                if ( tastiRapidi.isSelected() )
+                                        tastisiono = "tasti=si";
+                                else
+                                        tastisiono = "tasti=no";
+                                        
+                                formatter.format( lang );
+                                formatter.format( "\n" );
+                                formatter.format( suonosiono );
+                                formatter.format( "\n" );
+                                formatter.format( tastisiono );
+                                formatter.format( "\n" );
+                                formatter.format( main.color.getRed() + " " + main.color.getGreen() + " " + main.color.getBlue() );
+                                formatter.close();
+                                
+                                main.settaOpzioni();
+                                
+                                OptionFrame.this.dispose();
+                        }
+                });
+                
+                annulla = new JButton( main.stringaAnnulla );
+                annulla.addActionListener( new ActionListener() {
+                        /* Se l'utente annulla viene chiusa la finestra senza fare nulla. */
+                        public void actionPerformed( ActionEvent e ) {
+                                OptionFrame.this.dispose();
+                        }
+                });
+                
+                scegliColore = new JButton( " " );
+                scegliColore.setBackground( main.color );
+                scegliColore.addActionListener( new ActionListener() {
+                        /* Permette di scegliere il colore dello sfondo. */
+                        public void actionPerformed( ActionEvent e ) {
+                                Color colore = JColorChooser.showDialog( OptionFrame.this, "JBriscola " + main.version, main.color );
+                                if ( colore != null )
+                                        main.color = colore;
+                                OptionFrame.scegliColore.setBackground( main.color );
+                        }
+                } );
+                
+                /* Vengono impostati e disegnati i vari componenti. */
+                lingua = new JLabel( main.stringaLingua );
+                sfondo = new JLabel( main.stringaSfondo );
+                String[] lingueDaSelezionare = { main.stringaIt, main.stringaLa, main.stringaBL, main.stringaBV, main.stringaEN };
+                selezionaLingua = new JComboBox( lingueDaSelezionare );
+                int linguaPreselezionata = 0;
+                
+                if ( main.lang.equals( "it" ) )
+                        linguaPreselezionata = 0;
+                else if ( main.lang.equals( "la" ) )
+                        linguaPreselezionata = 1;
+                else if ( main.lang.equals( "bl" ) )
+                        linguaPreselezionata = 2;
+                else if ( main.lang.equals( "bv" ) )
+                        linguaPreselezionata = 3;
+                else if ( main.lang.equals( "en" ) )
+                        linguaPreselezionata = 4;
+                
+                selezionaLingua.setSelectedIndex( linguaPreselezionata );
+                suono = new JCheckBox( main.stringaSuono );
+                suono.setSelected( main.sound );
+                tastiRapidi = new JCheckBox( main.stringaTasti );
+                tastiRapidi.setSelected( main.keys );
+
+                pannello[0] = new JPanel( new GridLayout( 4, 1 ) );
+                pannello[1] = new JPanel( new FlowLayout() );
+                pannello[2] = new JPanel( new FlowLayout() );
+                pannello[3] = new JPanel( new FlowLayout() );
+                pannello[4] = new JPanel( new FlowLayout() );
+                pannello[5] = new JPanel( new FlowLayout() );
+                pannello[5].add( ok );
+                pannello[5].add( annulla );
+                pannello[4].add( sfondo );
+                pannello[4].add( scegliColore );
+                pannello[3].add( tastiRapidi );
+                pannello[2].add( suono );
+                pannello[1].add( lingua );
+                pannello[1].add( selezionaLingua );
+                pannello[0].add( pannello[1] );
+                pannello[0].add( pannello[2] );
+                pannello[0].add( pannello[3] );
+                pannello[0].add( pannello[4] );
+                add( pannello[0], BorderLayout.CENTER );
+                add( pannello[5], BorderLayout.SOUTH );
+        }
+}
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/Pannello.java b/JBriscola/all_versions/0.3/0.3.1/src/Pannello.java
new file mode 100755
index 0000000..ca9e9c6
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/Pannello.java
@@ -0,0 +1,88 @@
+/*
+Copyright 2009 Sebastiano Tronto <sebastiano@luganega.org>
+
+This file is part of JBriscola.
+
+    JBriscola is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    JBriscola is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with JBriscola; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+
+import javax.swing.*;
+import java.awt.*;
+
+/* Questa classe dispone semplicemente le carte
+ * sulla finestra e imposta la sfondo. */
+public class Pannello extends JPanel {
+        
+        public static Main main;
+        
+        public static Color color;
+        
+        public Pannello() {     }
+        
+        public void paint( Graphics g ) {
+                
+                super.paint( g );
+                
+                setBackground( main.color );
+                
+                if ( main.frame.ultimaCarta != null )
+                        main.frame.ultimaCarta.paintIcon( this, g, 50, 180 );
+                        
+                if ( main.frame.mazzo )
+                        main.frame.retro2.paintIcon( this, g, 17, 256 );
+                        
+                if ( main.carteScoperte ) {
+                        
+                        if ( main.frame.carteCPU[0] != null )
+                                main.frame.carteCPU[0].paintIcon( this, g, 230, 5 );
+                        
+                        if ( main.frame.carteCPU[1] != null )
+                                main.frame.carteCPU[1].paintIcon( this, g, 300, 5 );
+                        
+                        if ( main.frame.carteCPU[2] != null )
+                                main.frame.carteCPU[2].paintIcon( this, g, 370, 5 );
+                        
+                } else {
+                        
+                        if ( main.frame.carteCPU[0] != null )
+                                main.frame.retro1.paintIcon( this, g, 230, 5 );
+                                
+                        if ( main.frame.carteCPU[1] != null )
+                                main.frame.retro1.paintIcon( this, g, 300, 5 );
+                                
+                        if ( main.frame.carteCPU[2] != null )
+                                main.frame.retro1.paintIcon( this, g, 370, 5 );
+                
+                }
+                
+                if ( main.frame.carteInMano[0] != null )
+                        main.frame.carteInMano[0].paintIcon( this, g, 230, 340 );
+                        
+                if ( main.frame.carteInMano[1] != null )
+                        main.frame.carteInMano[1].paintIcon( this, g, 300, 340 );
+                        
+                if ( main.frame.carteInMano[2] != null )
+                        main.frame.carteInMano[2].paintIcon( this, g, 370, 340 );
+                        
+                if ( main.frame.giocata[0] != null )
+                        main.frame.giocata[0].paintIcon( this, g, 250, 200 );
+                        
+                if ( main.frame.giocata[1] != null )
+                        main.frame.giocata[1].paintIcon( this, g, 325, 150 );
+                        
+        }
+}
+
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/1-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/1-1.jpg
new file mode 100755
index 0000000..ae43510
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/1-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/1-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/1-2.jpg
new file mode 100755
index 0000000..3f7c75a
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/1-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/1-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/1-3.jpg
new file mode 100755
index 0000000..9e1ead7
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/1-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/1-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/1-4.jpg
new file mode 100755
index 0000000..710f879
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/1-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/10-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/10-1.jpg
new file mode 100755
index 0000000..9aba45a
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/10-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/10-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/10-2.jpg
new file mode 100755
index 0000000..037eeb7
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/10-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/10-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/10-3.jpg
new file mode 100755
index 0000000..8780b72
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/10-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/10-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/10-4.jpg
new file mode 100755
index 0000000..587dc0f
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/10-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/2-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/2-1.jpg
new file mode 100755
index 0000000..5dcb7db
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/2-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/2-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/2-2.jpg
new file mode 100755
index 0000000..ea9eeb7
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/2-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/2-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/2-3.jpg
new file mode 100755
index 0000000..8cb22dd
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/2-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/2-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/2-4.jpg
new file mode 100755
index 0000000..b3e7898
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/2-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/3-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/3-1.jpg
new file mode 100755
index 0000000..dcb435c
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/3-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/3-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/3-2.jpg
new file mode 100755
index 0000000..1e5b6ec
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/3-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/3-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/3-3.jpg
new file mode 100755
index 0000000..9202cfe
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/3-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/3-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/3-4.jpg
new file mode 100755
index 0000000..5436a8d
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/3-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/4-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/4-1.jpg
new file mode 100755
index 0000000..3bab6d5
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/4-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/4-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/4-2.jpg
new file mode 100755
index 0000000..b4901a6
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/4-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/4-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/4-3.jpg
new file mode 100755
index 0000000..d754ad8
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/4-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/4-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/4-4.jpg
new file mode 100755
index 0000000..3a54b96
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/4-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/5-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/5-1.jpg
new file mode 100755
index 0000000..3f7ba1f
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/5-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/5-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/5-2.jpg
new file mode 100755
index 0000000..fcacb75
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/5-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/5-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/5-3.jpg
new file mode 100755
index 0000000..ce32f9f
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/5-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/5-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/5-4.jpg
new file mode 100755
index 0000000..b86b09a
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/5-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/6-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/6-1.jpg
new file mode 100755
index 0000000..f90cd81
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/6-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/6-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/6-2.jpg
new file mode 100755
index 0000000..cf2a67a
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/6-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/6-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/6-3.jpg
new file mode 100755
index 0000000..2cd2fe2
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/6-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/6-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/6-4.jpg
new file mode 100755
index 0000000..73f410f
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/6-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/7-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/7-1.jpg
new file mode 100755
index 0000000..08cd397
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/7-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/7-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/7-2.jpg
new file mode 100755
index 0000000..a168ff8
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/7-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/7-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/7-3.jpg
new file mode 100755
index 0000000..5cda411
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/7-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/7-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/7-4.jpg
new file mode 100755
index 0000000..5d63229
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/7-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/8-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/8-1.jpg
new file mode 100755
index 0000000..a6faa7b
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/8-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/8-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/8-2.jpg
new file mode 100755
index 0000000..0d9edbb
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/8-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/8-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/8-3.jpg
new file mode 100755
index 0000000..91f8354
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/8-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/8-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/8-4.jpg
new file mode 100755
index 0000000..cc0089c
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/8-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/9-1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/9-1.jpg
new file mode 100755
index 0000000..be9c6bf
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/9-1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/9-2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/9-2.jpg
new file mode 100755
index 0000000..e25da4c
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/9-2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/9-3.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/9-3.jpg
new file mode 100755
index 0000000..cd384f8
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/9-3.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/9-4.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/9-4.jpg
new file mode 100755
index 0000000..441210e
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/9-4.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/Thumbs.db b/JBriscola/all_versions/0.3/0.3.1/src/img/Thumbs.db
new file mode 100755
index 0000000..d9b6bc5
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/Thumbs.db
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/carte.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/carte.jpg
new file mode 100755
index 0000000..838ffac
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/carte.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/retro1.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/retro1.jpg
new file mode 100755
index 0000000..9651b06
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/retro1.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/img/retro2.jpg b/JBriscola/all_versions/0.3/0.3.1/src/img/retro2.jpg
new file mode 100755
index 0000000..c5d3925
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/img/retro2.jpg
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/0.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/0.wav
new file mode 100755
index 0000000..67d9abd
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/0.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/1.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/1.wav
new file mode 100755
index 0000000..9357c97
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/1.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/2.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/2.wav
new file mode 100755
index 0000000..92b1541
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/2.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/3.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/3.wav
new file mode 100755
index 0000000..45a6e42
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/3.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/4.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/4.wav
new file mode 100755
index 0000000..1f7ec90
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/4.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/5.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/5.wav
new file mode 100755
index 0000000..3627f96
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/5.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/pareggio.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/pareggio.wav
new file mode 100755
index 0000000..ff978e6
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/pareggio.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/perso.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/perso.wav
new file mode 100755
index 0000000..a454ba4
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/perso.wav
diff --git a/JBriscola/all_versions/0.3/0.3.1/src/sounds/vinto.wav b/JBriscola/all_versions/0.3/0.3.1/src/sounds/vinto.wav
new file mode 100755
index 0000000..a6f3ac5
--- /dev/null
+++ b/JBriscola/all_versions/0.3/0.3.1/src/sounds/vinto.wav