Монета flipping игры. Как я могу сделать так, чтобы игрок мог получить очередной ход после удара определенного количества голов?

Question

В настоящее время я делаю программу, в которой 4 игрока по очереди бросают n монет. Первый игрок, получивший 16 очков, выигрывает. Игрок получает очки каждый раз, когда он бросает монеты. Количество очков, которые он зарабатывает, равно количеству головок, которые он бросает. Если он не бросает головы, он теряет свой следующий ход. Если он перевернет 3 головы, он заработает дополнительный ход и снова бросает монеты. Если он бросает меньше 3 голов, то это очередь следующего игрока. Игрок должен заработать ровно 16 очков, чтобы выиграть. Если игрок имеет 14 очков и бросает 2 головы, он выигрывает, но если он бросает n голов и переходит на 16 очков, то он теряет половину своих очков и теряет свою очередь тоже. У него должно быть ровно 16 очков, чтобы выиграть.

Моя проблема заключается в классе игры. Кажется, я не могу заставить игрока вернуться, если он бросает 3 головы подряд, которые будут награждать его очередным ходом.

Монета класса

import java.util.Random; 

public class Coins 
{ 
    //constants 
    private static final int HEADS = 0; 
    private static final int TAILS = 1; 


    //constants 
    private final int n_coins; 

    //instance variables 
    private int n_heads; 
    private int n_tails; 
    private Random randomizer; 

    //constructors 
    public Coins() 
    { 
     n_tails = 0; 
     n_heads = 0; 
     n_coins = 3; 
     randomizer = new Random(); 
    } 

    public Coins(int new_n_coins) throws Exception 
    { 
     if(new_n_coins < 1) 
     throw new Exception("Coins constructor number of coins is less than 1"); 
     n_coins = new_n_coins; 
     n_tails = 0; 
     n_heads = 0; 
     randomizer = new Random(); 
    } 
    //custom method 
    public void tossCoins() 
    { 
     n_tails = 0; 
     n_heads = 0; 
     for(int toss_counter = 1; toss_counter <= n_coins; toss_counter++) 
     { 

     int coin_face = randomizer.nextInt(TAILS + 1); 

     if(coin_face == HEADS) 
     n_heads++; 
     else 
     n_tails++; 

     } 
    } 
    //accessors 
    public int getNCoins() 
    { 
     return n_coins; 
    } 

    public int getNHeads() 
    { 
     return n_heads; 
    } 
    public int getNTails() 
    { 
     return n_tails; 
    } 

} 

игрока Класс

public class Player 
    { 
     private String name; 
     private int state; 
     private int points; 


     public Player() 
     { 
     state = State.NORMAL; 
     points = 0; 
     name = "no name"; 
     } 

     public Player(String new_name) throws Exception 
     { 
      state = State.NORMAL; 
      points = 0; 
      setName(new_name); 
     } 
     //accessors 
     public int getState() 
     { 
     return state; 
     } 
     public int getPoints() 
     { 
     return points; 
     } 
     public String getName() 
     { 
     return name; 
     } 
     //mutators 
     public void setState(int new_state) 
     { 
     state = new_state; 
     } 
     public void setPoints(int new_points) 
     { 
     points = new_points; 
     } 
     public void setName(String new_name) throws Exception 
     { 
     if(new_name.length() == 0) 
      throw new Exception("setName error - empty name"); 
     name = new_name; 
     } 
    } 

Класс State

public class State 
    { 
     public static final int NORMAL = 0; 
     public static final int EXTRA_TURN = 1; 
     public static final int LOSE_TURN = 2; 
    } 

Game Class

import java.util.Random; 
public class Game 
    { 
     private Random randomizer; 
     private final int n_players; 
     private final int m_coins; 
     private final int p_points; 
     private int player_index; 
     private boolean game_over; 

     public Game() 
     { 
     n_players = 4; 
     m_coins = 3; 
     p_points = 16; 
     game_over = false; 
     randomizer = new Random(); 
     player_index = randomizer.nextInt(n_players); 
     } 

     public Game(int new_m_coins, int new_n_players, int new_p_points) 
     { 
      n_players = new_n_players; 
      m_coins = new_m_coins; 
      p_points = new_p_points; 
      game_over = false; 
      randomizer = new Random(); 
      player_index = randomizer.nextInt(n_players); 
     } 

     public int getPlayerIndex() 
     { 
      return player_index; 
     } 
     //write mutators 


     public boolean gameOver() 
     { 

      return game_over; 

     } 

     public int nextPlayer(Player[] players) 
     { 
      player_index = (player_index + 1) % n_players; 

      if(players[player_index].getState() == State.EXTRA_TURN) 
      { 
      players[player_index].setState(State.NORMAL); 
      } 
      else 
      { 
       player_index = (player_index + 1) % n_players; 
      } 

      while(players[player_index].getState() != State.NORMAL) 
      { 
       players[player_index].setState(State.NORMAL); 
       player_index = (player_index + 1) % n_players; 
      } 
      return player_index; 
     } 
     public void computeState(Player player, int m_heads, int oldPoints, int newPoints) 
     { 

      int player_points = player.getPoints(); 

      if(player_points == p_points) 
       game_over = true; 
      else if(player_points > p_points) 
      { 
       player.setPoints(player_points/2); 
       player.setState(State.LOSE_TURN); 
      } 
      else if(player_points == oldPoints + m_heads) 
      { 
       player.setState(State.EXTRA_TURN); 
      } 
      else 
       player.setState(State.NORMAL); 

     } 
    } 

TestCoinGame

public class testcoingame 
    { 
     public static void main(String[] args) 
     { 
     try 
     { 
      int m_coins = 3; 
      int n_players = 4; 
      int p_points = 16; 
      String [] names = {"Hank", "Tina", "Hannah", "Tom"}; 
      Player [] players = new Player[n_players]; 

      for(int index = 0; index < players.length; index++) 
      players[index] = new Player(names[index]); 

      Coins coins = new Coins(); 
      Game game = new Game(); 
      int player_index; 
      do 
      { 
       player_index = game.nextPlayer(players); 
       System.out.printf("It is %s's turn\n", players[player_index].getName()); 
       System.out.printf("%s has %d points\n", players[player_index].getName(), 
       players[player_index].getPoints()); 

       coins.tossCoins(); 
       int n_heads = coins.getNHeads(); 
       System.out.printf("%s tossed %d heads\n", 
       players[player_index].getName(), n_heads); 

       int old_points = players[player_index].getPoints(); 
       int new_points = old_points + n_heads; 
       players[player_index].setPoints(new_points); 
       game.computeState(players[player_index], n_heads, old_points, new_points); 
       System.out.printf("%s has %d points\n", players[player_index].getName(),players[player_index].getPoints()); 
      } 
      while(!game.gameOver()); 
      System.out.printf("%s wins!\n", players[player_index].getName()); 
     } 
     catch(Exception ex) 
     { 
     } 
     } 
    } 

Answer 1

Edited

Просто удалите первую строку player_index = (player_index + 1) % n_players; в game.nextPlayer()

Answer 2

Я дам вам общую подсказку, как вы получили довольно много коды, и shoehorning моего решения там как было бы опасно.

Рассмотрите понятие «бег» - если у игрока есть одна голова, тогда они набегают 1. Если у них две головы подряд, то они находятся на пробеге 2. Если у них было три подряд, то их счет запуска сбрасывается, и их состояние установлено на EXTRA_TURN.

Что-то вроде этого:

private int runCount = 0; 
// should only *ever* be called after a heads 
public void onRun(boolean hadHeads) { 
    if(hadHeads) { 
     runCount++; 
     if(runCount == 3) { 
      runCount = 0; 
      setState(EXTRA_TURN); 
      System.out.println("Three heads in a row - you get an extra turn!"); 
    } else { 
     runCount = 0; 
    } 
}