[Java] Aiuto gestione turni briscola

[Groove89]

Ciao ragazzi, sto letteralmente impazzendo nel fare un progetto personale, ossia il gioco briscola. E' la prima volta che tento di programmare un gioco completo e mi sono reso conto di aver sviluppato un codice veramente incasinato e non so veramente come districarmi adesso. Il problema principale che sto incontrando è come GESTIRE I TURNI dei due giocatori (umano e computer).

Posto il codice delle classi principali (è molto lungo).

Classe Giocatore

package singleplayer;

import java.util.HashSet;
import carta.Carta;
import classifica.RecordClassifica;

public class Giocatore
{
	private String nome;
	private RecordClassifica dati;  //per la classifica
	private HashSet<Carta> carte;   //le carte in mano al giocatore
	
	public Giocatore(String nome) {
		this.nome = nome;
		dati = new RecordClassifica(nome);
		carte =  new HashSet<Carta>();
	}
	
	public int quanteCarte() {
		return carte.size();
	}
	
	public void setCarta(Carta c) {
		carte.add(c);
	}
	
	public void rimuoviCarta(Carta c) {
		carte.remove(c);
	}
	
	public String getNome() {
		return nome;
	}
	
	public String toString() {
		return "Giocatore: " + this.nome;
	}
	
	public HashSet<Carta> carte() {
		return carte;
	}
}

Classe GiocatoreElettronico

package singleplayer;

import java.util.HashSet;
import carta.Carta;

public class GiocatoreElettronico extends Giocatore {

	private HashSet<Carta> carte;
	
	public GiocatoreElettronico(String nome) {
		super(nome);
		carte = new HashSet<Carta>();
	}
	
	public int quanteCarte() {
		return carte.size();
	}
	
	public void setCarta(Carta c) {
		carte.add(c);
	}
	
	public void rimuoviCarta(Carta c) {
		carte.remove(c);
	}
 }

Classe Partita

package singleplayer;

import java.util.HashSet;
import classifica.RecordClassifica;
import carta.Carta;
import carta.Mazzo;

public class Partita
{
	private Giocatore giocatore;
	private Giocatore avversario;
	private Mazzo mazzo;
	private final Carta briscola;
	private RecordClassifica record;
	
	public Partita(Giocatore a, Giocatore b, RecordClassifica r) {
		this.giocatore = a;
		this.avversario = b;
		this.record = r;
		mazzo = new Mazzo();
		briscola = mazzo.getBriscola();
	}
	
	public RecordClassifica getRecordClassifica() {
		return record;
	}
	
	public Giocatore getGiocatore() {
		return giocatore;
	}
	
	public Giocatore getAvversario() {
		return avversario;
	}
	
	public Carta getBriscola() {
		return briscola;
	}
	
	public Mazzo getMazzo() {
		return mazzo;
	}
	
	public int carteRimanenti() {
		return mazzo.carteRimanenti();

	}
	
	public HashSet<Carta> distribuisciCarteGiocatore() {
		Carta a1 = mazzo.estrai();
		Carta a2 = mazzo.estrai();
		Carta a3 = mazzo.estrai();
		
		giocatore.setCarta(a1);
		giocatore.setCarta(a2);
		giocatore.setCarta(a3);
		
		HashSet<Carta> ret = new HashSet<Carta>();
		ret.add(a1);
		ret.add(a2);
		ret.add(a3);
		
		return ret;
	}

	public HashSet<Carta> distribuisciCarteAvversario() {
		Carta a1 = mazzo.estrai();
		Carta a2 = mazzo.estrai();
		Carta a3 = mazzo.estrai();
		
		giocatore.setCarta(a1);
		giocatore.setCarta(a2);
		giocatore.setCarta(a3);
		
		HashSet<Carta> ret = new HashSet<Carta>();
		ret.add(a1);
		ret.add(a2);
		ret.add(a3);
		
		return ret;
	}
	
	public Carta pescaGiocatore() {
		Carta c = mazzo.estrai();
		giocatore.setCarta(c);
		return c;
	}
	
	public Carta pescaAvversario() {
		Carta c = mazzo.estrai();
		avversario.setCarta(c);
		return c;
	}
	
	//Mossa del computer a seconda della Carta c
	public Carta giocaAvversario(Carta c) {
		Carta giocata = null;
		//imposterò una logica di gioco per inizializzare giocata...
		avversario.rimuoviCarta(giocata);
		return giocata;
	}
	
	public void giocaGiocatore(Carta c) {
		giocatore.rimuoviCarta(c);
	}
}

Classe GuiPartita

package gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import javax.swing.Box;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import singleplayer.Giocatore;
import singleplayer.Partita;
import carta.Carta;
import carta.Mazzo;
import classifica.RecordClassifica;

@SuppressWarnings("serial")
public class GuiPartita extends JFrame implements ActionListener
{
	private String url = "images/sfondotavolo.jpg";
	private MyPanel sfondo;

	private Object notifica;
	
	private Random random;
	
	private Partita p;
	
	private JPanel nord;
	private JPanel centro;
	private JPanel sud;
	
	private Box boxes[];
	
	private JLabel computer;
	private JLabel nG;
	
	//label che rappresentano le carte del computer
	private JLabel avvUno;
	private JLabel avvDue;
	private JLabel avvTre;
	
	//pulsanti che rappresentano le carte del giocatore
	private JButton primaCarta;
	private JButton secondaCarta;
	private JButton terzaCarta;
	
	//pulsante associato al mazzo
	private JButton labelMazzo;
	
	//label briscola
	private JButton buttonBriscola;
	
	//label carte rimanenti
	private JLabel carteRimanenti;
	
	//label carte giocate
	private JLabel cartaGiocata1;
	private JLabel cartaGiocata2;
	
	//turno dei giocatori
	boolean turnoGiocatore, turnoAvversario;
	
	public GuiPartita(String titolo, Partita p) {
		
		super(titolo);
		this.p = p;
		
		sfondo = new MyPanel(url);
		
		notifica = null;
		
		random = new Random(); 
		
		int turno = random.nextInt(2); //-> 0 se tocca al giocatore, 1 all'avversario
		
		if(turno==0)
			turnoGiocatore = true; //-> turnoMazziere vale true se è il giocatore a dover fare da mazziere, false altrimenti
		
		turnoAvversario = !turnoGiocatore; //-> Inizialmente è il turno di chi non fa il mazziere
		
		RecordClassifica record = p.getRecordClassifica();
		Giocatore giocatore = p.getGiocatore();
		Giocatore avversario = p.getAvversario();
		
		Container c = this.getContentPane();
		sfondo.setLayout(new BorderLayout());
		c.add(sfondo);
		
		boxes = new Box[3];
		
		boxes[0] = Box.createHorizontalBox();
		boxes[1] = Box.createHorizontalBox();
		boxes[2] = Box.createHorizontalBox();
		
		//ZONA NORD: AVVERSARIO
		
		computer = new JLabel("Computer");
		computer.setForeground(Color.WHITE);
		nord = new JPanel(new BorderLayout());
		nord.setOpaque(false);
		nord.add(computer, BorderLayout.NORTH);
		
		avvUno = new JLabel();
		avvUno.setPreferredSize(new Dimension(117,185));
		avvUno.setMinimumSize(new Dimension(117,185));
		avvUno.setMaximumSize(new Dimension(117,185));
		avvUno.setOpaque(true);
		avvDue = new JLabel();
		avvDue.setPreferredSize(new Dimension(117,185));
		avvDue.setMinimumSize(new Dimension(117,185));
		avvDue.setMaximumSize(new Dimension(117,185));
		avvDue.setOpaque(true);
		avvTre = new JLabel();
		avvTre.setPreferredSize(new Dimension(117,185));
		avvTre.setMinimumSize(new Dimension(117,185));
		avvTre.setMaximumSize(new Dimension(117,185));
		avvTre.setOpaque(true);
		
		boxes[0].setPreferredSize(new Dimension(745,229));
		boxes[0].add(Box.createRigidArea(new Dimension(330,190)));
		boxes[0].add(avvUno);
		boxes[0].add(Box.createRigidArea(new Dimension(25,185)));
		boxes[0].add(avvDue);
		boxes[0].add(Box.createRigidArea(new Dimension(25,185)));
		boxes[0].add(avvTre);
		boxes[0].add(Box.createRigidArea(new Dimension(25,185)));
		
		//ZONA SUD: GIOCATORE
		
		String nomeGiocatore = giocatore.getNome();
		String text = "Giocatore: " + nomeGiocatore;
		nG = new JLabel(text);
		nG.setForeground(Color.WHITE);
		sud = new JPanel(new BorderLayout());
		sud.setOpaque(false);
		sud.add(nG, BorderLayout.NORTH);
		
		primaCarta = new JButton();
		primaCarta.setPreferredSize(new Dimension(117,185));
		primaCarta.setMinimumSize(new Dimension(117,185));
		primaCarta.setMaximumSize(new Dimension(117,185));
		primaCarta.setOpaque(true);
		secondaCarta = new JButton();
		secondaCarta.setPreferredSize(new Dimension(117,185));
		secondaCarta.setMinimumSize(new Dimension(117,185));
		secondaCarta.setMaximumSize(new Dimension(117,185));
		secondaCarta.setOpaque(true);
		terzaCarta = new JButton();
		terzaCarta.setPreferredSize(new Dimension(117,185));
		terzaCarta.setMinimumSize(new Dimension(117,185));
		terzaCarta.setMaximumSize(new Dimension(117,185));
		terzaCarta.setOpaque(true);
		
		boxes[1].setPreferredSize(new Dimension(745,229));
		boxes[1].add(Box.createRigidArea(new Dimension(330,190)));
		boxes[1].add(primaCarta);
		boxes[1].add(Box.createRigidArea(new Dimension(25,185)));
		boxes[1].add(secondaCarta);
		boxes[1].add(Box.createRigidArea(new Dimension(25,185)));
		boxes[1].add(terzaCarta);
		boxes[1].add(Box.createRigidArea(new Dimension(25,185)));
		
		//ZONA CENTRALE
		
		centro = new JPanel(new BorderLayout());
		centro.setOpaque(false);
		carteRimanenti = new JLabel("Carte rimanenti: ");
		carteRimanenti.setForeground(Color.WHITE);
		centro.add(carteRimanenti, BorderLayout.SOUTH);
		
		labelMazzo = new JButton();
		labelMazzo.setPreferredSize(new Dimension(117,185));
		labelMazzo.setMinimumSize(new Dimension(117,185));
		labelMazzo.setMaximumSize(new Dimension(117,185));
		labelMazzo.setOpaque(true);
		buttonBriscola = new JButton();
		buttonBriscola.setPreferredSize(new Dimension(117,185));
		buttonBriscola.setMinimumSize(new Dimension(117,185));
		buttonBriscola.setMaximumSize(new Dimension(117,185));
		buttonBriscola.setOpaque(true);
		cartaGiocata1 = new JLabel();
		cartaGiocata1.setPreferredSize(new Dimension(117,185));
		cartaGiocata1.setMinimumSize(new Dimension(117,185));
		cartaGiocata1.setMaximumSize(new Dimension(117,185));
		cartaGiocata1.setOpaque(true);
		cartaGiocata1.setVisible(false);
		cartaGiocata2 = new JLabel();
		cartaGiocata2.setPreferredSize(new Dimension(117,185));
		cartaGiocata2.setMinimumSize(new Dimension(117,185));
		cartaGiocata2.setMaximumSize(new Dimension(117,185));
		cartaGiocata2.setOpaque(true);
		cartaGiocata2.setVisible(false);
		
		boxes[2].add(Box.createRigidArea(new Dimension(15,185)));
		boxes[2].add(labelMazzo);
		boxes[2].add(Box.createRigidArea(new Dimension(15,185)));
		boxes[2].add(buttonBriscola);
		boxes[2].add(Box.createRigidArea(new Dimension(100,185)));
		boxes[2].add(cartaGiocata1);
		boxes[2].add(Box.createRigidArea(new Dimension(25,185)));
		boxes[2].add(cartaGiocata2);
		
		///////////////
		
		nord.setPreferredSize(new Dimension(750,230));
		nord.add(boxes[0], BorderLayout.CENTER);
		centro.setPreferredSize(new Dimension(750,235));
		centro.add(boxes[2], BorderLayout.CENTER);
		sud.setPreferredSize(new Dimension(750,230));
		sud.add(boxes[1], BorderLayout.CENTER);
		sfondo.add(nord, BorderLayout.NORTH);
		sfondo.add(sud, BorderLayout.SOUTH);
		sfondo.add(centro, BorderLayout.CENTER);
	
		this.setSize(750, 705);
		this.setLocationRelativeTo(null);
		this.setResizable(false);
		this.setVisible(true);
		this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		
		//AVVIO PARTITA
		start();
		
		System.out.println("PARTITA TERMINATA");
	}
	
	//Svolgimento della partita
	private void start() {
		
		System.out.println("La partita ha inizio!");
		
		boolean vittoria = false;
		
		while(!vittoria) {
			
			String urlB = p.getBriscola().getUrlImage(p.getBriscola().getSeme());
			String urlM = p.getMazzo().getUrlImageMazzo();
			
			//PASSO 1: operazioni preliminari
			
			System.out.println("Distribuisco le carte ai giocatori");
			
			operazioniPreliminari(urlB, urlM);
			
			//Imposta il numero di carte rimanenti. E' da aggiornare ad ogni pescata
			carteRimanenti.setText("Carte rimanenti: " + p.carteRimanenti());
			
			System.out.println("Carte rimanenti: " + p.carteRimanenti());
			
			if(turnoGiocatore) {
				System.out.println("E' il turno del giocatore");
			}
			else System.out.println("E' il turno dell'avversario");
			
			//PASSO 2: Si iniziano a giocare le carte
			
			gestioneTurno();
		}
	}
	
	private void gestioneTurno() {
		
		if(turnoGiocatore) {
			turnoGiocatore();
			turnoAvversario();
		}
		else {
			turnoAvversario();
			turnoGiocatore();
		}
	}
	
	private void turnoGiocatore() {
		while(true) {
			notifica = new Object();
			synchronized (notifica) {
				try {
					nG.setText(p.getGiocatore().getNome() + " E' IL TUO TURNO!");
					notifica.wait(); //-> Mi metto in attesa che il gioatore tiri
				} catch (InterruptedException e) {
					System.out.println("Errore nella sincronizzazione del turnoGiocatore");
				}
			}
			
			primaCarta.addActionListener(this);
			secondaCarta.addActionListener(this);
			terzaCarta.addActionListener(this);
			
		}
	}
	
	private void turnoAvversario() {
		System.out.println("E' il turno dell'avversario");
	}
	
	@Override
	public void actionPerformed(ActionEvent event) {
		
		Object source = event.getSource();
		
		if(source.equals(primaCarta)) {
			String url = primaCarta.getText();
			System.out.println("Il giocatore ha giocato la carta: " + url);
			notifica.notify();
		}
		
		if(source.equals(secondaCarta)) {
			String url = secondaCarta.getText();
			System.out.println("Il giocatore ha giocato la carta: " + url);
			notifica.notify();
		}
		
		if(source.equals(terzaCarta)) {
			String url = terzaCarta.getText();
			System.out.println("Il giocatore ha giocato la carta: " + url);
			notifica.notify();
		}
	}
	
	/**Si occupa di impostare la fase iniziale del gioco**/
	private void operazioniPreliminari(String urlB, String urlM) {
		
		//Imposta la label briscola
		System.out.println("Scelgo la briscola");
		
		Carta briscola = p.getBriscola();
		briscola.volta();
		Image img = briscola.getImage(new Dimension(117,185));
		System.out.println("La briscola è: " + briscola.getSeme());
		ImageIcon imgIc = new ImageIcon(img);
		buttonBriscola.setIcon(imgIc);
		buttonBriscola.setText(urlB); //Testo per il riconoscimento della carta selezionata
		
		//Imposta la label mazzo
		Mazzo m = p.getMazzo();
		Image img_m = m.getImage(new Dimension(117,185));
		ImageIcon imgIc_m = new ImageIcon(img_m);
		labelMazzo.setIcon(imgIc_m);
		labelMazzo.setText(urlM);     //Testo per il riconoscimento della carta selezionata
		
		//Distribuisce le carte ai giocatori
		
		HashSet<Carta> cG = p.distribuisciCarteGiocatore();
		HashSet<Carta> cA = p.distribuisciCarteAvversario();
		
		String[] urlCG = new String[3];
		String[] urlCA = new String[3];
		
		Iterator<Carta> itG = cG.iterator();
		int i = 0;
		while(itG.hasNext()) {
			Carta next = itG.next();
			urlCG[i] = next.getUrlImage(next.getSeme());
			i++;
		}
		
		Iterator<Carta> itA = cA.iterator();
		int j = 0;
		while(itA.hasNext()) {
			Carta next = itA.next();
			urlCA[j] = next.getUrlImage(next.getSeme());
			j++;
		}
				
		Object[] carteAvv = cA.toArray();
		Object[] carteGio = cG.toArray();
		
		Image cA1 = ((Carta) carteAvv[0]).getImage(new Dimension(117,185));
		Image cA2 = ((Carta) carteAvv[1]).getImage(new Dimension(117,185));
		Image cA3 = ((Carta) carteAvv[2]).getImage(new Dimension(117,185));
		ImageIcon imgIcA1 = new ImageIcon(cA1);
		ImageIcon imgIcA2 = new ImageIcon(cA2);
		ImageIcon imgIcA3 = new ImageIcon(cA3);
		avvUno.setIcon(imgIcA1);
		avvUno.setText(urlCA[0]);
		avvDue.setIcon(imgIcA2);
		avvDue.setText(urlCA[1]);
		avvTre.setIcon(imgIcA3);
		avvTre.setText(urlCA[2]);
		
		((Carta) carteGio[0]).volta();
		((Carta) carteGio[1]).volta();
		((Carta) carteGio[2]).volta();
		Image cG1 = ((Carta) carteGio[0]).getImage(new Dimension(117,185));
		Image cG2 = ((Carta) carteGio[1]).getImage(new Dimension(117,185));
		Image cG3 = ((Carta) carteGio[2]).getImage(new Dimension(117,185));
		ImageIcon imgIcG1 = new ImageIcon(cG1);
		ImageIcon imgIcG2 = new ImageIcon(cG2);
		ImageIcon imgIcG3 = new ImageIcon(cG3);
		primaCarta.setIcon(imgIcG1);
		primaCarta.setText(urlCG[0]);
		secondaCarta.setIcon(imgIcG2);
		secondaCarta.setText(urlCG[1]);
		terzaCarta.setIcon(imgIcG3);
		terzaCarta.setText(urlCG[2]);
	}
}

Come vedete la classe GuiPartita sta uscendo un bel casino.. oltre ai turni
ho incontrato problemi sul come ottenere la carta in base al JButton cliccato.
L'idea di un restyling completo mi spaventa tantissimo.. xD Aiuto

[Varilion]

Originariamente inviato da Groove89

Ciao ragazzi, sto letteralmente impazzendo nel fare un progetto personale, ossia il gioco briscola. E' la prima volta che tento di programmare un gioco completo e mi sono reso conto di aver sviluppato un codice veramente incasinato e non so veramente come districarmi adesso. Il problema principale che sto incontrando è come GESTIRE I TURNI dei due giocatori (umano e computer).

[...]

Come vedete la classe GuiPartita sta uscendo un bel casino.. oltre ai turni
ho incontrato problemi sul come ottenere la carta in base al JButton cliccato.
L'idea di un restyling completo mi spaventa tantissimo.. xD Aiuto

Quella classe (GuiPartita) è pessima dai! Un po' di sforzo e la si risistema. Partiamo dagli action listener. Ok che hai risolto però si può fare di meglio. In sostanza io non fare implementare ActionListener dal mio JFrame ma farei una classe a parte qualcosa tipo

public class MioListener implements ActionListener(){
private String idCarta;
public void setCarta(String carta){
 idCarta = carta;
}
public void actionPerformed(ActionEvent event){
//le tue operazioni, però ora sai che la carta su cui sta cliccando è quella che hai settato in precedenza!
}
}

Non so se è la miglior ma è più "pulita".

Da qualche parte poi devi avere un Main che faccia partire la tua applicazione (non l'ho trovato nel tuo codice -.-') e quindi un cliclo che gestisca la tua partita qualcosa tipo while(!condizioniFine){//fai cose...}. In più cercerei di portare il più possibile la logica applicativa fuori da quella classe gui.

[Groove89]

Non ho postato mica tutto il codice, ci sono altre 10 classi ancora.. xD
Il fatto degli actionListener lo sapevo ma essendo pochi ho pensato di
farli nella medesima classe. E il ciclo di cui parli ci sta se guardi bene.. però
non so proprio come "mettere in pausa" l'applicazione quando IO (o l'avversario)
sto facendo la mia mossa. Ho provato a creare una variabile globale in
GuiPartita di tipo Object su cui invoco wait e notify ma si blocca tutto il
programma e non carica nemmeno la grafica. All'inizio ho cercato di sforzarmi
di separare la logica dalla gui ma non ci sono riuscito. Come faccio a gestire
la partita in una classe separata e contemporaneamente interagire con l'utente?
C'è una corrispondenza univoca tra JButton <--> ImageIcon della carta...
Mi serve un aiutino un po più concreto

[Varilion]

per fare le cose facili (in modo da non avere niente di concorrente) puoi far conseguire tutto all'azione dell'utente (senza nessun ciclo).

ovvero:
-all'inizio inizializzi una partita ed aggiorni la GUI. (e se comincia l'avversario la sua prima carta giocata)
-L'utente clicca sul bottone (gioca la carta) e tu giochi l'intera mano. La mossa del giocatore. Dopo la mossa dell'avversario (se non l'ha già fatta prima.) Quindi valuti di chi è il prossimo turno (o se la partita è finita). Se è dell'avversario giochi la sua carta.

A questo punto non devi fare nient'altro che aspettare che l'utente "avvii" un nuovo ciclo cliccando sul pulsante. Domani sera se faccio in tempo posso anche scriverti 3 righe di pseudocodice, ma spero di essere stato comprensibile.

[Groove89]

Intanto ho tolto tutta a porcheria dalla classe GuiPartita dove è rimasto solo il codice dell'interfaccia. Comunque si un po di pseudocodice mi sarebbe utile Nel frattempo mi sono venute un po di idee:

1) GuiPartita attualmente è il JFrame che rappresenta TUTTO il gioco con l'area del giocatore, l'area dove si buttano le carte e l'area dell'avversario. Potrei rendere dei JFrame anche le mie classi Giocatore e GiocatoreElettronico e creare una classe JFrame Tavolo (dove si buttano le carte) e comporre GuiPartita tramite questi tre JFrame. Questo potrebbe facilitarmi la modifica di GuiPartita a seconda dello svolgimento della Partita..almeno ad intuito, solo che non so se è un approccio corretto.

2) Lascio tutto com'è e creo una variabile globale turno (boolean o int non so).
Decido di chi è il turno in modo random e faccio una cosa simile:

Suppongo che il turno sia un int: 0 giocatore, 1 avversario

operazioniPreliminari() <-- distribuzione carte, scelta del turno

while(!vittoria) {
    
	if(turno == 0) { <-- è il turno del giocatore
        	while(turno == 0) { <-- dovrebbe bloccarsi all'interno di questo ciclo no?
                    eseguo le mosse del giocatore 
		    turno = 1 <-- ho finito, ora tocca all'avversario
                }
	}

	if(turno == 1) { <-- è il turno del computer
                come prima ma al contrario..
	
	}
 ...

}

Che dici?

Edit: boh non so sto provando ma non ne vengo a capo. Quando è il turno del giocatore attivo i listener per le sue carte ma dal
listener non trovo un modo elegante per ottenere la carta effettiva cliccata. Una volta che il giocatore ha cliccato la carta
essa deve sparire dal suo gruppo e comparire in mezzo al tavolo. Dopo di ciò il turno deve essere quello dell'avversario che verifica
la carta presente sul tavolo e gioca di conseguenza.

[Groove89]

Provo a rispondere un'altra volta.. se non mi risponde nessuno anche adesso non romperò più

Ho modificato un po l'impostazione delle classi Giocatore, GiocatoreElettronico, Carta, Mazzo e creato la classe Tavolo. Ho inoltre la classe Partita che si occupa di svolgere la partita fra i giocatori e la classe GuiPartita che vorrei rappresentasse graficamente lo svolgimento della partita (non so come).
Quello che chiedo è:
1) E' giusta l'impostazione?
2) Come faccio a far interagire la classe Partita con la classe GuiPartita?
So solo che a GuiPartita passo Partita nel costruttore.

Giocatore

package singleplayer;

import carta.Carta;
import classifica.RecordClassifica;

public class Giocatore
{
	protected String nome;			  //nome del giocatore
	protected RecordClassifica dati;  //per la classifica
	
	//le carte in mano al giocatore
	protected Carta primaCartaGiocatore;
	protected Carta secondaCartaGiocatore;
	protected Carta terzaCartaGiocatore;
	
	protected int puntiGiocatore;
	
	protected boolean turno;
	
	public Giocatore(String nome) {
		this.nome = nome;
		dati = new RecordClassifica(nome);
		primaCartaGiocatore = new Carta(0,null);
		secondaCartaGiocatore = new Carta(0,null);
		terzaCartaGiocatore = new Carta(0,null);
		puntiGiocatore = 0;
		turno = false;
	}
	
	public boolean isTurnoGiocatore() {
		return turno == true;
	}
	
	public void setTrueTurnoGiocatore() {
		turno = true;
	}
	
	public void setFalseTurnoGiocatore() {
		turno = false;
	}
	
	public void setPrimaCartaGio(Carta c) {
		primaCartaGiocatore = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setSecondaCartaGio(Carta c) {
		secondaCartaGiocatore = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setTerzaCartaGio(Carta c) {
		terzaCartaGiocatore = new Carta(c.getValore(),c.getSeme());
	}
	
	public int getPuntiGio() {
		return puntiGiocatore;
	}
	
	public String getNome() {
		return nome;
	}
	
	private Carta getPrimaCartaGiocatore() {
		return primaCartaGiocatore;
	}
	
	private Carta getSecondaCartaGiocatore() {
		return secondaCartaGiocatore;
	}
	
	private Carta getTerzaCartaGiocatore() {
		return terzaCartaGiocatore;
	}
	
	public String toString() {
		return "Giocatore: " + this.nome;
	}
	
	public RecordClassifica getRecordClassifica() {
		return dati;
	}
}

GiocatoreElettronico

package singleplayer;

import carta.Carta;

public class GiocatoreElettronico extends Giocatore {

	protected Carta primaCartaAvv;
	protected Carta secondaCartaAvv;
	protected Carta terzaCartaAvv;
	
	protected int puntiAvv;
	
	protected boolean turno;
	
	public GiocatoreElettronico(String nome) {
		super(nome);
		primaCartaAvv = new Carta(0,null);
		secondaCartaAvv = new Carta(0,null);
		terzaCartaAvv = new Carta(0,null);
		puntiAvv = 0;
		turno = false;
	}
	
	public boolean isTurnoAvversario() {
		return turno == true;
	}
	
	public void setTrueTurnoAvversario() {
		turno = true;
	}
	
	public void setFalseTurnoAvversario() {
		turno = false;
	}
	
	public void setPrimaCartaAvv(Carta c) {
		primaCartaAvv = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setSecondaCartaAvv(Carta c) {
		secondaCartaAvv = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setTerzaCartaAvv(Carta c) {
		terzaCartaAvv = new Carta(c.getValore(),c.getSeme());
	}
	
	public int getPuntiAvv() {
		return puntiAvv;
	}
	
	public Carta getPrimaCartaAvv() {
		return primaCartaAvv;
	}
	
	public Carta getSecondaCartaAvv() {
		return secondaCartaAvv;
	}
	
	public Carta getTerzaCartaAvv() {
		return terzaCartaAvv;
	}
 }

Carta

package carta;

public class Carta {
	
	//caratteristiche carta
	private final Seme seme;   //seme carta
	private final int valore;  //valore carta
	
	 /**
     * Queste costanti ci informano dello stato della carta:
     * - VISIBILE:  la carte è visibile con la sua immagine;
     * - COPERTA: è visibile il retro della carta;
     * - RIMOSSA: la carta è stata rimossa dal gioco.
     */
	
	static final int VISIBILE = 1;
    static final int COPERTA = 0;
    static final int RIMOSSA = -1;
    
    private int stato;

	public Carta(int valore, Seme seme)  
	{	
		this.seme = seme; 
		this.valore = valore;
		this.stato = COPERTA;
	}
	
	//ritorna il valore della carta
	public int getValore() {
		return this.valore;
	}
	
	public String getValoreStr() {
		switch(this.valore) {
			case  1: return "Asso";
			case  2: return "Due";
			case  3: return "Tre";
			case  4: return "Quattro";
			case  5: return "Cinque";
			case  6: return "Sei";
			case  7: return "Sette";
			case  8: return "Donna";
			case  9: return "Cavallo";
			case 10: return "Re";
			default: return "-";
		}
	}
	
	//ritorna il seme
	public Seme getSeme() {
		return this.seme;
	}
	
	//funzione utilizzata per girare la carta
	public void volta() {
		if(stato == Carta.VISIBILE) {
			stato = Carta.COPERTA;
		}
		else if(stato == Carta.COPERTA) {
			stato = Carta.VISIBILE;
		}
	}
	
	//rimuove la carta dal gioco
	public void rimuovi() {
        stato = Carta.RIMOSSA;
    }
	
	//fa tornare una carta in gioco
	public void riassegna() {
        stato = Carta.COPERTA;
    }
	
	//verifica se la carta è stata rimossa
	public boolean isRimossa() {
		 if (stato == Carta.RIMOSSA)
	            return true;
	        else
	            return false;
	}
	
	//verifica se la carta è visibile
	public boolean isVisibile() {
        if(stato == Carta.VISIBILE)
            return true;
        else
            return false;
    }
	
	//stampa la carta
	public String toString() {
		String ret = this.getValoreStr() + " di " + this.seme;
		return ret;
	}
		
	//ridefinizione equals
	public boolean equals(Object o) {
		if(o == null || o.getClass() != getClass()) {
			return false;
		}
		
		Carta c = (Carta)o;
		
		return (valore == c.valore && seme == c.seme);
	}
	
	//verifica se la carta è una figura
	public boolean isFigura() {
		return (this.valore == 8 || this.valore == 9 || this.valore == 10);
	}
	
	//Ritorna l'url dell'immagine associata alla carta
	public String getUrlImage(Seme seme) {
		String url1 = "images/retro.jpg";
		String url2 = "images/" + getValoreStr() + " " + seme + ".jpg";
		if(this.isVisibile()) {
			return url2;
		}
		else return url1;
	}
}

Mazzo

package carta;

import java.util.ArrayList;
import java.util.Collections;

/**
 * Questa classe rappresenta un mazzo di carte.
 * 
 * @author Stefano Loris
 *
 */
public class Mazzo {
   
    private ArrayList<Carta> carte;
    private int indiceCorrente;
   
    public Mazzo() {
    	
        carte = new ArrayList<Carta>();
      
        // inizializza il mazzo
        for (int valore=1; valore<=10; valore++) {
            for (Seme seme: Seme.values()) {
                carte.add(new Carta(valore, seme));
            }
        }
      
        // mischia le carte
        Collections.shuffle(carte);
      
        // la prima carta da servire e' la carta in indice zero
        indiceCorrente = 0;
    }     
   
    /**
    * Mischia il mazzo di carte
    */
    public void mischia() {
        Collections.shuffle(carte);
    }
   
    /**
    * Estrae una carta dal mazzo
    * @return
    */
    public Carta estrai() {
        Carta estratta = null;
    	try {
    		estratta = carte.remove(indiceCorrente++);
            return estratta;
        } catch (IndexOutOfBoundsException e) {
            return null;
        }
    }
    
    public Carta getBriscola() {
    	return carte.get(indiceCorrente++);
    }
    
    public int carteRimanenti() {
    	return this.carte.size();
    }
}

Tavolo

package singleplayer;

import carta.Carta;
import carta.Mazzo;

/**
 * 
 * @author Loris
 *
 *	Classe che rappresenta il tavolo centrale 
 *	dove è presente il mazzo e dove vengono
 *	posate le carte.
 */
public class Tavolo {
	
	protected Carta pcTavolo;          //Carta giocata dal pc
	protected Carta userTavolo;        //Carta giocata dall'utente
	protected Carta briscolaTavolo;    //Briscola
	protected Mazzo mazzo;             //Nel tavolo è presente anche il mazzo di carte
	
	public Tavolo() {
		pcTavolo = new Carta(0,null);
		userTavolo = new Carta(0,null);
		briscolaTavolo = new Carta(0,null);
		mazzo = new Mazzo();
	}
	
	//METODI GET
	
	public Carta getPcTavolo() {
		return pcTavolo;
	}
	
	public Carta getUserTavolo() {
		return userTavolo;
	}
	
	public Carta getBriscolaTavolo() {
		return briscolaTavolo;
	}
	
	public Mazzo getMazzo() {
		return mazzo;
	}
	
	//METODI SET
	
	public void setPcTavolo(Carta c) {
		pcTavolo = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setUserTavolo(Carta c) {
		userTavolo = new Carta(c.getValore(),c.getSeme());
	}
	
	public void setBriscolaTavolo(Carta c) {
		briscolaTavolo = new Carta(c.getValore(),c.getSeme());
	}
}

La classe GuiPartita è la stessa che ho scritto nei post precedenti solo che ci ho lasciato solo la grafica.
La classe Partita devo rifarla d'accapo..