Java 硬币游戏。如何让玩家在满足特定标准的情况下失去下一回合

我目前正在制作一个程序，有4名玩家轮流投掷3枚硬币。第一个获得16分的玩家获胜。玩家每次掷硬币都会获得点数。他得到的点数等于他掷的人头数。如果他没有掷头，那么他就失去了下一回合。如果他翻了3个头，那么他就多赚了一个回合，并再次掷硬币。如果他掷的球少于3个，那么轮到下一个球员了。一名球员必须获得16分才能获胜。如果一名球员得了14分，抛了2个头，他就赢了，但是如果他抛了n个头，并且超过16分，那么他就失去了一半的分数，也失去了轮次。他必须有16分才能赢

如何让玩家在下一回合被跳过？每个玩家目前都按顺序进行。汤姆，汉克，汉娜，蒂娜。如果汉克掷0个头球或超过16分，他将输掉下一轮，下一轮的顺序是汤姆，汉娜，蒂娜，汤姆，汉克，汉娜，蒂娜。我已经发布了我的代码，我需要找出如何编辑nextPlayer（）方法以满足我的需要。我相信我在computerState（）方法中所做的逻辑和代码是正确的。任何帮助都将不胜感激

游戏类

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;
      }

      public void setPlayerIndex()
      {
          player_index = randomizer.nextInt(n_players);
      }

      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 if(players[player_index].getState() == State.LOSE_TURN)
          {
              player_index = (player_index + 1) % n_players;

          }
          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(m_heads == 0)
            {
                player.setState(State.LOSE_TURN);
            }
            else if(m_heads == 3)
            {
                player.setState(State.EXTRA_TURN);
            }
            else if(m_heads == 3 && player_points > p_points)
            {
                player.setState(State.NORMAL);
            }
            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)
     {
     }
  }
}

公共类testcoingame
{
公共静态void main（字符串[]args）
{
尝试
{
国际货币单位=3；
国际n_玩家=4；
int p_点=16；
String[]name={“Hank”、“Tina”、“Hannah”、“Tom”}；
玩家[]玩家=新玩家[n_玩家]；
for（int index=0；index

在

玩家类中可以有一个布尔实例变量，用于跟踪玩家是否跳过下一回合。当您要检查该值是真是假，并且它的计算结果为真（即是，她跳过了她的回合），然后跳过您通常会为回合执行的操作，但在您继续下一个
玩家
或
回合
或您拥有的任何操作之前，将布尔值设置为假

编辑（基于用户响应）：
伪代码：
我假设你通过数组、列表或类似的东西来跟踪轮到谁。我将把它称为playerList。例如，如果我们有三个玩家，那么我们将继续循环
玩家列表[0]
，
玩家列表[1]
，
玩家列表[2]

while (gameNotOver())
{
    if (!playerList[currentPlayer].skipNextTurn())
    {
        //do what you would normally do
    }
    else
    {
        playerList[currentPlayer].setSkipNextTurn(false);
    }
}

您可以从注释代码开始；使用注释“隐藏”代码或与使用过的代码完全相同的注释并不重要。为了解释您收到的反对票：您的问题需要5分钟以上的投入。这超过了SO的典型阈值，所以我们否决了投票，继续前进。看起来家庭作业也很自然，这可能会让人们不太可能提供帮助，除非你说得对，并提出一个小问题。