Java 掷硬币游戏。我该怎么做才能让玩家在击中一定数量的头部后获得另一个回合?
我目前正在制作一个程序,有4名玩家轮流投掷n枚硬币。第一个获得16分的玩家获胜。玩家每次掷硬币都会获得点数。他得到的点数等于他掷的人头数。如果他没有头晕,那么他就失去了下一轮。如果他翻了3个头,那么他就多赚了一个回合,并再次掷硬币。如果他掷的球少于3个,那么轮到下一个球员了。一名球员必须获得16分才能获胜。如果一名球员得到14分,掷2个头,那么他获胜,但如果他掷n个头,超过16分,那么他将失去一半的分数,也将失去轮次。他必须得到16分才能获胜 我的问题在于游戏课。如果球员连续抛3个头球,我似乎无法让他再次上场,这将奖励他另一回合 硬币类别Java 掷硬币游戏。我该怎么做才能让玩家在击中一定数量的头部后获得另一个回合?,java,Java,我目前正在制作一个程序,有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 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);
}
}
国家级
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 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);
}
}
游戏类
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 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);
}
}
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
我会给你一个一般性的提示,因为你有很多代码,把我的解决方案硬塞在里面是很危险的
考虑一下“跑动”的概念——如果一个玩家有一个头,那么他们就跑动1。如果他们有两个连续的头,那么他们就有2个。如果他们连续有三个,那么他们的运行计数将重置,并且他们的状态设置为EXTRA\u 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;
}
}
已编辑 只需删除第一行
player_index=(player_index+1)%n个玩家代码>
在game.nextPlayer()
中,开发一个简单的计数器,仅当玩家得到正面且其最后一次翻转也是正面时,该计数器才会增加,如果其最后一次翻转是反面,则重置计数器。如果计数器达到3,则创建一种方法为该玩家添加额外回合。是否可以像我在游戏类中使用的“ComputeTeste”方法那样完成?可能吧。老实说,这更像是一种概括。jist是这样的;如何将其放入代码库实际上取决于您。我觉得我在计算状态下做额外工作的方式应该可以工作,但我在nextPlayer方法中执行它的方式就是问题所在。我希望按照您的方式来做,但我觉得在我的代码中添加这一点会给我带来更多的问题。有没有办法修复我的nextPlayer方法来实现这一点?当我的nextPlayer()方法使用随机化器选择下一个玩家时,我一直在想如何在下一轮给连续滚动3个头的玩家。这不是我所做的吗?在第二次查看后编辑了我的答案。编辑:再看一看