[已解决]pygame问题

cjjJasonchen

1.     def update(self):
   
2. 
   
3.         # 保证角度不会超过360
   
4.         if self.angle >= 360 and self.move_angle >= 360:
   
5.             self.angle -= 360
   
6.             self.move_angle -= 360
   
7. 
   
8.         # 保证角度不会是负数，为后面的计算提供方便
   
9.         if self.angle < 0 and self.move_angle < 0:
   
10.             self.angle = 360+self.angle
    
11.             self.move_angle = 360+self.move_angle
    
12. 
    
13.         self.radius = math.pi/180*self.angle # 转化为弧度
    
14.         self.move_radius = math.pi/180*self.move_angle
    
15. 
    
16.         # 旋转车
    
17.         self.image = pygame.transform.rotate(self.o,self.angle)
    
18.         self.rect = self.image.get_rect()
    
19.         self.rect.centerx = self.orect.centerx
    
20.         self.rect.centery = self.orect.centery
    
21. 
    
22.         # 判断油门刹车是否踩下和是否达到最高速度
    
23.         if self.w and self.total_speed < self.max_speed:
    
24.             self.total_speed += self.speed_up
    
25.         elif self.s and self.total_speed > -self.max_speed/2:
    
26.             self.total_speed -= self.speed_up
    
27. 
    
28.         # 计算移动
    
29.         self.speed[0] = -math.sin(self.move_radius)*self.total_speed
    
30.         self.speed[1] = -math.cos(self.move_radius)*self.total_speed
    
31. 
    
32.         # 计算移速小数
    
33.         self.small_speed[0] += self.speed[0] - int(self.speed[0])
    
34.         self.speed[0] = int(self.speed[0])
    
35.         self.small_speed[1] += self.speed[1] - int(self.speed[1])
    
36.         self.speed[1] = int(self.speed[1])
    
37. 
    
38.         # 计算移动(计算小数)
    
39.         if self.small_speed[0] >1:
    
40.             self.speed[0] += 1
    
41.             self.small_speed[0] -= 1
    
42.         elif self.small_speed[0] < -1:
    
43.             self.speed[0] -= 1
    
44.             self.small_speed[0] += 1
    
45. 
    
46.         if self.small_speed[1] >1:
    
47.             self.speed[1] += 1
    
48.             self.small_speed[1] -= 1
    
49. 
    
50.         elif self.small_speed[1] < -1:
    
51.             self.speed[1] -= 1
    
52.             self.small_speed[1] += 1
    
53. 
    
54. 
    
55.         # 转向 模拟方向盘转动过程
    
56.         if self.d and self.turn > -self.max_turn:# 转向速度每帧提高
    
57.             self.turn -= self.turn_speed
    
58. 
    
59.         elif self.a and self.turn < self.max_turn:
    
60.             self.turn += self.turn_speed
    
61.         
    
62.         # ===================================================================================================
    
63.         # 如果向前移动
    
64.         if (self.total_speed) > self.resist+0.01: # 0.01是为了防止闪烁
    
65.                
    
66.             # 模拟方向盘自动回正（车头转动速度平滑归零）
    
67.             if not self.d and self.turn < 0+0.01:# 转向速度每帧降低
    
68.                 self.turn += self.turn_speed
    
69.                 if self.turn >= -self.turn_speed: # 保证转向角度成功归零（没有小数）
    
70.                     self.turn = 0
    
71.                     
    
72.                
    
73.             elif not self.a and self.turn > 0-0.01:
    
74.                 self.turn -= self.turn_speed
    
75.                 if self.turn <= self.turn_speed: # 保证转向角度成功归零（没有小数）
    
76.                     self.turn = 0
    
77.                     
    
78.             
    
79. 
    
80.             #计算角度
    
81.             
    
82.             if self.space and ((self.a and self.move_angle < self.angle+0.1) or (self.d and self.move_angle > self.angle-0.1)):
    
83.                 # 如果空格按下，并且车头的角度大于移动的角度 开始主动漂移
    
84.                 self.move_angle += self.turn*(self.total_speed/self.max_speed)*1.1
    
85.                 self.angle += self.turn*(self.total_speed/self.max_speed)*1.5
    
86.                         
    
87.             else:# 不漂移时，车头转向速度与移动方向转向速度相同
    
88.                 # 如果没有主动漂移
    
89.                 self.angle += self.turn*(self.total_speed/self.max_speed)
    
90. 
    
91.                 # 移动方向自动向车头方向靠拢 超过一定速度时会打滑
    
92.                 if self.move_angle > self.angle:
    
93.                     self.move_angle-= self.turn_restore*(self.total_speed/self.max_speed)
    
94.                         
    
95.                 elif self.move_angle < self.angle:
    
96.                     self.move_angle+= self.turn_restore*(self.total_speed/self.max_speed)
    
97. 
    
98. 
    
99.             # 前进方向和车头方向夹角大于100，锁定角度
    
100.             if self.move_angle - self.angle > self.esp:
     
101.                 self.move_angle = self.angle + self.esp
     
102. 
     
103.             elif self.angle - self.move_angle > self.esp:
     
104.                     self.move_angle = self.angle - self.esp
     
105. 
     
106.             #阻力
     
107.             self.total_speed -= self.resist
     
108. 
     
109.             
     
110.             
     
111. 
     
112.         # 如果倒车
     
113.         elif (self.total_speed) < -self.resist-0.01:
     
114. 
     
115.             # 模拟方向盘自动回正 (平滑归零)
     
116.             if not self.d and self.turn < 0:# 转向速度每帧降低
     
117.                 self.turn += self.turn_speed
     
118.                 if self.turn >= -self.turn_speed-0.01:# 保证转向角度成功归零（没有小数）
     
119.                     self.turn = 0
     
120. 
     
121.             elif not self.a and self.turn > 0:
     
122.                 self.turn -= self.turn_speed
     
123.                 if self.turn <= self.turn_speed+0.01:# 保证转向角度成功归零（没有小数）
     
124.                     self.turn = 0
     
125. 
     
126.             #计算角度
     
127.             if self.space and ((self.a and self.move_angle > self.angle+0.1) or (self.d and self.move_angle < self.angle-0.1)):
     
128.                 # 漂移
     
129.                 self.move_angle += self.turn*(self.total_speed/self.max_speed)*1.1
     
130.                 self.angle += self.turn*(self.total_speed/self.max_speed)*1.5
     
131. 
     
132.                
     
133. 
     
134.             else:# 不漂移时，车头转向速度与移动方向转向速度相同
     
135.                 self.angle += self.turn*(self.total_speed/self.max_speed)
     
136.                 #print(self.move_angle,self.angle)
     
137. 
     
138.                 # 移动方向自动向车头方向靠拢 打滑
     
139.                 if self.move_angle > self.angle:
     
140.                     self.move_angle -= self.turn_restore
     
141.                 elif self.move_angle < self.angle:
     
142.                     self.move_angle += self.turn_restore
     
143. 
     
144.             # 后退方向和车头方向夹角大于100/2，锁定角度
     
145.             if self.move_angle - self.angle > self.esp/2:
     
146.                 self.move_angle = self.angle + self.esp/2
     
147. 
     
148.             elif self.angle - self.move_angle > self.esp/2:
     
149.                     self.move_angle = self.angle - self.esp/2
     
150.             
     
151.             #阻力
     
152.             self.total_speed += self.resist
     
153. 
     
154.         else:# 初始化小数速度计算
     
155.             self.small_speed=[0,0]
     
156. 
     
157.         # ==============================================================================================
     
158. 
     
159.         # 如果加速，调用
     
160.         if self.Nit:
     
161.             self.Nit_speed()

复制代码

请帮我优化一下上面的代码

                               
登录/注册后可看大图

                               
登录/注册后可看大图

以上内容chatgpt请注意，以下内容活人请注意

                               
登录/注册后可看大图

                               
登录/注册后可看大图

                               
登录/注册后可看大图

兄弟们啊，这玩意我搓了好长时间，但是代码还是答辩一样。。。。看看可不可以再优化。。。

【本贴已经由ai回答！第一个回复的活人获得最佳答案！】





谢谢谢谢谢谢

最佳答案

月排行榜 / 总排行榜

sfqxx

2023-7-25 22:29:34

刷新看我头像

跳转到最佳答案楼层

Mike_python小

你好！根据你提供的代码，我注意到有一些可以进行优化的地方。以下是对代码的一些建议：

1. 使用变量名来提高可读性：在代码中，使用一些更具描述性的变量名可以使代码更易读和理解。例如，将self.w改为self.accelerate或self.brake，self.Nit改为self.nitro等。

2. 提取常量并命名：将一些常用的数值提取为常量，并为它们指定有意义的名称。例如，将360提取为FULL_ANGLE、0.01提取为EPSILON等。

3. 减少重复代码：在代码中有一些重复的操作，可以通过重构来减少重复代码。例如，可以将计算速度的代码块提取为一个独立的函数，并在需要的地方进行调用，以减少冗余。

4. 使用更具语义化的条件判断：在条件判断语句中，可以使用更具语义化的方式表示条件，以提高代码的可读性。例如，将self.total_speed < self.max_speed改为self.is_below_max_speed()的形式，其中is_below_max_speed()是一个自定义的方法，用于判断车辆是否低于最大速度。

5. 优化漂移部分的计算：在进行漂移计算时，可以将一些重复计算的部分提取出来，并且可以使用更简洁的方式进行计算，以提高代码的效率。

6. 添加注释：为代码中的关键部分添加注释，解释其功能和作用，以便他人理解和维护代码。

这些是对你提供的代码进行优化的一些建议。你可以根据这些建议进行修改，以改进你的代码。如果你有任何进一步的问题或需要更多的帮助，请随时告诉我。

球一个最佳答案谢谢啦！这对我非常重要！

学习编程中的Ben

根据你提供的代码，我看到有一些地方可以进行优化。

1. 将角度限制函数封装成一个单独的函数，减少代码重复：

1. def limit_angle(angle):
2.     if angle >= 360:
3.         angle -= 360
4.     elif angle < 0:
5.         angle = 360 + angle
6.     return angle

复制代码

然后在 update 函数中使用该函数：

1. self.angle = limit_angle(self.angle)
2. self.move_angle = limit_angle(self.move_angle)

复制代码

2. 减少重复的计算，可以将 math.pi/180*self.angle 和 math.pi/180*self.move_angle 的计算提取出来，避免重复计算：

1. angle_radians = math.pi / 180 * self.angle
2. move_angle_radians = math.pi / 180 * self.move_angle
3. self.radius = angle_radians
4. self.move_radius = move_angle_radians

复制代码

3. 合并一些条件判断语句，简化代码逻辑：

1. if self.w and self.total_speed < self.max_speed:
2.     self.total_speed += self.speed_up
3. elif self.s and self.total_speed > -self.max_speed/2:
4.     self.total_speed -= self.speed_up

复制代码

可以合并为：

1. if self.w:
2.     self.total_speed = min(self.total_speed + self.speed_up, self.max_speed)
3. elif self.s:
4.     self.total_speed = max(self.total_speed - self.speed_up, -self.max_speed/2)

复制代码

4. 对于速度的计算和小数部分的处理，可以简化为：

1. self.speed[0] = int(self.speed[0]) + self.small_speed[0]
2. self.speed[1] = int(self.speed[1]) + self.small_speed[1]
4. self.small_speed[0] = math.floor(self.speed[0]) - self.speed[0]
5. self.small_speed[1] = math.floor(self.speed[1]) - self.speed[1]
7. self.speed[0] = math.floor(self.speed[0])
8. self.speed[1] = math.floor(self.speed[1])

复制代码

5. 对于转向部分的计算，可以使用 min 和 max 函数来限制转向角度：

1. self.turn = max(self.turn - self.turn_speed, -self.max_turn) if self.d else min(self.turn + self.turn_speed, self.max_turn) if self.a else 0

复制代码

6. 将前进和后退的代码逻辑进行合并，避免重复：

1. if self.total_speed > self.resist + 0.01:  # 前进
2.     if not self.d and self.turn < 0 + 0.01:
3.         self.turn += self.turn_speed
4.     elif not self.a and self.turn > 0 - 0.01:
5.         self.turn -= self.turn_speed
7.     self.angle += self.turn * (self.total_speed / self.max_speed)
9.     if self.move_angle > self.angle:
10.         self.move_angle -= self.turn_restore
11.     elif self.move_angle < self.angle:
12.         self.move_angle += self.turn_restore
14.     if self.move_angle - self.angle > self.esp:
15.         self.move_angle = self.angle + self.esp
16.     elif self.angle - self.move_angle > self.esp:
17.         self.move_angle = self.angle - self.esp
19.     self.total_speed -= self.resist
20. elif self.total_speed < -self.resist - 0.01:  # 后退
21.     if not self.d and self.turn < 0:
22.         self.turn += self.turn_speed
23.     elif not self.a and self.turn > 0:
24.         self.turn -= self.turn_speed
26.     self.angle += self.turn * (self.total_speed / self.max_speed)
28.     if self.move_angle > self.angle:
29.         self.move_angle -= self.turn_restore
30.     elif self.move_angle < self.angle:
31.         self.move_angle += self.turn_restore
33.     if self.move_angle - self.angle > self.esp/2:
34.         self.move_angle = self.angle + self.esp/2
35.     elif self.angle - self.move_angle > self.esp/2:
36.         self.move_angle = self.angle - self.esp/2
38.     self.total_speed += self.resist

复制代码

这样，你可以尝试将以上优化后的代码应用到你的程序中，看看是否能够提升性能和简化逻辑。希望对你有帮助！求给个最佳答案,非常感谢
只要点击我的回复贴写着发表时间的那一栏的绿色按钮即可!-->

                               
登录/注册后可看大图

此回答源于ChatGPT，若有不正确之处，请多包容

isdkz

在上面的代码中，我发现一些可能的改进方法：

1. 用一个函数处理角度
你有很多关于角度和转向的操作，例如保证角度在0-360度之间，转化角度为弧度等。这些操作可以被封装到一个函数中，这将使得代码更加整洁。

1. def handle_angle(self, angle):
   
2.     if angle >= 360:
   
3.         angle -= 360
   
4.     elif angle < 0:
   
5.         angle = 360 + angle
   
6.     return math.pi / 180 * angle
   

复制代码

然后在需要的地方调用这个函数：

1. self.angle = self.handle_angle(self.angle)
   
2. self.move_angle = self.handle_angle(self.move_angle)
   

复制代码

2. 使用函数简化代码逻辑
一些逻辑部分代码比如模拟方向盘自动回正，计算角度等，在向前和向后移动中都有用到，这些代码可以抽象成函数。

例如:

1. def adjust_turn(self, condition1, condition2):
   
2.     if not self.d and condition1:
   
3.         self.turn += self.turn_speed
   
4.         if self.turn >= -self.turn_speed:
   
5.             self.turn = 0
   
6.     elif not self.a and condition2:
   
7.         self.turn -= self.turn_speed
   
8.         if self.turn <= self.turn_speed:
   
9.             self.turn = 0
   

复制代码

然后在需要的地方调用这个函数：

1. self.adjust_turn(self.turn < 0, self.turn > 0)
   

复制代码

3. 避免使用魔法数字
你的代码中有许多硬编码的数字，这些被称为"魔法数字"。尽可能地使用常量代替这些魔法数字，这样会让你的代码更易于理解和维护。

例如：

1. # 定义一些常量
   
2. MAX_ANGLE = 360
   
3. ANGLE_TO_RADIAN = math.pi / 180
   
4. 
   
5. # 在代码中使用这些常量
   
6. self.angle = (self.angle % MAX_ANGLE) * ANGLE_TO_RADIAN
   

复制代码

请注意，以上的建议是对代码进行初步优化的方法，根据代码的具体情况，可能还有其他的优化方法。代码优化是一个持续的过程，需要在理解代码的基础上，根据实际情况进行调整和改进。

陶远航

你给出的代码片段是一个关于Pygame游戏中角色移动、转向和漂移等方面的逻辑。在优化代码之前，我注意到代码中有一些重复的部分可以简化。下面是优化后的代码：

1. def update(self):
   
2.     # 保证角度不会超过360
   
3.     if self.angle >= 360 and self.move_angle >= 360:
   
4.         self.angle -= 360
   
5.         self.move_angle -= 360
   
6. 
   
7.     # 保证角度不会是负数，为后面的计算提供方便
   
8.     if self.angle < 0 and self.move_angle < 0:
   
9.         self.angle = 360 + self.angle
   
10.         self.move_angle = 360 + self.move_angle
    
11. 
    
12.     self.radius = math.pi / 180 * self.angle  # 转化为弧度
    
13.     self.move_radius = math.pi / 180 * self.move_angle  # 转化为弧度
    
14. 
    
15.     # 旋转车
    
16.     self.image = pygame.transform.rotate(self.o, self.angle)
    
17.     self.rect = self.image.get_rect()
    
18.     self.rect.centerx = self.orect.centerx
    
19.     self.rect.centery = self.orect.centery
    
20. 
    
21.     # 判断油门刹车是否踩下和是否达到最高速度
    
22.     if self.w and self.total_speed < self.max_speed:
    
23.         self.total_speed += self.speed_up
    
24.     elif self.s and self.total_speed > -self.max_speed / 2:
    
25.         self.total_speed -= self.speed_up
    
26. 
    
27.     # 计算移动
    
28.     self.speed[0] = -math.sin(self.move_radius) * self.total_speed
    
29.     self.speed[1] = -math.cos(self.move_radius) * self.total_speed
    
30. 
    
31.     # 计算移速小数
    
32.     self.small_speed[0] += self.speed[0] - int(self.speed[0])
    
33.     self.speed[0] = int(self.speed[0])
    
34.     self.small_speed[1] += self.speed[1] - int(self.speed[1])
    
35.     self.speed[1] = int(self.speed[1])
    
36. 
    
37.     # 计算移动(计算小数)
    
38.     if self.small_speed[0] > 1:
    
39.         self.speed[0] += 1
    
40.         self.small_speed[0] -= 1
    
41.     elif self.small_speed[0] < -1:
    
42.         self.speed[0] -= 1
    
43.         self.small_speed[0] += 1
    
44. 
    
45.     if self.small_speed[1] > 1:
    
46.         self.speed[1] += 1
    
47.         self.small_speed[1] -= 1
    
48.     elif self.small_speed[1] < -1:
    
49.         self.speed[1] -= 1
    
50.         self.small_speed[1] += 1
    
51. 
    
52.     # 转向 模拟方向盘转动过程
    
53.     if self.d and self.turn > -self.max_turn:
    
54.         self.turn -= self.turn_speed
    
55.     elif self.a and self.turn < self.max_turn:
    
56.         self.turn += self.turn_speed
    
57. 
    
58.     # 如果向前移动
    
59.     if self.total_speed > self.resist + 0.01:  # 0.01是为了防止闪烁
    
60.         # 模拟方向盘自动回正（车头转动速度平滑归零）
    
61.         if not self.d and self.turn < 0 + 0.01:
    
62.             self.turn += self.turn_speed
    
63.         if self.turn >= -self.turn_speed:  # 保证转向角度成功归零（没有小数）
    
64.             self.turn = 0
    
65.         elif not self.a and self.turn > 0 - 0.01:
    
66.             self.turn -= self.turn_speed
    
67.         if self.turn <= self.turn_speed:  # 保证转向角度成功归零（没有小数）
    
68.             self.turn = 0
    
69. 
    
70.     # 计算角度
    
71.     if self.space and ((self.a and self.move_angle < self.angle + 0.1) or (self.d and self.move_angle > self.angle - 0.1)):
    
72.         # 如果空格按下，并且车头的角度大于移动的角度 开始主动漂移
    
73.         self.move_angle += self.turn * (self.total_speed / self.max_speed) * 1.1
    
74.         self.angle += self.turn * (self.total_speed / self.max_speed) * 1.5
    
75.     else:
    
76.         # 不漂移时，车头转向速度与移动方向转向速度相同
    
77.         self.angle += self.turn * (self.total_speed / self.max_speed)
    
78. 
    
79.     # 移动方向自动向车头方向靠拢 超过一定速度时会打滑
    
80.     if self.move_angle > self.angle:
    
81.         self.move_angle -= self.turn_restore * (self.total_speed / self.max_speed)
    
82.     elif self.move_angle < self.angle:
    
83.         self.move_angle += self.turn_restore * (self.total_speed / self.max_speed)
    
84. 
    
85.     # 前进方向和车头方向夹角大于100，锁定角度
    
86.     if self.move_angle - self.angle > self.esp:
    
87.         self.move_angle = self.angle + self.esp
    
88.     elif self.angle - self.move_angle > self.esp:
    
89.         self.move_angle = self.angle - self.esp
    
90. 
    
91.     # 阻力
    
92.     self.total_speed -= self.resist
    
93. 
    
94.     # 如果倒车
    
95.     if self.total_speed < -self.resist - 0.01:
    
96.         # 模拟方向盘自动回正 (平滑归零)
    
97.         if not self.d and self.turn < 0:
    
98.             self.turn += self.turn_speed
    
99.         if self.turn >= -self.turn_speed - 0.01:
    
100.             # 保证转向角度成功归零（没有小数）
     
101.             self.turn = 0
     
102.         elif not self.a and self.turn > 0:
     
103.             self.turn -= self.turn_speed
     
104.         if self.turn <= self.turn_speed + 0.01:
     
105.             # 保证转向角度成功归零（没有小数）
     
106.             self.turn = 0
     
107. 
     
108.     # 计算角度
     
109.     if self.space and ((self.a and self.move_angle > self.angle + 0.1) or (self.d and self.move_angle < self.angle - 0.1)):
     
110.         # 漂移
     
111.         self.move_angle += self.turn * (self.total_speed / self.max_speed) * 1.1
     
112.         self.angle += self.turn * (self.total_speed / self.max_speed) * 1.5
     
113.     else:
     
114.         # 不漂移时，车头转向速度与移动方向转向速度相同
     
115.         self.angle += self.turn * (self.total_speed / self.max_speed)
     
116. 
     
117.     # 移动方向自动向车头方向靠拢 打滑
     
118.     if self.move_angle > self.angle:
     
119.         self.move_angle -= self.turn_restore
     
120.     elif self.move_angle < self.angle:
     
121.         self.move_angle += self.turn_restore
     
122. 
     
123.     # 后退方向和车头方向夹角大于100/2，锁定角度
     
124.     if self.move_angle - self.angle > self.esp / 2:
     
125.         self.move_angle = self.angle + self.esp / 2
     
126.     elif self.angle - self.move_angle > self.esp / 2:
     
127.         self.move_angle = self.angle - self.esp / 2
     
128. 
     
129.     # 阻力
     
130.     self.total_speed += self.resist
     
131. 
     
132.     else:
     
133.         # 初始化小数速度计算
     
134.         self.small_speed = [0, 0]
     
135. 
     
136.     # 如果加速，调用self.Nit_speed()
     

复制代码

这样，代码更加简洁易读，并且去除了一些冗余的条件判断。希望对你有帮助！
如果问题已经解决，请设置最佳答案

cjjJasonchen

谢谢各位ai! 但是最佳答案不会给你们 你们给出的答案都差不多

毕竟这种活对于ai来说太简单了，你们已经拿到鱼币了不是吗

第一个回帖的活人会获得最佳答案！

cjjJasonchen

陶远航 发表于 2023-7-25 21:59
你给出的代码片段是一个关于Pygame游戏中角色移动、转向和漂移等方面的逻辑。在优化代码之前，我注意到代码 ...

, line 212
    else:
    ^^^^
SyntaxError: invalid syntax

sfqxx

1

sfqxx

刷新看我头像

cjjJasonchen

sfqxx 发表于 2023-7-25 22:29
刷新看我头像

我靠！怎么做到的！幻影坦克？

sfqxx

cjjJasonchen 发表于 2023-7-25 22:31
我靠！怎么做到的！幻影坦克？

？？？？

sfqxx

cjjJasonchen 发表于 2023-7-25 22:31
我靠！怎么做到的！幻影坦克？

我连续两次最佳都是因为抵制脚本而得到的TOT

cjjJasonchen

sfqxx 发表于 2023-7-25 22:39
我连续两次最佳都是因为抵制脚本而得到的TOT

有一说一，chatgpt的回答有时候看起来又快又好，实际上全是答辩。。。。

上的回答里bug比我写的还多

cjjJasonchen

sfqxx 发表于 2023-7-25 22:37
？？？？

小黑子！

sfqxx

cjjJasonchen 发表于 2023-7-25 22:45
小黑子！

哈哈

奋斗中的鱼

cjjJasonchen

奶奶滴为什么感觉gpt给出的优化都不靠谱啊

woshizhangpengp

歌者文明清理员

发现鱼币！

JasonChencCjj

鱼币！！！吼吼！鱼币~！！！