Advertisement
aa91

Model/MatchManager

Mar 1st, 2024
504
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 24.93 KB | None | 0 0
  1. package model;
  2.  
  3. import javax.swing.*;
  4. import java.io.*;
  5. import java.util.*;
  6. import java.util.concurrent.Semaphore;
  7.  
  8. public class MatchManager extends Observable {
  9.  
  10.     List<Player> playerList;
  11.     Deck gameDeck;
  12.     Deck discardedCards;
  13.     Card cardInHand;
  14.     int playerIndex;
  15.     int numberOfPlayer;
  16.     String giocatoriPath = "/Users/andrea/Il mio Drive/Università/- Metodologie di programmazione/ProgettoJava/src/Giocatori.txt";
  17.  
  18.     List<Player> winnerPlayerList;
  19.     int firtPlayerIndexWinner;
  20.     boolean ultimoGiro;
  21.  
  22.     private static boolean interactionOnDeck = true;
  23.     private static boolean interactionOnBoard = false;
  24.  
  25.     public Semaphore semaphoreInteractionOnDeck = new Semaphore(0);
  26.     public Semaphore semaphoreInteractionOnBoard = new Semaphore(0);
  27.  
  28.     boolean firstPlay = true;
  29.  
  30.     public MatchManager() {
  31.     }
  32.  
  33.     public void avviaGioco(){
  34.         //Da reinserire
  35. //        if(firstPlay == true) {
  36.             setChanged();
  37.             notifyObservers(Arrays.asList(9));
  38. //        }
  39.  
  40.         System.out.println("Inserisci numero giocatori");
  41.         Scanner scanner = new Scanner(System.in);
  42.         setNumberOfPlayer(scanner.nextInt());
  43.         inizializzaGiocatori();
  44.         inizializzaGioco();
  45.     }
  46.  
  47.     //inizializzo il gioco di carte
  48.     public void inizializzaGioco() {
  49.         //genero un gamedeck
  50.         this.gameDeck = new Deck(numberOfPlayer);
  51.         this.discardedCards = new Deck();
  52.  
  53.         this.winnerPlayerList = new ArrayList<>();
  54.  
  55.         firtPlayerIndexWinner = -1;
  56.         ultimoGiro = false;
  57.  
  58.         for (Player p : playerList) {
  59.             p.initializeBoardCard();
  60.             p.initializaRemainingCard();
  61.         }
  62.  
  63.         for (Player p : playerList) {
  64.             assegnaCarte(p, this.gameDeck);
  65.         }
  66.  
  67.         Card cartaGirata = this.gameDeck.giveCard();
  68.  
  69.         //Giro prima carta sul tavolo
  70.         discardedCards.addCard(cartaGirata);
  71.  
  72.  
  73.         setChanged();
  74.         notifyObservers(Arrays.asList(0, playerList, playerIndex, discardedCards));
  75.  
  76. //        setChanged();
  77. //        notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  78.  
  79.     }
  80.  
  81.     public void inizializzaGiocatori() {
  82.         Scanner scanner2 = new Scanner(System.in);
  83.         //Inizializzo lista giocatori
  84.         playerList = new ArrayList<>();
  85.         String nicknameApp;
  86.  
  87.         //Inserisco Player Umano
  88.         System.out.println("Inserisci nome del Player Umano");
  89.         nicknameApp = scanner2.nextLine();
  90. //        nicknameApp = "Andrea";
  91.         playerList.add(new Player(nicknameApp));
  92.  
  93.         //Inserisco Player Computer
  94.         for (int i = 1; i < numberOfPlayer; i++) {
  95.             System.out.println("Inserisci nome del Player Computer");
  96.             nicknameApp = scanner2.nextLine();
  97. //            nicknameApp = "Francesco";
  98.             playerList.add(new Player(nicknameApp));
  99.         }
  100.  
  101.         try(BufferedReader br = new BufferedReader(new FileReader(giocatoriPath))){
  102.             String line;
  103.             while((line = br.readLine()) != null){
  104.                 String[] statisticPlayer = line.split(" ");
  105.  
  106.                 String nomePlayer = statisticPlayer[0];
  107.                 int lvPlayer = Integer.parseInt(statisticPlayer[1]);
  108.  
  109.                 for(Player p: playerList){
  110.                     if(p.getNickname().equals(nomePlayer))
  111.                         p.setPartiteVinte(lvPlayer);
  112.                 }
  113.  
  114.             }
  115.  
  116.         } catch (FileNotFoundException e) {
  117.             throw new RuntimeException(e);
  118.         } catch (IOException e) {
  119.             throw new RuntimeException(e);
  120.         }
  121.     }
  122.  
  123.  
  124.         public static void assegnaCarte(Player player, Deck gameDeck) {
  125.         for (int i = 0; i < player.getboardCardDimension(); i++) {
  126.             player.takeCardToBoard(gameDeck.giveCard());
  127.         }
  128.     }
  129.  
  130.     private boolean controlloCartaJackDonna(Card card) {
  131.         if (card.getRank() == CardRank.JACK || card.getRank() == CardRank.DONNA)
  132.             return true;
  133.  
  134.         return false;
  135.     }
  136.  
  137.     private boolean controlloCartaJollyRe(Card card) {
  138.         if (card.getRank() == CardRank.JOLLY || card.getRank() == CardRank.RE)
  139.             return true;
  140.  
  141.         return false;
  142.     }
  143.  
  144.     private void movimentoComputer(Player player) {
  145.         boolean sostituito = false;
  146.         Card appCard = null;
  147.         while (!sostituito) {
  148.  
  149.             //scelgo un numero a caso tra 0 e dimensione del board
  150.             int randomIndex = (int) (Math.random() * player.getboardCardDimension());
  151.             //prendo in mano carta che era a terra
  152.             appCard = player.getBoardCards().get(randomIndex);
  153.  
  154.             if (!appCard.getFaceUp()) {
  155.                 player.showCard();
  156. //                System.out.print(" * Scambio: " + cardInHand + " con " + appCard + "  111" + "\n");
  157. //                System.out.println(" * Indici: " + cardInHand.getRank().rankToValue() + " con " + (randomIndex + 1));
  158.  
  159.                 //posiziono la carta
  160.                 player.getBoardCards().set(randomIndex, cardInHand);
  161.  
  162.                 cardInHand = appCard;
  163.                 //Ristampo la scacchiera
  164.                 setChanged();
  165.                 notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  166.  
  167.                 setChanged();
  168.                 notifyObservers(Arrays.asList(6, this.playerIndex));
  169.  
  170.                 //In revisione, si può rimuovere questo controllo è anche nel ComposeGampanel from matrix
  171.                 if(!discardedCards.isEmpty()) {
  172.                     //Aggiorno carta sul tavolo
  173.                     setChanged();
  174.                     notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  175.                 }
  176.  
  177.                 sostituito = true;
  178.             }
  179.         }
  180.  
  181.  
  182.         //Aggiorno visualizzazione carta vicino a giocatore dal giocatore
  183.         setChanged();
  184.         notifyObservers(Arrays.asList(2, cardInHand, playerIndex));
  185.  
  186.         //controllo termine partita
  187. //        controlloTerminePartita(player);
  188.  
  189.         System.out.println("Uscito da movimento computer");
  190.     }
  191.  
  192.     public void movimentoUmanoPescaTerra() {
  193.         if(interactionOnDeck == true){
  194. //            interactionOnDeck = false;
  195.             cardInHand = discardedCards.getLastERemove();
  196.             System.out.println("Carta Pescata da terra: " + cardInHand);
  197.             semaphoreInteractionOnDeck.release();
  198.         }
  199.     }
  200.  
  201.     public void movimentoUmanoPescaMazzo(){
  202.         if(interactionOnDeck == true) {
  203. //            interactionOnDeck = false;
  204.             cardInHand = gameDeck.giveCard();
  205.             System.out.println("Carta pescata dal mazzo: " + cardInHand);
  206.             semaphoreInteractionOnDeck.release();
  207.         }
  208.     }
  209.  
  210.     public void turnoDiGioco() {
  211.  
  212.         if(ultimoGiro == true && playerIndex == firtPlayerIndexWinner) {
  213.             System.out.println("Sono qui");
  214.             if (termineRoundOTermineGioco() == true) {
  215.                 System.out.println("Gioco Terminato");
  216.  
  217.                 System.out.println("Vuoi giocare nuovamente?: ");
  218.                 Scanner scanner = new Scanner(System.in);
  219.                 String scelta = scanner.nextLine();
  220.  
  221.                 if(scelta.equals("no"))
  222.                     throw new RuntimeException("Gioco Terminato");
  223.                 else if (scelta.equals("si")) {
  224.                     firstPlay = false;
  225.                     avviaGioco();
  226.  
  227.                 }
  228.                 else
  229.                     throw new RuntimeException("Scelta non valida!");
  230.  
  231.  
  232.             } else {
  233.                 //Elimino carta visualizzata a terra
  234.                 setChanged();
  235.                 notifyObservers(Arrays.asList(5));
  236.             }
  237.         }
  238.  
  239.         System.out.println("********************************");
  240.         if (playerIndex != -1) {
  241.             System.out.println("Turno di: " + playerList.get(playerIndex).getNickname());
  242.             System.out.println(" * Carta coperta: " + cardInHand);
  243.         }
  244.  
  245.         //Visualizzazione pedina
  246. //        setChanged();
  247. //        notifyObservers(Arrays.asList(6, this.playerIndex));
  248.  
  249.         setChanged();
  250.         notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  251.  
  252.         sleep(300);
  253.  
  254.         //Controllo se carte del mazzo sono terminate
  255.         if (gameDeck.getRemainingCardOfDeck() == 0) {
  256.             Deck.mischiaMazzo(discardedCards);
  257.             this.gameDeck = discardedCards;
  258.             discardedCards = new Deck();
  259.         }
  260.  
  261.         Card appCard = null;
  262.         Player playerInRound = playerList.get(playerIndex);
  263.  
  264.         if(playerIndex == 0){
  265.             System.out.println("Fa la tua scelta");
  266.             System.out.println(gameDeck.getFirst());
  267.  
  268.             try {
  269.                 interactionOnDeck = true;
  270.                 semaphoreInteractionOnDeck.acquire();
  271.                 interactionOnDeck = false;
  272.  
  273.             } catch (InterruptedException e) {
  274.                 e.printStackTrace();
  275.             }
  276.         }
  277.         else{
  278.             //Se le scartate sono un Re o Jolly
  279.             if(discardedCards.getLast().getRank() == CardRank.RE || discardedCards.getLast().getRank() == CardRank.JOLLY){
  280.                 cardInHand = discardedCards.getLastERemove();
  281.                
  282.             //Se il rank carta > 10 o maggiore della dimensione board giocatore o la faceUp non è un Wildcard
  283.             } else if (discardedCards.getLast().getRank().rankToValue() > 10 || discardedCards.getLast().getRank().rankToValue() > playerInRound.getboardCardDimension() || (playerInRound.getBoardCards().get(discardedCards.getLast().getRank().rankToValue() - 1).getFaceUp() && (playerInRound.getBoardCards().get(discardedCards.getLast().getRank().rankToValue() - 1).getRank() != CardRank.JOLLY && playerInRound.getBoardCards().get(discardedCards.getLast().getRank().rankToValue() - 1).getRank() != CardRank.RE))) {
  284.                 cardInHand = this.gameDeck.giveCard();
  285.             }
  286.             //Ottimizzazione scelta giocatore con carte < 5
  287.             else if(!playerInRound.getBoardCards().get(discardedCards.getLast().getRank().rankToValue()-1).getFaceUp() && playerInRound.getRemainingCards()< 5){
  288.                 cardInHand = discardedCards.getLastERemove();
  289.             }
  290.             //scelgo casualmente se pescare dal mazzo o da terra
  291.             else{
  292.                 if(casuale0e1() == 0)
  293.                     cardInHand = this.gameDeck.giveCard();
  294.                 else {
  295.                     cardInHand = discardedCards.getLastERemove();
  296.                 }
  297.             }
  298.         }
  299.  
  300. //        In revisione
  301. //        //Visualizzazione carte scartate
  302. //        if(discardedCards.isEmpty()) {
  303. //            setChanged();
  304. //            notifyObservers(Arrays.asList(5));
  305. //        }
  306. //        else {
  307. //            setChanged();
  308. //            notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  309. //        }
  310.  
  311.         setChanged();
  312.         notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  313.  
  314.         sleep(300);
  315.  
  316.         //Visualizzazione carta pescata
  317.         setChanged();
  318.         notifyObservers(Arrays.asList(2, cardInHand, playerIndex));
  319.  
  320. //        sleep(200);
  321. //
  322.         sleep(1000);
  323.  
  324.         do {
  325.             sleep(1000);
  326.  
  327.             cardInHand.setFaceUpTrue();
  328.             int cardInHandIndex = cardInHand.getRank().rankToValue() - 1;
  329.  
  330.             if (controlloCartaJackDonna(cardInHand)) {
  331.                 //Rimuovo visualizzazione carta pescata dal giocatore
  332.                 setChanged();
  333.                 notifyObservers(Arrays.asList(3, playerIndex));
  334.  
  335.                 discardedCards.addCard(cardInHand);
  336.                 System.out.println(" * Scarto: " + cardInHand);
  337.  
  338. //                In revisione
  339. //                //Aggiorno visualizzazione scarto la carta e la posiziono sul tavolo
  340. //                setChanged();
  341. //                notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  342.                 setChanged();
  343.                 notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  344.  
  345.                 break;
  346.  
  347.             //Controllo se la carta in mano è una WildCard
  348.             } else if (controlloCartaJollyRe(cardInHand)) {
  349.                 if (playerIndex != 0)
  350.                     movimentoComputer(playerInRound);
  351.                 else {
  352.                     interactionOnBoard = true;
  353.  
  354.                     try {
  355.                         semaphoreInteractionOnBoard.acquire();
  356.                     } catch (InterruptedException e) {
  357.                         throw new RuntimeException(e);
  358.                     }
  359.  
  360.                     interactionOnBoard = false;
  361.                 }
  362.  
  363.                 sleep(500);
  364.                 playerInRound.reduceRemainingCards();
  365.  
  366.                 if (controlloJtrash()) {
  367.                     //Rimuovo visualizzazione carta pescata dal giocatore
  368.                     setChanged();
  369.                     notifyObservers(Arrays.asList(3, playerIndex));
  370.                     System.out.println(" * Scarto: " + cardInHand);
  371.                     discardedCards.addCard(cardInHand);
  372.                     break;
  373.                 }
  374.             }
  375.  
  376.             //se indice carta è maggiore di dimensione del board del giocatore e non è una WildCard
  377.             else if (cardInHandIndex >= playerInRound.getboardCardDimension()) {
  378.                 discardedCards.addCard(cardInHand);
  379.                 System.out.println(" * Scarto: " + cardInHand);
  380.  
  381.                 //Rimuovo visualizzazione carta pescata dal giocatore
  382.                 setChanged();
  383.                 notifyObservers(Arrays.asList(3, playerIndex));
  384.  
  385. //                In revisione
  386. //                setChanged();
  387. //                notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  388.                 setChanged();
  389.                 notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  390.  
  391.                 break;
  392.             }
  393.             //Se la carta non è una figura
  394.             else {
  395.                 //controllo posizione già occupata\scoperta
  396.                 if (playerInRound.getBoardCards().get(cardInHandIndex).getFaceUp()) {
  397.                     //se occupata da Jolly o Re
  398.                     if (playerInRound.getBoardCards().get(cardInHandIndex).getRank() == CardRank.JOLLY || playerInRound.getBoardCards().get(cardInHandIndex).getRank() == CardRank.RE) {
  399.  
  400.                         //Carta appoggio per WildCards che era sul board
  401.                         appCard = playerInRound.getBoardCards().get(cardInHandIndex);
  402.  
  403. //                       Stampe
  404.                         //sostituisco WildCard sul board con carta in mano
  405.                         playerInRound.showCard();
  406.                         System.out.println(" * Scambio: " + cardInHand + " con " + appCard + "  256");
  407.                         System.out.println(" * Indici: " + cardInHand.getRank().rankToValue() + " con " + cardInHandIndex);
  408.  
  409.                         playerInRound.getBoardCards().set(cardInHandIndex, cardInHand);
  410.  
  411.  
  412.                         setChanged();
  413.                         notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  414.  
  415. //                        setChanged();
  416. //                        notifyObservers(Arrays.asList(6, this.playerIndex));
  417.  
  418. //                        In revisione
  419. //                        if(!discardedCards.isEmpty()) {
  420. //                            //Aggiorno carta sul tavolo
  421. //                            setChanged();
  422. //                            notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  423. //                        }
  424.  
  425.                         //Aggiorno visualizzazione carta vicino al giocatore
  426.                         cardInHand = appCard;
  427.                         setChanged();
  428.                         notifyObservers(Arrays.asList(2, cardInHand, playerIndex));
  429.  
  430. //                        playerInRound.reduceRemainingCards();
  431.  
  432.                         if (controlloJtrash()) {
  433.                             //Rimuovo visualizzazione carta pescata dal giocatore
  434.                             setChanged();
  435.                             notifyObservers(Arrays.asList(3, playerIndex));
  436.                             System.out.println(" * Scarto: " + cardInHand);
  437.                             discardedCards.addCard(cardInHand);
  438.                             break;
  439.                         }
  440.                     }
  441.  
  442.                     //altrimenti
  443.                     else {
  444.                         discardedCards.addCard(cardInHand);
  445.                         System.out.println(" * Scarto: " + cardInHand);
  446. //                        In revisione
  447. //                        setChanged();
  448. //                        notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  449.  
  450.                         setChanged();
  451.                         notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  452.                         break;
  453.                     }
  454.                 }
  455.  
  456.                 //se posizione non è occupata
  457.                 else {
  458.                     //prendo in mano carta coperta
  459.                     appCard = playerInRound.getBoardCards().get(cardInHandIndex);
  460.  
  461.                     //posiziono la carta
  462.                     playerInRound.showCard();
  463.                     System.out.println(" * Scambio: " + cardInHand + " con " + appCard + "  299");
  464.                     System.out.println(" * Indici: " + cardInHand.getRank().rankToValue() + " con " + cardInHandIndex);
  465.  
  466.                     setChanged();
  467.                     notifyObservers(Arrays.asList(8, playerIndex, cardInHandIndex));
  468.  
  469.                     sleep(1000);
  470.  
  471. //                    setChanged();
  472. //                    notifyObservers(Arrays.asList(10, playerIndex, cardInHandIndex));
  473. //                    sleep(1000);
  474.  
  475.                     playerInRound.getBoardCards().set(cardInHandIndex, cardInHand);
  476.  
  477.                     //Aggiorno visualizzazione scacchiera giocatori
  478.                     setChanged();
  479.                     notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  480.  
  481. //                    In revisione
  482. //                    setChanged();
  483. //                    notifyObservers(Arrays.asList(6, this.playerIndex));
  484.  
  485.                     if(!discardedCards.isEmpty()) {
  486. //                        In revisione
  487.                         //Aggiorno carta sul tavolo
  488. //                        setChanged();
  489. //                        notifyObservers(Arrays.asList(1, discardedCards.getLast(), playerIndex));
  490.                     }
  491.  
  492.                     cardInHand = appCard;
  493.                     setChanged();
  494.                     notifyObservers(Arrays.asList(2, cardInHand, playerIndex));
  495.  
  496.                     playerInRound.reduceRemainingCards();
  497.  
  498.                     if (controlloJtrash()) {
  499.                         //Rimuovo visualizzazione carta pescata dal giocatore
  500.                         setChanged();
  501.                         notifyObservers(Arrays.asList(3, playerIndex));
  502.                         System.out.println(" * Scarto: " + cardInHand);
  503.  
  504.                         discardedCards.addCard(cardInHand);
  505.                         break;
  506.                     }
  507.                 }
  508.             }
  509.         } while (true);
  510.  
  511.         setChanged();
  512.         notifyObservers(Arrays.asList(3, playerIndex));
  513.         sleep(200);
  514.  
  515. //        In revisione
  516. //        setChanged();
  517. //        notifyObservers(Arrays.asList(7, this.playerIndex));
  518.         setChanged();
  519.         notifyObservers(Arrays.asList(4, playerList, playerIndex, discardedCards));
  520.  
  521.         sleep(1500);
  522.  
  523.         calcolaTurno();
  524.     }
  525.  
  526.     private static void sleep(int millis) {
  527.         try {
  528.             Thread.sleep(millis);
  529.         } catch (InterruptedException e) {
  530.             throw new RuntimeException(e);
  531.         }
  532.     }
  533.  
  534.     public boolean termineRoundOTermineGioco() {
  535.         boolean giocoFinito = false;
  536.  
  537.         for(Player p: winnerPlayerList)
  538.             p.reduceBoardCardDimension();
  539.  
  540.         for (Player p : this.playerList) {
  541.             System.out.println("Dimensione Board: " + p.getNickname() + " " + p.getboardCardDimension());
  542.         }
  543.  
  544.         for(Player p: winnerPlayerList){
  545.             if (p.getboardCardDimension() == 0) {
  546.                 giocoFinito = true;
  547.                 p.incrementaPartiteVinte();
  548.                 System.out.println("Gioco terminato da: " + p.getNickname());
  549.             }
  550.         }
  551.  
  552.  
  553.         if(giocoFinito){
  554.             File file = new File(giocatoriPath);
  555.  
  556.             if(!file.exists()) {
  557.                 try {
  558.                     file.createNewFile();
  559.                 } catch (IOException e) {
  560.                     throw new RuntimeException(e);
  561.                 }
  562.             }
  563.  
  564.             HashMap<String, Integer> statisticheGiocatoriLette = new HashMap<>();
  565.  
  566.             try(BufferedReader br = new BufferedReader(new FileReader(giocatoriPath))){
  567.                 String line;
  568.  
  569.                 while((line = br.readLine()) != null){
  570.                     String[] app = line.split(" ");
  571.  
  572.                     statisticheGiocatoriLette.put(app[0], Integer.parseInt(app[1]));
  573.                 }
  574.  
  575.             } catch (IOException e) {
  576.                 throw new RuntimeException(e);
  577.             }
  578.  
  579.             for(Player p: playerList){
  580.                 statisticheGiocatoriLette.computeIfPresent(p.getNickname(), (key, value) -> {
  581.                     return Math.max(value, p.getPartiteVinte());
  582.                 });
  583.  
  584.                 statisticheGiocatoriLette.computeIfAbsent(p.getNickname(), key-> p.getPartiteVinte());
  585.             }
  586.  
  587.             FileWriter fw = null;
  588.  
  589.             try {
  590.                 fw = new FileWriter(file.getAbsoluteFile());
  591.             } catch (IOException e) {
  592.                 throw new RuntimeException(e);
  593.             }
  594.             BufferedWriter bw = new BufferedWriter(fw);
  595.  
  596.             for(String key: statisticheGiocatoriLette.keySet()) {
  597.                 try {
  598.                     bw.write(key + " " + statisticheGiocatoriLette.get(key) + "\n");
  599.                 } catch (IOException e) {
  600.                     throw new RuntimeException(e);
  601.                 }
  602.             }
  603.  
  604.             try {
  605.                 bw.close();
  606.             } catch (IOException e) {
  607.                 throw new RuntimeException(e);
  608.             }
  609.  
  610.         }
  611.  
  612.  
  613.         this.playerIndex = 0;
  614.         inizializzaGioco();
  615.  
  616.         if(giocoFinito)
  617.             return true;
  618.         else
  619.             return false;
  620.     }
  621.  
  622.     private boolean controlloJtrash() {
  623.         if (playerList.get(playerIndex).getRemainingCards() == 0) {
  624.             System.out.println(playerList.get(playerIndex).getNickname() + ": *** JTrash ***");
  625.  
  626.             if (ultimoGiro == false){
  627.                 firtPlayerIndexWinner = playerIndex;
  628.                 ultimoGiro = true;
  629.                 System.out.println("ULTIMOOOOO GIROOOOOOOOO");
  630.             }
  631.  
  632.             winnerPlayerList.add(playerList.get(playerIndex));
  633.  
  634.             return true;
  635.         }
  636.         else
  637.             return false;
  638.     }
  639.  
  640.     public void calcolaTurno() {
  641.         if(numberOfPlayer <4) {
  642.             this.playerIndex++;
  643.             if (this.playerIndex == numberOfPlayer) {
  644.                 this.playerIndex = 0;
  645.             }
  646.         }
  647.         else {
  648.             switch (playerIndex) {
  649.                 case -1:
  650.                     this.playerIndex = 0;
  651.                     break;
  652.  
  653.                 case 0:
  654.                     this.playerIndex = 3;
  655.                     break;
  656.  
  657.                 case 3:
  658.                     this.playerIndex = 1;
  659.                     break;
  660.  
  661.                 case 1:
  662.                     this.playerIndex = 2;
  663.                     break;
  664.  
  665.                 case 2:
  666.                     this.playerIndex = 0;
  667.                     break;
  668.             }
  669.         }
  670.  
  671.     }
  672.  
  673.     public int casuale0e1(){
  674.         double appNum =  Math.random();
  675.  
  676.         if(appNum >= 0.5)
  677.             return 1;
  678.         else
  679.             return 0;
  680. //        return 1;
  681.  
  682.     }
  683.  
  684.     public List<Player> getPlayerList() {
  685.         return this.playerList;
  686.     }
  687.  
  688.     public void setNumberOfPlayer(int numberOfPlayer) {
  689.         this.numberOfPlayer = numberOfPlayer;
  690.     }
  691.  
  692.     public void movimentoUmanoPescaBoardIndex(int cardIndex) {
  693.  
  694.         if(interactionOnBoard == true) {
  695.             System.out.println("Sto scambiando una carta");
  696.  
  697.             if(playerList.get(playerIndex).getBoardCards().get(cardIndex-1).getFaceUp() == false){
  698.                 Card app = playerList.get(playerIndex).getBoardCards().get(cardIndex-1);
  699. //                setChanged();
  700. //                notifyObservers(Arrays.asList(8,app));
  701.                 playerList.get(playerIndex).getBoardCards().set(cardIndex-1,cardInHand);
  702.                 cardInHand = app;
  703.                 semaphoreInteractionOnBoard.release();
  704.                 }
  705.             }
  706.  
  707.     }
  708.  
  709.     public void comandoAvviaGioco(){
  710.         System.out.println("Premuto il pulsante avvia gioco");
  711.         setChanged();
  712.         notifyObservers(Arrays.asList(99));
  713.     }
  714. }
  715.  
  716.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement