博饼小游戏

题目：博饼小游戏

目的：

• 掌握java面向对象编程
  
• 选择合适的数据结构实现需求
  
• 熟练使用各种控制结构
  

内容：

设计并编程实现博饼小游戏，游戏规则如下：
游戏使用骰子一副（6个），参与游戏的玩家轮流依次掷骰子，看骰子点数得饼：

• 有1个“四点”，得“一秀”饼
  
• 有2个“四点”，得“二举”饼
  
• 有3个“四点”，得“三红”饼
  
• 有4个相同点数（除四点外），得“四进”饼
  
• 若骰子点数分别为1-6顺序排列，得“对堂”饼
  
• 玩家得“状元”饼的情况有几种，其等级按从小到大
  排列如下：
  
  
  
  • 有4个“四点”，得“状元”
    
  • 有5个相同点数的，得“五子登科”
    
  • 有4个“四点”，加上2个“一点”，得“状元插金花”
    
  
  
• 特殊情况: 若玩家掷出6个“四点”得“六杯红”，则直接夺得所有奖品
  

程序要求：

• 游戏开始时，可由玩家设置奖品数，例如：设“状元”1个，“对堂”2个，“三红”4个，“四进”8个，“二举”16个，“一秀”32个
  
• 游戏开始时，可设定玩家人数，游戏中应提示各位玩家轮流依次掷骰子，例如“1号玩家请掷筛子：y”
  
• 游戏中，应显示玩家每次掷得的点数，并显示得奖情况。例如“1,2,3,5,5,6   无奖，继续努力”；“1,4,4,3,5,6  二举，恭喜”。程序应能保存各位玩家得奖的记录
  
• 游戏设定的“一秀”、“二举”、“三红”、“四进”、“对堂”的奖品若领完，后续玩家若再掷出此类点数，不再得奖。但在上述奖品领完前，“状元饼”采取追饼的方式，即在其他奖品分完前，后一个掷得“状元”的人若比前一个“状元”等级大，则可追得“状元饼”
  
• 所有奖品分完，游戏结束。或者某玩家掷出6个“四点”，夺得所有奖品，其他玩家将同时失去所有奖品，游戏结束
  
• 游戏结束后，应输出所有玩家得奖情况
  

各种得奖情况图示


代码实现

Prize类（奖品对象）

1. package BocakeGame;
3. import java.util.Scanner;
5. public class Prize { //奖品对象
6.     //牺牲一个存储空间，增加程序可读性
7.     public static int reward1; //一秀
8.     public static int reward2; //二举
9.     public static int reward3; //三红
10.     public static int reward4; //四进
11.     public static int reward5; //对堂
12.     public static int reward6; //状元 五子登科 状元插金花 六杯红
14.     public Prize() { //初始化
15.         reward1 = reward2 = reward3 = reward4 = reward5 = reward6 = 0;
16.     }
18.     public void setPrizeNumber(Scanner scanner) {
19.         System.out.println("请设置奖品数量（如果输入负数或零将变为默认设置）：");
20.         System.out.println("（1）状元奖数固定为：1");
21.         reward6 = 1;
22.         System.out.print("（2）请设置对堂奖数：");
23.         reward5 = scanner.nextInt();
24.         System.out.print("（3）请设置三红奖数：");
25.         reward3 = scanner.nextInt();
26.         System.out.print("（4）请设置四进奖数：");
27.         reward4 = scanner.nextInt();
28.         System.out.print("（5）请设置二举奖数：");
29.         reward2 = scanner.nextInt();
30.         System.out.print("（6）请设置一秀奖数：");
31.         reward1 = scanner.nextInt();
32.     }
33. }

复制代码

PlayGame类（玩游戏对象）

1. package BocakeGame;
3. import java.util.Scanner;
5. public class PlayGame { //玩游戏
6.     public static int num; //游戏玩家数（静态属性）
8.     public static void setPlayerNumber(Scanner scanner) { //设置游戏玩家数（静态属性）
9.         System.out.print("请设置玩家人数(6~10)：");
10.         num = scanner.nextInt();
11.         if (num < 6) num = 6;
12.         else if (num > 10) num = 10;
13.     }
15.     public static void main(String[] args) { //运行游戏
16.         Scanner scanner = new Scanner(System.in); //创建一个全局扫描器对象
17.         Dice dice = new Dice(); //创建骰子对象
18.         Prize prize = new Prize(); //创建奖品对象
19.         prize.setPrizeNumber(scanner); //设置奖品数量
20.         setPlayerNumber(scanner); //设置玩家人数
21.         scanner.close(); //关闭全局扫描器对象 后面不再需要输入了
23.         Player[] players = new Player[num]; //创建num个玩家
24.         for (int i = 0; i < num; i++) {
25.             players[i] = new Player(); //创建玩家对象
26.             players[i].id = i + 1; //给每个玩家编号
27.         }
28.         for (int i = 0; i < num; i++) {
29.             players[i].play(dice, prize); //每个人玩游戏
30.             if (players[i].flag == 1) { //游戏结束 退出循环
31.                 break;
32.             }
33.         }
34.         if (players[0].winner != -1) { //最后输出状元玩家
35.             System.out.println("状元是" + players[0].winner + "号玩家！");
36.         } else System.out.println("很遗憾没有人获得状元！");
37.     }
38. }

复制代码

Player类（玩家对象）

1. package BocakeGame;
3. public class Player { //玩家对象
4.     public int id; //玩家号码
5.     public int[] result = new int[6]; //记录玩家结果 一秀 二举 三红 四进 对堂 状元
6.     public static int grade; //记录玩家追饼情况
7.     public static int winner; //记录状元获得者
8.     public int flag; //记录玩家是否夺得六杯红
10.     public Player() { //初始化玩家
11.         id = 0;
12.         for (int i = 0; i < 6; i++) {
13.             result[i] = 0;
14.         }
15.         grade = 0;
16.         winner = -1;
17.         flag = 0;
18.     }
20.     public void play(Dice dice, Prize prize) { //每个人只能投一次骰子 之后判断玩家所获得的奖励
21.         //牺牲一个存储空间，增加程序可读性
22.         int[] roll = {0, 0, 0, 0, 0, 0, 0}; //记录六个点数出现的次数
23.         System.out.println(id + "号玩家掷骰子");
24.         dice.rollDice(); //掷骰子
25.         dice.printDice(); //打印出骰子的点数
26.         for (int i = 0; i < 6; i++) { //记录骰子的点数
27.             roll[dice.dice[i]]++;
28.         }
29.         //判断玩家能否获得奖励
30.         //六杯红
31.         if (roll[4] == 6) {
32.             System.out.println("六杯红，恭喜获得所有奖品！");
33.             result[5] = 1;
34.             winner = id;
35.             flag = 1;
36.             return;
37.         }
38.         //状元插金花
39.         else if (roll[4] == 4 && roll[1] == 2 && grade < 3) {
40.             System.out.println("状元插金花，有机会获得状元！");
41.             prize.reward6 = 0;
42.             result[5] = 1;
43.             winner = id;
44.             grade = 3;
45.         }
46.         //五子登科
47.         else if ((roll[1] == 5 || roll[2] == 5 || roll[3] == 5 || roll[5] == 5 || roll[6] == 5) && (grade < 2)) {
48.             System.out.println("五子登科，有机会获得状元！");
49.             prize.reward6 = 0;
50.             result[5] = 1;
51.             winner = id;
52.             grade = 2;
53.         }
54.         //状元
55.         else if (roll[4] == 4 && grade < 1) {
56.             System.out.println("状元，有机会获得状元！");
57.             prize.reward6 = 0;
58.             result[5] = 1;
59.             winner = id;
60.             grade = 1;
61.         }
62.         //对堂
63.         else if (roll[1] == 1 && roll[2] == 1 && roll[3] == 1 && roll[4] == 1 && roll[5] == 1 && roll[6] == 1) {
64.             if (prize.reward5 == 0) {
65.                 System.out.println("恭喜获得对堂，但是奖品没有了！");
66.             } else {
67.                 result[4] = 1;
68.                 prize.reward5--;
69.                 System.out.println("恭喜获得对堂！");
70.             }
71.         }
72.         //四进
73.         else if (roll[1] == 4 || roll[2] == 4 || roll[3] == 4 || roll[5] == 4 || roll[6] == 4) {
74.             if (prize.reward4 == 0) {
75.                 System.out.println("恭喜获得四进，但是奖品没有了！");
76.             } else {
77.                 result[3] = 1;
78.                 prize.reward4--;
79.                 System.out.println("恭喜获得四进！");
80.             }
81.         }
82.         //三红
83.         else if (roll[4] == 3) {
84.             if (prize.reward3 == 0) {
85.                 System.out.println("恭喜获得三红，但是奖品没有了！");
86.             } else {
87.                 result[2] = 1;
88.                 prize.reward3--;
89.                 System.out.println("恭喜获得三红！");
90.             }
91.         }
92.         //二举
93.         else if (roll[4] == 2) {
94.             if (prize.reward2 == 0) {
95.                 System.out.println("恭喜获得二举，但是奖品没有了！");
96.             } else {
97.                 result[1] = 1;
98.                 prize.reward2--;
99.                 System.out.println("恭喜获得二举！");
100.             }
101.         }
102.         //一秀
103.         else if (roll[4] == 1) {
104.             if (prize.reward1 == 0) {
105.                 System.out.println("恭喜获得一秀，但是奖品没有了！");
106.             } else {
107.                 result[0] = 1;
108.                 prize.reward1--;
109.                 System.out.println("恭喜获得一秀！");
110.             }
111.         } else {
112.             System.out.println("很遗憾，没有获奖！");
113.         }
114.         //判断游戏是否结束
115.         if (prize.reward1 == 0 && prize.reward2 == 0 && prize.reward3 == 0 && prize.reward4 == 0 && prize.reward5 == 0 && prize.reward6 == 0) {
116.             System.out.println("奖品全发完啦，游戏结束！");
117.             flag = 1;
118.             return;
119.         }
120.     }
121. }

复制代码

Dice类（骰子对象）

1. package BocakeGame;
3. public class Dice { //骰子对象
4.     public int[] dice = new int[6]; //六次掷骰子的点数
6.     public Dice() { //初始化骰子点数
7.         for (int i = 0; i < 6; i++) {
8.             dice[i] = 0;
9.         }
10.     }
12.     public void printDice() { //打印骰子点数
13.         System.out.print("骰子的点数为：");
14.         for (int i = 0; i < 6; i++)
15.             System.out.print(dice[i] + " ");
16.         System.out.println();
17.     }
19.     public void rollDice() { //随机扔骰子
20.         for (int i = 0; i < 6; i++) {
21.             dice[i] = 1 + (int) (Math.random() * 6); //产生[1,7)的随机整数
22.         }
23.     }
24. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！