Python 打砖块小游戏

zltzlt

Python 打砖块小游戏

游戏效果

                               
登录/注册后可看大图

代码

1. # 导入模块
   
2. import pygame
   
3. from pygame.locals import *
   
4. import sys, random, time, math
   
5. 
   
6. 
   
7. class GameWindow(object):
   
8.     """创建游戏窗口类"""
   
9. 
   
10.     def __init__(self, *args, **kw):
    
11.         self.window_length = 600
    
12.         self.window_wide = 500
    
13.         # 绘制游戏窗口，设置窗口尺寸
    
14.         self.game_window = pygame.display.set_mode((self.window_length, self.window_wide))
    
15.         # 设置游戏窗口标题
    
16.         pygame.display.set_caption("CatchBallGame")
    
17.         # 定义游戏窗口背景颜色参数
    
18.         self.window_color = (135, 206, 250)
    
19. 
    
20.     def backgroud(self):
    
21.         # 绘制游戏窗口背景颜色
    
22.         self.game_window.fill(self.window_color)
    
23. 
    
24. 
    
25. class Ball(object):
    
26.     '''创建球类'''
    
27. 
    
28.     def __init__(self, *args, **kw):
    
29.         # 设置球的半径、颜色、移动速度参数
    
30.         self.ball_color = (255, 215, 0)
    
31.         self.move_x = 1
    
32.         self.move_y = 1
    
33.         self.radius = 10
    
34. 
    
35.     def ballready(self):
    
36.         # 设置球的初始位置、
    
37.         self.ball_x = self.mouse_x
    
38.         self.ball_y = self.window_wide - self.rect_wide - self.radius
    
39.         # 绘制球，设置反弹触发条件
    
40.         pygame.draw.circle(self.game_window, self.ball_color, (self.ball_x, self.ball_y), self.radius)
    
41. 
    
42.     def ballmove(self):
    
43.         # 绘制球，设置反弹触发条件
    
44.         pygame.draw.circle(self.game_window, self.ball_color, (self.ball_x, self.ball_y), self.radius)
    
45.         self.ball_x += self.move_x
    
46.         self.ball_y -= self.move_y
    
47.         # 调用碰撞检测函数
    
48.         self.ball_window()
    
49.         self.ball_rect()
    
50.         # 每接5次球球速增加一倍
    
51.         if self.distance < self.radius:
    
52.             self.frequency += 1
    
53.             if self.frequency == 5:
    
54.                 self.frequency = 0
    
55.                 self.move_x += self.move_x
    
56.                 self.move_y += self.move_y
    
57.                 self.point += self.point
    
58.         # 设置游戏失败条件
    
59.         if self.ball_y > 520:
    
60.             self.gameover = self.over_font.render("Game Over", False, (0, 0, 0))
    
61.             self.game_window.blit(self.gameover, (100, 130))
    
62.             self.over_sign = 1
    
63. 
    
64. 
    
65. class Rect(object):
    
66.     '''创建球拍类'''
    
67. 
    
68.     def __init__(self, *args, **kw):
    
69.         # 设置球拍颜色参数
    
70.         self.rect_color = (255, 0, 0)
    
71.         self.rect_length = 100
    
72.         self.rect_wide = 10
    
73. 
    
74.     def rectmove(self):
    
75.         # 获取鼠标位置参数
    
76.         self.mouse_x, self.mouse_y = pygame.mouse.get_pos()
    
77.         # 绘制球拍，限定横向边界
    
78.         if self.mouse_x >= self.window_length - self.rect_length // 2:
    
79.             self.mouse_x = self.window_length - self.rect_length // 2
    
80.         if self.mouse_x <= self.rect_length // 2:
    
81.             self.mouse_x = self.rect_length // 2
    
82.         pygame.draw.rect(self.game_window, self.rect_color, (
    
83.         (self.mouse_x - self.rect_length // 2), (self.window_wide - self.rect_wide), self.rect_length, self.rect_wide))
    
84. 
    
85. 
    
86. class Brick(object):
    
87.     def __init__(self, *args, **kw):
    
88.         # 设置砖块颜色参数
    
89.         self.brick_color = (139, 126, 102)
    
90.         self.brick_list = [[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1],
    
91.                            [1, 1, 1, 1, 1, 1]]
    
92.         self.brick_length = 80
    
93.         self.brick_wide = 20
    
94. 
    
95.     def brickarrange(self):
    
96.         for i in range(5):
    
97.             for j in range(6):
    
98.                 self.brick_x = j * (self.brick_length + 24)
    
99.                 self.brick_y = i * (self.brick_wide + 20) + 40
    
100.                 if self.brick_list[i][j] == 1:
     
101.                     # 绘制砖块
     
102.                     pygame.draw.rect(self.game_window, self.brick_color,
     
103.                                      (self.brick_x, self.brick_y, self.brick_length, self.brick_wide))
     
104.                     # 调用碰撞检测函数
     
105.                     self.ball_brick()
     
106.                     if self.distanceb < self.radius:
     
107.                         self.brick_list[i][j] = 0
     
108.                         self.score += self.point
     
109.         # 设置游戏胜利条件
     
110.         if self.brick_list == [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],
     
111.                                [0, 0, 0, 0, 0, 0]]:
     
112.             self.win = self.win_font.render("You Win", False, (0, 0, 0))
     
113.             self.game_window.blit(self.win, (100, 130))
     
114.             self.win_sign = 1
     
115. 
     
116. 
     
117. class Score(object):
     
118.     '''创建分数类'''
     
119. 
     
120.     def __init__(self, *args, **kw):
     
121.         # 设置初始分数
     
122.         self.score = 0
     
123.         # 设置分数字体
     
124.         self.score_font = pygame.font.SysFont('arial', 20)
     
125.         # 设置初始加分点数
     
126.         self.point = 1
     
127.         # 设置初始接球次数
     
128.         self.frequency = 0
     
129. 
     
130.     def countscore(self):
     
131.         # 绘制玩家分数
     
132.         my_score = self.score_font.render(str(self.score), False, (255, 255, 255))
     
133.         self.game_window.blit(my_score, (555, 15))
     
134. 
     
135. 
     
136. class GameOver(object):
     
137.     '''创建游戏结束类'''
     
138. 
     
139.     def __init__(self, *args, **kw):
     
140.         # 设置Game Over字体
     
141.         self.over_font = pygame.font.SysFont('arial', 80)
     
142.         # 定义GameOver标识
     
143.         self.over_sign = 0
     
144. 
     
145. 
     
146. class Win(object):
     
147.     '''创建游戏胜利类'''
     
148. 
     
149.     def __init__(self, *args, **kw):
     
150.         # 设置You Win字体
     
151.         self.win_font = pygame.font.SysFont('arial', 80)
     
152.         # 定义Win标识
     
153.         self.win_sign = 0
     
154. 
     
155. 
     
156. class Collision(object):
     
157.     '''碰撞检测类'''
     
158. 
     
159.     # 球与窗口边框的碰撞检测
     
160.     def ball_window(self):
     
161.         if self.ball_x <= self.radius or self.ball_x >= (self.window_length - self.radius):
     
162.             self.move_x = -self.move_x
     
163.         if self.ball_y <= self.radius:
     
164.             self.move_y = -self.move_y
     
165. 
     
166.     # 球与球拍的碰撞检测
     
167.     def ball_rect(self):
     
168.         # 定义碰撞标识
     
169.         self.collision_sign_x = 0
     
170.         self.collision_sign_y = 0
     
171. 
     
172.         if self.ball_x < (self.mouse_x - self.rect_length // 2):
     
173.             self.closestpoint_x = self.mouse_x - self.rect_length // 2
     
174.             self.collision_sign_x = 1
     
175.         elif self.ball_x > (self.mouse_x + self.rect_length // 2):
     
176.             self.closestpoint_x = self.mouse_x + self.rect_length // 2
     
177.             self.collision_sign_x = 2
     
178.         else:
     
179.             self.closestpoint_x = self.ball_x
     
180.             self.collision_sign_x = 3
     
181. 
     
182.         if self.ball_y < (self.window_wide - self.rect_wide):
     
183.             self.closestpoint_y = (self.window_wide - self.rect_wide)
     
184.             self.collision_sign_y = 1
     
185.         elif self.ball_y > self.window_wide:
     
186.             self.closestpoint_y = self.window_wide
     
187.             self.collision_sign_y = 2
     
188.         else:
     
189.             self.closestpoint_y = self.ball_y
     
190.             self.collision_sign_y = 3
     
191.         # 定义球拍到圆心最近点与圆心的距离
     
192.         self.distance = math.sqrt(
     
193.             math.pow(self.closestpoint_x - self.ball_x, 2) + math.pow(self.closestpoint_y - self.ball_y, 2))
     
194.         # 球在球拍上左、上中、上右3种情况的碰撞检测
     
195.         if self.distance < self.radius and self.collision_sign_y == 1 and (
     
196.                 self.collision_sign_x == 1 or self.collision_sign_x == 2):
     
197.             if self.collision_sign_x == 1 and self.move_x > 0:
     
198.                 self.move_x = - self.move_x
     
199.                 self.move_y = - self.move_y
     
200.             if self.collision_sign_x == 1 and self.move_x < 0:
     
201.                 self.move_y = - self.move_y
     
202.             if self.collision_sign_x == 2 and self.move_x < 0:
     
203.                 self.move_x = - self.move_x
     
204.                 self.move_y = - self.move_y
     
205.             if self.collision_sign_x == 2 and self.move_x > 0:
     
206.                 self.move_y = - self.move_y
     
207.         if self.distance < self.radius and self.collision_sign_y == 1 and self.collision_sign_x == 3:
     
208.             self.move_y = - self.move_y
     
209.         # 球在球拍左、右两侧中间的碰撞检测
     
210.         if self.distance < self.radius and self.collision_sign_y == 3:
     
211.             self.move_x = - self.move_x
     
212. 
     
213.     # 球与砖块的碰撞检测
     
214.     def ball_brick(self):
     
215.         # 定义碰撞标识
     
216.         self.collision_sign_bx = 0
     
217.         self.collision_sign_by = 0
     
218. 
     
219.         if self.ball_x < self.brick_x:
     
220.             self.closestpoint_bx = self.brick_x
     
221.             self.collision_sign_bx = 1
     
222.         elif self.ball_x > self.brick_x + self.brick_length:
     
223.             self.closestpoint_bx = self.brick_x + self.brick_length
     
224.             self.collision_sign_bx = 2
     
225.         else:
     
226.             self.closestpoint_bx = self.ball_x
     
227.             self.collision_sign_bx = 3
     
228. 
     
229.         if self.ball_y < self.brick_y:
     
230.             self.closestpoint_by = self.brick_y
     
231.             self.collision_sign_by = 1
     
232.         elif self.ball_y > self.brick_y + self.brick_wide:
     
233.             self.closestpoint_by = self.brick_y + self.brick_wide
     
234.             self.collision_sign_by = 2
     
235.         else:
     
236.             self.closestpoint_by = self.ball_y
     
237.             self.collision_sign_by = 3
     
238.         # 定义砖块到圆心最近点与圆心的距离
     
239.         self.distanceb = math.sqrt(
     
240.             math.pow(self.closestpoint_bx - self.ball_x, 2) + math.pow(self.closestpoint_by - self.ball_y, 2))
     
241.         # 球在砖块上左、上中、上右3种情况的碰撞检测
     
242.         if self.distanceb < self.radius and self.collision_sign_by == 1 and (
     
243.                 self.collision_sign_bx == 1 or self.collision_sign_bx == 2):
     
244.             if self.collision_sign_bx == 1 and self.move_x > 0:
     
245.                 self.move_x = - self.move_x
     
246.                 self.move_y = - self.move_y
     
247.             if self.collision_sign_bx == 1 and self.move_x < 0:
     
248.                 self.move_y = - self.move_y
     
249.             if self.collision_sign_bx == 2 and self.move_x < 0:
     
250.                 self.move_x = - self.move_x
     
251.                 self.move_y = - self.move_y
     
252.             if self.collision_sign_bx == 2 and self.move_x > 0:
     
253.                 self.move_y = - self.move_y
     
254.         if self.distanceb < self.radius and self.collision_sign_by == 1 and self.collision_sign_bx == 3:
     
255.             self.move_y = - self.move_y
     
256.         # 球在砖块下左、下中、下右3种情况的碰撞检测
     
257.         if self.distanceb < self.radius and self.collision_sign_by == 2 and (
     
258.                 self.collision_sign_bx == 1 or self.collision_sign_bx == 2):
     
259.             if self.collision_sign_bx == 1 and self.move_x > 0:
     
260.                 self.move_x = - self.move_x
     
261.                 self.move_y = - self.move_y
     
262.             if self.collision_sign_bx == 1 and self.move_x < 0:
     
263.                 self.move_y = - self.move_y
     
264.             if self.collision_sign_bx == 2 and self.move_x < 0:
     
265.                 self.move_x = - self.move_x
     
266.                 self.move_y = - self.move_y
     
267.             if self.collision_sign_bx == 2 and self.move_x > 0:
     
268.                 self.move_y = - self.move_y
     
269.         if self.distanceb < self.radius and self.collision_sign_by == 2 and self.collision_sign_bx == 3:
     
270.             self.move_y = - self.move_y
     
271.         # 球在砖块左、右两侧中间的碰撞检测
     
272.         if self.distanceb < self.radius and self.collision_sign_by == 3:
     
273.             self.move_x = - self.move_x
     
274. 
     
275. 
     
276. class Main(GameWindow, Rect, Ball, Brick, Collision, Score, Win, GameOver):
     
277.     '''创建主程序类'''
     
278. 
     
279.     def __init__(self, *args, **kw):
     
280.         super(Main, self).__init__(*args, **kw)
     
281.         super(GameWindow, self).__init__(*args, **kw)
     
282.         super(Rect, self).__init__(*args, **kw)
     
283.         super(Ball, self).__init__(*args, **kw)
     
284.         super(Brick, self).__init__(*args, **kw)
     
285.         super(Collision, self).__init__(*args, **kw)
     
286.         super(Score, self).__init__(*args, **kw)
     
287.         super(Win, self).__init__(*args, **kw)
     
288.         # 定义游戏开始标识
     
289.         start_sign = 0
     
290. 
     
291.         while True:
     
292.             self.backgroud()
     
293.             self.rectmove()
     
294.             self.countscore()
     
295. 
     
296.             if self.over_sign == 1 or self.win_sign == 1:
     
297.                 break
     
298.             # 获取游戏窗口状态
     
299.             for event in pygame.event.get():
     
300.                 if event.type == pygame.QUIT:
     
301.                     sys.exit()
     
302.                 if event.type == MOUSEBUTTONDOWN:
     
303.                     pressed_array = pygame.mouse.get_pressed()
     
304.                     if pressed_array[0]:
     
305.                         start_sign = 1
     
306.             if start_sign == 0:
     
307.                 self.ballready()
     
308.             else:
     
309.                 self.ballmove()
     
310. 
     
311.             self.brickarrange()
     
312. 
     
313.             # 更新游戏窗口
     
314.             pygame.display.update()
     
315.             # 控制游戏窗口刷新频率
     
316.             time.sleep(0.010)
     
317. 
     
318. 
     
319. if __name__ == '__main__':
     
320.     pygame.init()
     
321.     pygame.font.init()
     
322.     catchball = Main()

复制代码

本文转载自 https://blog.csdn.net/haoxun07/a ... _category.none-task