Coin flipping game. How do I make it so the player can get another turn after hitting a certain number of heads?
<p>I'm currently making a program that has 4 players taking turns tossing n coins. The first player to earn 16 points wins. A player earns points each time he tosses the coins. The number of points he earns equals to the number of heads he tosses. If he tosses no heads then he loses his next turn. If he flips 3 heads then he earns an extra turn and tosses the coins again. If he tosses less than 3 heads then it is the next player’s turn. A player must earn exactly 16 points to win. If a player has 14 points and tosses 2 heads then he wins but if he tosses n heads and goes over 16 points then he loses half of his points and loses his turn too. He must have exactly 16 points to win.</p>

<p>My problem lies within the game class. I can't seem to get the player to go again if he tosses 3 heads in a row which would award him with another turn.</p>

<p><strong>Coin Class</strong></p>

<pre><code>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 &lt; 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 &lt;= 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;
   }

}   
</code></pre>

<p><strong>Player Class</strong>  </p>

<pre><code>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;
      }
    }
</code></pre>

<p><strong>State Class</strong></p>

<pre><code>public class State
    {
        public static final int NORMAL = 0;
        public static final int EXTRA_TURN = 1;
        public static final int LOSE_TURN = 2;
    }
</code></pre>

<p><strong>Game Class</strong></p>

<pre><code>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 &gt; 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);

      }
    }
</code></pre>

<p><strong>TestCoinGame</strong></p>

<pre><code>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 &lt; 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)
         {
         }
      }
    }
</code></pre>
