Go语言视频零基础入门到精通

javalearner

以前总是很向往写游戏程序，但是从不知道写游戏其实也是一个很艰苦的过程。

       这次重写的推箱子，所实现的功能不多。仅仅实现了：玩家和箱子的正确移动，包括对撞墙的检测；当所有的箱子都到达目的地的时候，就提示“恭喜过关”；玩家可以用键盘的“上下左右”来控制前进的方向；整个代码的思路是：把游戏界面看成一个二维的数组，然后用一个布尔型的数组boolean a[][]去填充它。其中，玩家、箱子和墙为true，目的地为false。所有的界面元素都是个Node类的对象，当a[Node.x][Node.y]为true时，就代表玩家遇到了箱子或者是墙，然后再去实现相关的算法.。

下面是代码：

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.awt.geom.*;
  
   
   

     
   

     
   
  

1. 
   
2. public class PushBox {
   
3. public static void main(String args[]) {
   
4.   GameFrame frame = new GameFrame();
   
5.   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   
6.   frame.show();
   
7.   JOptionPane.showMessageDialog(null,
   
8.     "红色方块代表玩家
9. 把紫色箱子推到蓝框中过关
10. 方向键控制方向
11. 不能返回到上一步");
    
12. }
    
13. }
    
14. class GameFrame extends JFrame {
    
15. static int num;
    
16. public GameFrame() {
    
17.   setSize(400, 400);
    
18.   Container c = getContentPane();
    
19.   GamePanel panel1 = new GamePanel();
    
20.   c.add(panel1);
    
21. }
    
22. }
    
23. class GamePanel_2 extends JPanel {
    
24. public GamePanel_2() {
    
25.   this.setBackground(Color.BLACK);
    
26. }
    
27. }
    
28. class GamePanel extends JPanel implements KeyListener {
    
29. int width = 400;
    
30. int height = 400;
    
31. Box b;
    
32. Node man;
    
33. Node box;
    
34. Node[] target;
    
35. int d = 1;// 移动的步长
    
36. int sideX = 25;
    
37. int sideY = 25;
    
38. GameFrame frame;
    
39. ArrayList wallList;
    
40. // 初始化界面元素
    
41. public GamePanel() {
    
42.   this.setBackground(Color.WHITE);
    
43.   b = new Box(this, width / sideX, width / sideY);
    
44.   this.man = b.man;
    
45.   this.box = b.box;
    
46.   this.target = b.target;
    
47.   this.wallList = b.wallList;
    
48.   this.setFocusable(true);
    
49.   this.addKeyListener(this);
    
50. }
    
51. public void paintComponent(Graphics g) {
    
52.   super.paintComponent(g);
    
53.   Graphics2D g2 = (Graphics2D) g;
    
54.   // 绘制游戏背景,玩家和箱子.
    
55.   g2.setColor(Color.white);
    
56.   g2.fillRect(0, 0, width, height);
    
57.   g2.setColor(Color.RED);
    
58.   draw(g2, man);
    
59.   g2.setColor(Color.MAGENTA);
    
60.   draw(g2, box);
    
61.   draw(g2, b.box1);
    
62.   draw(g2, b.box2);
    
63.   draw(g2, b.box3);
    
64.   // 绘制墙壁
    
65.   g2.setColor(Color.darkGray);
    
66.   for (int i = 0; i < wallList.size(); i++) {
    
67.    Node n = (Node) wallList.get(i);
    
68.    draw(g2, n);
    
69.   }
    
70.   // 绘制目的地.
    
71.   g2.setColor(Color.blue);
    
72.   for (int i = 0; i < target.length; i++) {
    
73.    g2.drawRect(target[i].x * sideX, target[i].y * sideY, sideX - 1,
    
74.      sideY - 1);
    
75.    Ellipse2D e = new Ellipse2D.Double(target[i].x * sideX, target[i].y
    
76.      * sideY, sideX - 1, sideY - 1);
    
77.    g2.draw(e);
    
78.   }
    
79. }
    
80. public void keyPressed(KeyEvent e) {
    
81.   int keycode = e.getKeyCode();
    
82.   if (keycode == KeyEvent.VK_UP) {
    
83.    Box.direction = 1;// 要先确定方向再移动
    
84.    b.move(0, -d);
    
85.   } else if (keycode == KeyEvent.VK_RIGHT) {
    
86.    Box.direction = 2;
    
87.    b.move(d, 0);
    
88.   } else if (keycode == KeyEvent.VK_DOWN) {
    
89.    Box.direction = 3;
    
90.    b.move(0, d);
    
91.   } else if (keycode == KeyEvent.VK_LEFT) {
    
92.    Box.direction = 4;
    
93.    b.move(-d, 0);
    
94.   }
    
95. }
    
96. public void keyReleased(KeyEvent e) {
    
97. }
    
98. public void keyTyped(KeyEvent e) {
    
99. }
    
100. public void draw(Graphics2D g, Node n) {
     
101.   g.fillRect(n.x * sideX, n.y * sideY, sideX - 1, sideY - 1);
     
102. }
     
103. }
     
104. class Node {
     
105. int x;
     
106. int y;
     
107. public Node(int x, int y) {
     
108.   this.x = x;
     
109.   this.y = y;
     
110. }
     
111. }
     
112. class Box {
     
113. boolean end = false;
     
114. int maxX;
     
115. int maxY;
     
116. boolean[][] a;// 整个游戏区域就是一个布尔型的二维数组
     
117. Node man;
     
118. Node[] target;// 储存目的地
     
119. Node box;
     
120. Node box1;
     
121. Node box2;
     
122. Node box3;
     
123. Node[] wall;// 储存墙
     
124. Node[] b;// 数组b储存箱子.
     
125. GamePanel panel;
     
126. // 当一个箱子推到目的时,list储存目的地节点.
     
127. ArrayList list = new ArrayList();
     
128. // 储存墙.
     
129. ArrayList wallList = new ArrayList();
     
130. public static int left = 4;
     
131. public static int up = 1;
     
132. public static int right = 2;
     
133. public static int down = 3;
     
134. public static int direction = 0;
     
135. // 在BOX的构造函数中，用布尔型的二维数组填充游戏画面,同时，定义玩家，箱子和目的地。
     
136. public Box(GamePanel p, int maxX, int maxY) {
     
137.   panel = p;
     
138.   this.maxX = maxX;
     
139.   this.maxY = maxY;
     
140.   a = new boolean[maxX][maxY];
     
141.   for (int i = 0; i < maxX; i++) {
     
142.    for (int j = 0; j < maxY; j++) {
     
143.     a[i][j] = false;
     
144.    }
     
145.   }
     
146.   // 定义箱子，玩家和目的地的初始位置
     
147.   int x = 5;
     
148.   int y = 8;
     
149.   man = new Node(x, y);
     
150.   a[x][y] = true;
     
151.   // 定义游戏中的箱子的位置,并置为TRUE;
     
152.   b = new Node[4];
     
153.   box = new Node(10, 9);
     
154.   a[10][9] = true;
     
155.   b[0] = box;
     
156.   box1 = new Node(6, 7);
     
157.   a[6][7] = true;
     
158.   b[1] = box1;
     
159.   box2 = new Node(11, 8);
     
160.   a[11][8] = true;
     
161.   b[2] = box2;
     
162.   box3 = new Node(8, 8);
     
163.   a[8][8] = true;
     
164.   b[3] = box3;
     
165.   // 定义墙和目的地.
     
166.   createWall();
     
167.   target = new Node[4];
     
168.   target[0] = new Node(7, 9);
     
169.   target[3] = new Node(6, 9);
     
170.   target[1] = new Node(7, 10);
     
171.   target[2] = new Node(6, 10);
     
172. }
     
173. public void move(int d1, int d2) {
     
174.   a[man.x][man.y] = false;
     
175.   man.x += d1;
     
176.   man.y += d2;
     
177.   // 如果玩家遇到墙,则不能前进;否则,推动箱子.
     
178.   if (a[man.x][man.y]) {
     
179.    if (isOutofwall()) {
     
180.     moveDisable(man, d1, d2);
     
181.    } else {
     
182.     for (int i = 0; i < b.length; i++) {
     
183.      if (man.x == b[i].x && man.y == b[i].y) {
     
184.       b[i].x += d1;
     
185.       b[i].y += d2;
     
186.       // 利用一个IF判断箱子是否重叠,如果重叠,则不能前进;
     
187.       if (a[b[i].x][b[i].y]) {
     
188.        moveDisable(man, d1, d2);
     
189.        moveDisable(b[i], d1, d2);
     
190.       } else {
     
191.        // 一定要将箱子的位置置为true,不然箱子移动一次以后就不再移动.
     
192.        a[b[i].x][b[i].y] = true;
     
193.        // 如果箱子全部推到位,则游戏结束
     
194.        // 在这个程序里,isArrive方法要在箱子置为true以后使用.
     
195.        isArrive(b[i]);
     
196.       }
     
197.      }
     
198.     }
     
199.    }
     
200.   }
     
201.   panel.repaint();
     
202.   if (end) {
     
203.    JOptionPane.showMessageDialog(null, "over");
     
204.    System.exit(0);
     
205.   }
     
206. }
     
207. // 生成游戏地图
     
208. public void createWall() {
     
209.   for (int i = 5; i < 12; i++) {
     
210.    Node walls = new Node(i, 5);
     
211.    wallList.add(walls);
     
212.   }
     
213.   for (int i = 11; i < 14; i++) {
     
214.    Node walls = new Node(i, 6);
     
215.    wallList.add(walls);
     
216.   }
     
217.   wallList.add(new Node(13, 7));
     
218.   wallList.add(new Node(13, 8));
     
219.   wallList.add(new Node(13, 9));
     
220.   wallList.add(new Node(12, 9));
     
221.   wallList.add(new Node(12, 10));
     
222.   for (int i = 12; i > 4; i--) {
     
223.    Node walls = new Node(i, 11);
     
224.    wallList.add(walls);
     
225.   }
     
226.   wallList.add(new Node(5, 10));
     
227.   wallList.add(new Node(4, 10));
     
228.   wallList.add(new Node(4, 9));
     
229.   wallList.add(new Node(4, 8));
     
230.   wallList.add(new Node(4, 8));
     
231.   wallList.add(new Node(4, 7));
     
232.   wallList.add(new Node(5, 7));
     
233.   wallList.add(new Node(5, 6));
     
234.   wallList.add(new Node(7, 7));
     
235.   wallList.add(new Node(8, 7));
     
236.   wallList.add(new Node(9, 7));
     
237.   wallList.add(new Node(8, 9));
     
238.   wallList.add(new Node(8, 10));
     
239.   // 将墙壁的对象置为true
     
240.   for (int i = 0; i < wallList.size(); i++) {
     
241.    Node n = (Node) wallList.get(i);
     
242.    a[n.x][n.y] = true;
     
243.   }
     
244. }
     
245. // 当撞到墙时,玩家不能前进
     
246. public void moveDisable(Node n, int d1, int d2) {
     
247.   switch (direction) {
     
248.   case 4:
     
249.    n.x -= d1;
     
250.    break;
     
251.   case 1:
     
252.    n.y -= d2;
     
253.    break;
     
254.   case 2:
     
255.    n.x -= d1;
     
256.    break;
     
257.   case 3:
     
258.    n.y -= d2;
     
259.    break;
     
260.   }
     
261. }
     
262. // 判断玩家是否越过边界
     
263. public boolean isOutofwall() {
     
264.   for (int i = 0; i < wallList.size(); i++) {
     
265.    Node n = (Node) wallList.get(i);
     
266.    if (man.x == n.x && man.y == n.y) {
     
267.     return true;
     
268.    }
     
269.   }
     
270.   return false;
     
271. }
     
272. // 如果所有的箱子到位,则游戏结束
     
273. public void isArrive(Node n) {
     
274.   for (int i = 0; i < target.length; i++) {
     
275.    if ((target[i].x == n.x && target[i].y == n.y)) {
     
276.     list.add(target[i]);
     
277.    } else if (target[i].x == man.x && target[i].y == man.y) {
     
278.     list.remove(target[i]);
     
279.    }
     
280.   }
     
281.   if (list.size() == target.length) {
     
282.    end = true;
     
283.   }
     
284. }
     
285. }
     
286.                   

复制代码

  
  
   
   

     
   

     
   
  

复制代码

源码下载：http://file.javaxxz.com/2014/10/2/092723500.zip