Newsgroup: it.comp.java
Titolo: Comunicazioni tra due classi ( parte 2 ;) )

Salve,
mi trovo dinnanzi all'ultimo problema in java ( lo spero :) ) che mi
sta impedendo di terminare il mio programma universitario (java
+prolog) per giocare a poker.
Come scritto, in un mio post precedente, ho due classi principali:
"Tavolo" e  "Poker".
Con "Tavolo" gestisco il funzionamento del gioco vero e proprio,
mentre con "Poker" visualizzo i giocatori, le puntate, i piatti ecc.
Non appena, nella classe "Tavolo" succede "qualcosa". Per esempio una
giocata di un giocatore, la suddetta classe comunica a "Poker" la
giocata e quest'ultima visualizza a schermo la giocata fatta dal
giocatore.
Quindi ho "class Poker extends javax.swing.JFrame implements Observer"
e "class Tavolo extends Observable".
Fatta questa premessa, il problema che non riesco a risolvere è il
seguente:
Nella classe "Tavolo" ho un metodo chiamato "giroScommesse()" al cui
interno c'è un while, per ciclare fra tutti i giocatori per
consentirgli di effettuare la propria giocata/puntata.
Per ogni giocatore controllo il suo "tipo", ovvero se deve essere
gestito dall'intelligenza artificiale (parte in prolog) o gestito da
una persona in carne ed ossa.
Il problema si presenta,quando arriva il turno dell' "umano", perchè i
bottoni per effettuare le varie giocate (call, raise, allin, ecc..) si
trovano nella classe "Poker", mentre il metodo per gestire le puntate
e il giro delle scommesse in "Tavolo".
Mi sapete dire come potrei da "Tavolo" gestire i bottoni delle giocate
presenti in "Poker" e poi da "Poker" inviare a "Tavolo" la giocata
fatta per riprendere il ciclo while dei giocatori???
Riassumo il tutto con un pò di codice:
-----------------------------------------------------------------------------------
public class Tavolo extends Observable{
   .....
   private void giroScommesse(){
      while( giocatori.hasNext() ){
         ...
         if( giocatore.getTipo().equals("ia") ){
            // parte in prolog
         } else {
            // E' arrivato il turno del giocatore umano. In questo
punto
            // vorrei ricevere la giocata fatta. attraverso i pulsanti
delle varie giocate presenti
            // nella classe "Poker".
            // --- Come si fa?
         }
        // Invio alla classe "Poker" la giocata fatta e la visualizzo
a schermo
        notificaCambiamento("giocata");
   }
}
public class Poker extends javax.swing.JFrame implements Observer {
   // definisco i vari bottoni per fare raise, call, bet, allin, ecc..
   // pulsante per fare raise
   private void raiseActionPerformed(java.awt.event.ActionEvent evt)
{
        // come possono comunicare alla classe "tavolo" che il
giocatore in questione ha fatto
        // raise e di conseguenza a quanto ammonta il suo rilancio ??
    }
}
-----------------------------------------------------------------------------------
Sperando di essere stato abbastanza chiaro e che mi possiate aiutare,
vi ringrazio anticipatamente
Nicola


la prima cosa che mi viene in mente è creare una variabile in Poker
che contiene un oggetto Giocata; dall'else di Tavolo fai partire un
while che aspetta la valorizzazione di questa variabile (da parte del
giocatore umano) e recupera i valori inseriti rimettendo la variabile
a null.

 a null.
Grazie della risposta,
stavo pensando di fare una cosa simile: visto che da Poker faccio
partire la gestione della partita istanziando la classe tavolo, avevo
pansato di valorizzare da Poker una variabile in Tavolo...e
controllare da Tavolo, una volta dentro all'else, ogni 500
millisecondi, se questa variabile è stata valorizzata...ma
effettivamente l'uso del while dovrebbe essere la soluzione migliore.
Ma questa divisione dei compiti che ho fatto tra Tavolo e Poker è
accettabile oppure ce ne sono di migliori?

 effettivamente l'uso del while dovrebbe essere la soluzione migliore.
anzi non funziona :(
se nell'else metto un while che continua a ciclare a vuoto fino a
quando la variabile della giocata è diversa da null, non riuscirò a
visualizzare l'interfaccia con i bottoni delle azioni dell'umano
presenti in Poker..andando a finire in un loop.
-----------------------------------------------------------------------------------
public class Tavolo extends Observable{
   .....
   private int ultimaPuntataUmano = -1;
   private String ultimaAzioneUmano = "";
   ....
   private void giroScommesse(){
      while( giocatori.hasNext() ){
         ...
         if( giocatore.getTipo().equals("ia") ){
            // parte in prolog
         } else {
            // continuo a ciclare fino a quando il giocatore
            // umano non fa una giocata
            while( ultimaAzioneUmano.equals( "" ) ){
              // ciclo vuoto
              // cicla all'infinito perchè l'interfaccia presente in
Poker
              // non viene mai visualizzata, impedendo al giocatore
              // di fare la propria giocata....:(
             }
           // salvo la giocata
           azione = ultimaAzioneUmano;
           puntata = ultimaPuntataUmano;
           // ripristino i valori di default per consentire il ciclo
nel giro successivo
           ultimaAzioneUmano = "";
           ultimaPuntataUmano = -1;
         }
        // Invio alla classe "Poker" la giocata fatta
       // e la visualizzo a schermo
        notificaCambiamento("giocata");
   }
}
public class Poker extends javax.swing.JFrame implements Observer {
   // definisco i vari bottoni per fare raise, call, bet, allin, ecc..
  ...
  Tavolo tavolo = new Tavolo();
  public Poker() {
     ....
     tavolo.iniziaPartita();
  }
   // pulsante per fare raise
   private void raiseActionPerformed(java.awt.event.ActionEvent evt)
{
        tavolo.setUltimaAzioneUmano( "raise" );
        tavolo.setUltimaPuntataUmano( 1000 );
    }
}
-----------------------------------------------------------------------------------
Mi sa che devo cambiare approccio :( ... consigli?

 Mi sa che devo cambiare approccio :( ... consigli?
Ho provato in tutti i modi:
- con il while, non riesco a rendere cliccabili i bottoni, di
conseguenza, non riesco a valorizzare la variabile. Conseguenza: loop!
- con un Timer, l'esecuzione riprende senza aspettare che il bottone
venga schiacciato.
Quindi cambio approccio: elimino il while e lo sostituisco con la
ricorsione di un metodo. Così da Poker, al click sul bottone, potrò
richiamare il metodo e passare al giocatore successivo....mi sembra la
soluzione migliore