使用Java实现生命游戏串行代码示例

庞红叶

目录

• 生命游戏介绍
• 一、效果展示
• 1.初始界面
• 2.启动游戏
• 二、代码实现
• 三、代码解释
• 1.常量设置
• 2.图形化
• 3.计算“生死”情况与统计邻居细胞数量
• 四、结语

生命游戏介绍

生命游戏，是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。

一个方格游戏棋盘上，每个方格中都可放置一个生命细胞，每个生命细胞只有两种状态：“生”或“死”（状态往往随机决定）。然后细胞根据某些规则，计算出下一代每个细胞的状态，并且不停迭代。

在游戏的进行中，杂乱无序的细胞会逐渐演化出各种精致、有形的结构；这些结构往往有很好的对称性，而且每一代都在变化形状。一些形状已经锁定，不会逐代变化。有时，一些已经成形的结构会因为一些无序细胞的“入侵”而被破坏。但是形状和秩序经常能从杂乱中产生出来。

现设定其规则是：

• 如果一个细胞周围有3个细胞为生（一个细胞周围共有8个细胞），则该细胞为生（即该细胞若原先为死，则转为生，若原先为生，则保持不变） 。
•  如果一个细胞周围有2个细胞为生，则该细胞的生死状态保持不变；
•  在其它情况下，该细胞为死（即该细胞若原先为生，则转为死，若原先为死，则保持不变）

下面就此规则，使用java来编写100*100的棋盘，并使用简单的JavaFX来实现简易图形化来观察游戏的迭代过程。

一、效果展示

1.初始界面

100*100的棋盘上随机生成“生”和“死”细胞（黑为生，白为死）。底部有“运行”和“暂停”按钮。

2.启动游戏

二、代码实现

1. package com.itheima.gameOfLife;
2. import javafx.animation.AnimationTimer;
3. import javafx.application.Application;
4. import javafx.scene.Scene;
5. import javafx.scene.control.Button;
6. import javafx.scene.layout.BorderPane;
7. import javafx.scene.layout.Pane;
8. import javafx.scene.paint.Color;
9. import javafx.scene.shape.Rectangle;
10. import javafx.stage.Stage;
12. import java.util.Random;
14. public class GameOfLife extends Application {
15. private static final int GRID_SIZE = 100;
16. private static final int CELL_SIZE = 10; // 每个细胞的像素大小
17. private static final int GENERATIONS = 1000; // 演化代数
18. private int[][] grid = new int[GRID_SIZE][GRID_SIZE]; // 当前代棋盘
19. private int[][] nextGrid = new int[GRID_SIZE][GRID_SIZE]; // 下一代棋盘
20. private Pane pane = new Pane();
21. private AnimationTimer timer;
22. private boolean isRunning = false; // 运行状态标志
24. public static void main(String[] args) {
25. launch(args);
26. }
28. @Override
29. public void start(Stage primaryStage) {
30. initializeGrid(); // 随机初始化棋盘
32. // 创建JavaFX界面
33. BorderPane root = new BorderPane();
34. Scene scene = new Scene(root, GRID_SIZE * CELL_SIZE, GRID_SIZE * CELL_SIZE + 50);
35. primaryStage.setTitle("生命游戏");
36. primaryStage.setScene(scene);
38. // 创建按钮，便于停止观察当前棋盘状态
39. Button startButton = new Button("运行");
40. Button pauseButton = new Button("暂停");
42. startButton.setOnAction(e -> startGame());
43. pauseButton.setOnAction(e -> pauseGame());
45. // 设置按钮位置
46. root.setBottom(new Pane(startButton, pauseButton));
47. Pane buttonPane = new Pane();
48. buttonPane.getChildren().addAll(startButton, pauseButton);
49. buttonPane.setPrefSize(GRID_SIZE * CELL_SIZE, 50);
50. buttonPane.setLayoutY(GRID_SIZE * CELL_SIZE);
51. startButton.setLayoutX(20);
52. pauseButton.setLayoutX(80);
53. root.setCenter(pane);
54. root.setBottom(buttonPane);
56. primaryStage.show();
58. drawGrid(); // 绘制初始棋盘
60. // 使用AnimationTimer更新棋盘
61. timer = new AnimationTimer() {
62. private int generationCount = 0;
64. @Override
65. public void handle(long now) {
66. if (isRunning && generationCount < GENERATIONS) {
67. runGeneration(); // 运行一代
68. drawGrid(); // 更新绘制
69. generationCount++;
70. } else if (generationCount >= GENERATIONS) {
71. stop(); // 结束动画
72. }
73. }
74. };
75. }
77. // 随机初始化棋盘
78. private void initializeGrid() {
79. Random random = new Random();
80. for (int i = 0; i < GRID_SIZE; i++) {
81. for (int j = 0; j < GRID_SIZE; j++) {
82. grid[i][j] = random.nextInt(2); // 随机生成0或1
83. }
84. }
85. }
87. // 启动
88. private void startGame() {
89. if (!isRunning) {
90. isRunning = true; // 设置为运行状态
91. timer.start(); // 启动计时器
92. }
93. }
95. // 暂停
96. private void pauseGame() {
97. isRunning = false; // 设置为暂停状态
98. timer.stop(); // 停止计时器
99. }
101. // 运行一代
102. private void runGeneration() {
103. for (int i = 0; i < GRID_SIZE; i++) {
104. for (int j = 0; j < GRID_SIZE; j++) {
105. int liveNeighbors = countLiveNeighbors(i, j);
106. if (grid[i][j] == 1) { // 当前细胞是活的
107. nextGrid[i][j] = (liveNeighbors == 2 || liveNeighbors == 3) ? 1 : 0;
108. } else { // 当前细胞是死的
109. nextGrid[i][j] = (liveNeighbors == 3) ? 1 : 0;
110. }
111. }
112. }
113. copyNextGridToCurrent();
114. }
116. // 计算邻居活细胞数量
117. private int countLiveNeighbors(int row, int col) {
118. int liveNeighbors = 0;
119. for (int i = -1; i <= 1; i++) {
120. for (int j = -1; j <= 1; j++) {
121. if (i == 0 && j == 0) continue; // 跳过自身
122. int newRow = (row + i + GRID_SIZE) % GRID_SIZE; // 考虑边界
123. int newCol = (col + j + GRID_SIZE) % GRID_SIZE;
124. liveNeighbors += grid[newRow][newCol];
125. }
126. }
127. return liveNeighbors;
128. }
130. // 将nextGrid复制到grid
131. private void copyNextGridToCurrent() {
132. for (int i = 0; i < GRID_SIZE; i++) {
133. System.arraycopy(nextGrid[i], 0, grid[i], 0, GRID_SIZE);
134. }
135. }
137. // 绘制当前棋盘状态
138. private void drawGrid() {
139. pane.getChildren().clear(); // 清除旧的图形
140. for (int i = 0; i < GRID_SIZE; i++) {
141. for (int j = 0; j < GRID_SIZE; j++) {
142. Rectangle cell = new Rectangle(j * CELL_SIZE, i * CELL_SIZE, CELL_SIZE, CELL_SIZE);
143. cell.setFill(grid[i][j] == 1 ? Color.BLACK : Color.WHITE); // 黑色表示活细胞，白色表示死细胞
144. cell.setStroke(Color.GRAY); //细胞之间的边框
145. pane.getChildren().add(cell); // 将细胞添加到面板
146. }
147. }
148. }
149. }

复制代码

三、代码解释

1.常量设置

1. private static final int GRID_SIZE = 100;
2. private static final int CELL_SIZE = 10; // 每个细胞的像素大小
3. private static final int GENERATIONS = 1000; // 演化代数
4. private int[][] grid = new int[GRID_SIZE][GRID_SIZE]; // 当前代棋盘
5. private int[][] nextGrid = new int[GRID_SIZE][GRID_SIZE]; // 下一代棋盘
6. private Pane pane = new Pane();
7. private AnimationTimer timer;
8. private boolean isRunning = false; // 运行状态标志

复制代码

GRID_SIZE: 定义了棋盘的大小，当前设置为 

1. 100

复制代码

。即棋盘是一个 

1. 100 x 100

复制代码

 的格子。

CELL_SIZE: 定义了每个细胞的像素大小，当前设置为 

1. 10

复制代码

。因此，每个细胞在界面上将显示为一个 

1. 10 x 10

复制代码

 像素的正方形。

棋盘总大小: 因此，整个棋盘的实际像素大小为：

• 宽度: 
  1. GRID_SIZE * CELL_SIZE = 100 * 10 = 1000

  复制代码
   像素
• 高度: 
  1. GRID_SIZE * CELL_SIZE = 100 * 10 = 1000

  复制代码
   像素

2.图形化

1. // 创建JavaFX界面
2. BorderPane root = new BorderPane();
3. Scene scene = new Scene(root, GRID_SIZE * CELL_SIZE, GRID_SIZE * CELL_SIZE + 50);
4. primaryStage.setTitle("生命游戏");
5. primaryStage.setScene(scene);
7. // 创建按钮
8. Button startButton = new Button("运行");
9. Button pauseButton = new Button("暂停");
11. startButton.setOnAction(e -> startGame());
12. pauseButton.setOnAction(e -> pauseGame());
14. // 将按钮放置在界面底部
15. root.setBottom(new Pane(startButton, pauseButton));
16. Pane buttonPane = new Pane();
17. buttonPane.getChildren().addAll(startButton, pauseButton);
18. buttonPane.setPrefSize(GRID_SIZE * CELL_SIZE, 50);
19. buttonPane.setLayoutY(GRID_SIZE * CELL_SIZE);
20. startButton.setLayoutX(20);
21. pauseButton.setLayoutX(80);
22. root.setCenter(pane);
23. root.setBottom(buttonPane);
25. primaryStage.show();
27. drawGrid(); // 绘制初始棋盘
29. // 使用AnimationTimer更新棋盘
30. timer = new AnimationTimer() {
31. private int generationCount = 0;
33. @Override
34. public void handle(long now) {
35. if (isRunning && generationCount < GENERATIONS) {
36. runGeneration(); // 运行一代
37. drawGrid(); // 更新绘制
38. generationCount++;
39. } else if (generationCount >= GENERATIONS) {
40. stop(); // 结束动画
41. }
42. }
43. };
44. }

复制代码

上面这段代码是JavaFX的核心部分，创建棋盘界面和处理游戏逻辑。部分解释已经在代码中注释出来。

在“使用AnimationTimer更新棋盘”这部分中，创建了一个 

1. AnimationTimer

复制代码

 对象，并重写其handle方法，用于定时更新棋盘状态。

3.计算“生死”情况与统计邻居细胞数量

1. //根据规则判断生死
2. private void runGeneration() {
3. for (int i = 0; i < GRID_SIZE; i++) {
4. for (int j = 0; j < GRID_SIZE; j++) {
5. int liveNeighbors = countLiveNeighbors(i, j);
6. if (grid[i][j] == 1) { // 当前细胞是活的
7. nextGrid[i][j] = (liveNeighbors == 2 || liveNeighbors == 3) ? 1 : 0;
8. } else { // 当前细胞是死的
9. nextGrid[i][j] = (liveNeighbors == 3) ? 1 : 0;
10. }
11. }
12. }
13. copyNextGridToCurrent();
14. }
16. // 计算邻居活细胞数量
17. private int countLiveNeighbors(int row, int col) {
18. int liveNeighbors = 0;
19. for (int i = -1; i <= 1; i++) {
20. for (int j = -1; j <= 1; j++) {
21. if (i == 0 && j == 0) continue; // 跳过自身
22. int newRow = (row + i + GRID_SIZE) % GRID_SIZE; // 考虑边界
23. int newCol = (col + j + GRID_SIZE) % GRID_SIZE;
24. liveNeighbors += grid[newRow][newCol];
25. }
26. }
27. return liveNeighbors;
28. }

复制代码

比较简单的代码，使用最基本的双重循环来遍历整个棋盘的细胞，得到其邻居的数量用于判断下一次迭代的状态。

在“计算邻居活细胞数量”中，用取模运算来处理边界情况，使得棋盘具有环绕效果。例如，如果当前细胞在第一行，且要检查上方的细胞，则通过取模确保索引循环回到棋盘的底部。

四、结语

以上主要浅显的实现了生命游戏的基本逻辑，并用简单的图形可视化来创建一个直观的界面来观察细胞的迭代，更直接的观察到由简单规则产生的复杂动态行为。在这个串行的生命游戏基础上，后续可以改写为多线程的生命游戏，并通过一些方法来比对串行与并行代码的效率。

到此这篇关于使用Java实现生命游戏串行的文章就介绍到这了,更多相关Java生命游戏串行代码内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

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

交受章多图

路过，支持一下