求助一下pygame的碰撞检测问题

Folly

自己写的一个打砖块游戏 碰撞检测部分如下 我的球只有遇到边框会发生反弹 在需要到mask碰撞检测的地方就会直接穿过砖块跟板子是怎么回事呢 file:///C:/Users/Folly/Desktop/L%7BJKU(GS)5_T55VZUH1E$%7B6.png

Folly

1.         #检测球的碰撞
   
2.             for each in brick_list:
   
3.                 ball_hit_brick = pygame.sprite.collide_mask(ball,each)
   
4.                 if ball_hit_brick == True:
   
5.                     if ball.rect.centerx < each.rect.left:
   
6.                         if ball.centery < each.rect.top or ball.rect.centery > each.rect.bottom:
   
7.                             if ball.centery < each.rect.top and ball.speed_y > 0:
   
8.                                 ball.speed_x = - ball.speed_x
   
9.                                 ball.speed_y = - ball.speed_y
   
10.                             elif ball.rect.centery > each.rect.bottom and ball.speed_y < 0:
    
11.                                 ball.speed_x = - ball.speed_x
    
12.                                 ball.speed_y = - ball.speed_y
    
13.                            
    
14.                         else:
    
15.                             ball.speed_x = - ball.speed_x
    
16.                     elif ball.rect.centerx > each.rect.right:
    
17.                         if ball.rect.centery < each.rect.top or ball.rect.centery > each.rect.bottom:
    
18.                             if ball.rect.centery < each.rect.top and ball.speed_y > 0:
    
19.                                 ball.speed_x = - ball.speed_x
    
20.                                 ball.speed_y = - ball.speed_y
    
21.                             elif ball.rect.centery > each.rect.bottom and ball.speed_y < 0:
    
22.                                 ball.speed_x = - ball.speed_x
    
23.                                 ball.speed_y = - ball.speed_y
    
24.                                 
    
25.                         else:
    
26.                             ball.speed_x = - ball_speed_x
    
27.                     else:
    
28.                         ball.speed_y = - ball_speed_y
    
29. 
    
30.             ball_hit_board = pygame.sprite.collide_mask(ball,board)
    
31.             if ball_hit_board == True:
    
32.                 if ball.rect.centerx < board.rect.left:
    
33.                     if ball.rect.centert < board.rect.top or ball.rect.centery > board.rect.bottom:
    
34.                         if ball.rect.centert < board.rect.top and ball.speed_y > 0:
    
35.                             ball.speed_x = - ball.speed_x
    
36.                             ball.speed_y = - ball.speed_y
    
37.                         elif ball.rect.centery > board.rect.bottom and ball.speed_y < 0:
    
38.                             ball.speed_x = - ball.speed_x
    
39.                             ball.speed_y = - ball.speed_y
    
40.                         
    
41.                     else:
    
42.                         ball.speed_x = - ball.speed_x
    
43.                 elif ball.rect.centerx > board.rect.right:
    
44.                     if ball.rect.centery < board.rect.top or ball.rect.centery > board.rect.bottom:
    
45.                             if ball.rect.centery < board.rect.top and ball.speed_y > 0:
    
46.                                 ball.speed_x = - ball.speed_x
    
47.                                 ball.speed_y = - ball.speed_y
    
48.                             elif ball.rect.centery > board.rect.bottom and ball.speed_y < 0:
    
49.                                 ball.speed_x = - ball.speed_x
    
50.                                 ball.speed_y = - ball.speed_y
    
51.                     else:
    
52.                         ball.speed_x = - ball_speed_x
    
53.                 else:
    
54.                     ball.speed_y = - ball.speed_y
    
55. 
    
56.             if ball.rect.left < 0:
    
57.                 ball.speed_x = - ball.speed_x
    
58.             if ball.rect.right > background_width:
    
59.                 ball.speed_x = - ball.speed_x
    
60.             if ball.rect.top < 0:
    
61.                 ball.speed_y = - ball.speed_y
    
62.                     
    
63.                         

复制代码

乘号

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()
     

复制代码

Folly

乘号 发表于 2020-5-3 22:01

您这是百度的代码答案啊 我想要知道的是能不能偷懒直接用碰撞检测函数来完成

乘号

Folly 发表于 2020-5-3 22:04
您这是百度的代码答案啊 我想要知道的是能不能偷懒直接用碰撞检测函数来完成

我没学到这。。。代码是哪的我忘了，两个月前弄的

Folly

乘号 发表于 2020-5-3 22:06
我没学到这。。。代码是哪的我忘了，两个月前弄的

我是看到小甲鱼视频里面可以直接用一个内置的碰撞检测函数来判断是否发生碰撞 而不是像这样用数学方法重新算一遍

乘号

Folly 发表于 2020-5-3 22:07
我是看到小甲鱼视频里面可以直接用一个内置的碰撞检测函数来判断是否发生碰撞 而不是像这样用数学方法重 ...

ummmmmmm
@zltzlt