-2

現在、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;
      }
    }

州クラス

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

ゲームクラス

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

      }
    }

テストコインゲーム

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)
         {
         }
      }
    }
4

2 に答える 2

1

編集済み

の最初の行を削除するだけ player_index = (player_index + 1) % n_players; ですgame.nextPlayer()

于 2013-05-14T05:40:32.907 に答える
0

かなり多くのコードがあり、そこに私のソリューションをそのまま押し込むのは危険なので、一般的なヒントを提供します。

「ラン」の概念を考えてみましょう。プレイヤーが 1 回表を出していれば、ラン 1 です。連続して 2 回表が出ていれば、ラン 2 です。が 3 つ続けて実行された場合、実行カウントがリセットされ、状態が に設定され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;
    }
}
于 2013-05-14T04:33:41.493 に答える