学了两个月，来上交我的第一份超级超级长的作业

zxynb

给上次作业中的小甲鱼吃小鱼的游戏加了点内容：
给小甲鱼加了一个视野范围，在视野范围里面的小鱼，小甲鱼会加速去抓他；
给小鱼加了一个逃跑的方法，在视野范围里，看到小甲鱼的时候，会向反方向跑；
又加了一点文字互动
但是还没学游戏模块，就先用文字表示了。

1. import random as r
   
2. import math
   
3. 
   
4. legal_x = [0, 30]
   
5. legal_y = [0, 30]
   
6. 
   
7. class Turtle:
   
8.     #初始数据
   
9.     def __init__(self):
   
10.         #定义乌龟的初始位置
    
11.         self.turtle_x = r.randint(legal_x[0], legal_x[1])
    
12.         self.turtle_y = r.randint(legal_y[0], legal_y[1])
    
13.         #定义初始血量
    
14.         self.turtle_blood = 100
    
15.         #初始能量
    
16.         self.power = 10
    
17. 
    
18.     #普通移动的方向和移动的距离
    
19.     def move(self):
    
20.         #随机选择是在 x轴方向移动还是在 y轴方向移动
    
21.         if r.choice([0, 1]):
    
22.             move_x = r.choice([1, 2, -1, -2])
    
23.             self.turtle_x = self.turtle_x + move_x
    
24.             #print(f'小甲鱼沿着 x 轴走了{move_x}格')
    
25.         else:
    
26.             move_y = r.choice([1, 2, -1, -2])
    
27.             self.turtle_y = self.turtle_y + move_y
    
28.             #print(f'小甲鱼沿着 y 轴走了{move_y}格')
    
29. 
    
30.         #边界检测
    
31.         if self.turtle_x < 0:
    
32.             self.turtle_x = -self.turtle_x
    
33.         if self.turtle_x > legal_x[1]:
    
34.             self.turtle_x = 2*legal_x[1] - self.turtle_x
    
35.         if self.turtle_y < 0:
    
36.             self.turtle_y = -self.turtle_y
    
37.         if self.turtle_y > legal_y[1]:
    
38.             self.turtle_y = 2*legal_y[1] - self.turtle_y
    
39. 
    
40.         #每移动一次，体力减 1
    
41.         self.turtle_blood -= 1
    
42.         self.power += 1
    
43.         return self.turtle_x, self.turtle_y
    
44. 
    
45.     def hungry_move(self):
    
46.         #随机选择是在 x轴方向移动还是在 y轴方向移动
    
47.         if r.choice([0, 1]):
    
48.             move_x = r.choice([-3, 3])
    
49.             self.turtle_x = self.turtle_x + move_x
    
50.             #print(f'小甲鱼沿着 x 轴走了{move_x}格')
    
51.         else:
    
52.             move_y = r.choice([-3, 3])
    
53.             self.turtle_y = self.turtle_y + move_y
    
54.             #print(f'小甲鱼沿着 y 轴走了{move_y}格')
    
55. 
    
56.         #边界检测
    
57.         if self.turtle_x < 0:
    
58.             self.turtle_x = -self.turtle_x
    
59.         if self.turtle_x > legal_x[1]:
    
60.             self.turtle_x = 2*legal_x[1] - self.turtle_x
    
61.         if self.turtle_y < 0:
    
62.             self.turtle_y = -self.turtle_y
    
63.         if self.turtle_y > legal_y[1]:
    
64.             self.turtle_y = 2*legal_y[1] - self.turtle_y
    
65. 
    
66.         #每移动一次，体力减 1
    
67.         self.turtle_blood -= 1
    
68.         return self.turtle_x, self.turtle_y
    
69. 
    
70.     #吃小鱼
    
71.     def eat(self):
    
72.         self.turtle_blood += 20
    
73.         self.power = 10
    
74.         #体力上限为 100
    
75.         if self.turtle_blood > 100:
    
76.             self.turtle_blood = 100
    
77. 
    
78.     #小甲鱼的快速移动，智慧的小甲鱼已经学会拐弯了。
    
79.     def quick_move(self, fish_x, fish_y):
    
80.         #print('发现一条小鱼！冲冲冲！')
    
81.         # 当 y坐标差距更大时，先调整 x坐标
    
82.         if abs(self.turtle_x - fish_x) >= abs(self.turtle_y - fish_y):
    
83.             if (self.turtle_x - fish_x) >= 3:
    
84.                 self.turtle_x -= 3
    
85.             # 当小甲鱼和小鱼的 x轴的距离不足 3时，先对 x轴进行调整，则 y轴最小移动距离为 3-move >= 1
    
86.             elif 0 < (self.turtle_x - fish_x) < 3:  # x轴的移动距离可能为 1，2   甲鱼(7, 10) 鱼(13, 17)
    
87.                 move = self.turtle_x - fish_x
    
88.                 self.turtle_x -= move
    
89.                 if (self.turtle_y - fish_y) >= 2:
    
90.                     self.turtle_y -= 3 - move
    
91.                 elif (self.turtle_y - fish_y) == 1:
    
92.                     self.turtle_y -= 1
    
93.                 elif (self.turtle_y - fish_y) == 0:
    
94.                     pass
    
95.                 elif (self.turtle_y - fish_y) == -1:
    
96.                     self.turtle_y += 1
    
97.                 else:
    
98.                     self.turtle_y += 3 - move
    
99.             elif -3 < (self.turtle_x - fish_x) < 0:
    
100.                 move = self.turtle_x - fish_x
     
101.                 self.turtle_x -= move
     
102.                 if (self.turtle_y - fish_y) >= 2:
     
103.                     self.turtle_y -= 3 - move
     
104.                 elif (self.turtle_y - fish_y) == 1:
     
105.                     self.turtle_y -= 1
     
106.                 elif (self.turtle_y - fish_y) == 0:
     
107.                     pass
     
108.                 elif (self.turtle_y - fish_y) == -1:
     
109.                     self.turtle_y += 1
     
110.                 else:
     
111.                     self.turtle_y += 3 - move
     
112.             else:
     
113.                 self.turtle_x += 3
     
114.         else:
     
115.             if (self.turtle_y - fish_y) >= 3:
     
116.                 self.turtle_y -= 3
     
117.             elif 0 < (self.turtle_y - fish_y) < 3:  # x轴的移动距离可能为 1，2
     
118.                 move = self.turtle_y - fish_y
     
119.                 self.turtle_y -= move
     
120.                 if (self.turtle_x - fish_x) >= 2:
     
121.                     self.turtle_x -= 3 - move
     
122.                 elif (self.turtle_x - fish_x) == 1:
     
123.                     self.turtle_x -= 1
     
124.                 elif (self.turtle_x - fish_x) == 0:
     
125.                     pass
     
126.                 elif (self.turtle_x - fish_x) == -1:
     
127.                     self.turtle_x += 1
     
128.                 else:
     
129.                     self.turtle_x += 3 - move
     
130.             elif -3 < (self.turtle_y - fish_y) < 0:
     
131.                 move = -(self.turtle_y - fish_y)   #注意这个 move > 0
     
132.                 self.turtle_y += move
     
133.                 if (self.turtle_x - fish_x) >= 2:
     
134.                     self.turtle_x -= 3 - move
     
135.                 elif (self.turtle_x - fish_x) == 1:
     
136.                     self.turtle_x -= 1
     
137.                 elif (self.turtle_x - fish_x) == 0:
     
138.                     pass
     
139.                 elif (self.turtle_x - fish_x) == -1:
     
140.                     self.turtle_x += 1
     
141.                 else:
     
142.                     self.turtle_x += 3 - move
     
143.             else:
     
144.                 self.turtle_y += 3
     
145. 
     
146. 
     
147.         #每加速一个能量减 2
     
148.         self.power -= 2
     
149.         self.turtle_blood -= 1
     
150.         return self.turtle_x, self.turtle_y
     
151. 
     
152. class Fish:
     
153.     def __init__(self):
     
154.         #定义初始位置
     
155.         self.fish_x = r.randint(legal_x[0], legal_x[1])
     
156.         self.fish_y = r.randint(legal_y[0], legal_y[1])
     
157. 
     
158.     def move(self):
     
159.         # 随机选择是在 x轴方向移动还是在 y轴方向移动
     
160.         if r.choice([0, 1]):
     
161.             move_x = r.choice([1, -1])
     
162.             self.fish_x += move_x
     
163.             #print(f'小鱼沿 x 轴走了{move_x}格')
     
164.         else:
     
165.             move_y = r.choice([1, -1])
     
166.             self.fish_y = self.fish_y + move_y
     
167.             #print(f'小鱼沿 y 轴走了{move_y}格')
     
168.         # 边界检测
     
169.         if self.fish_x < 0:
     
170.             self.fish_x = -self.fish_x
     
171.         if self.fish_x > legal_x[1]:
     
172.             self.fish_x = 2*legal_x[1] - self.fish_x
     
173.         if self.fish_y < 0:
     
174.             self.fish_y = -self.fish_y
     
175.         if self.fish_y > legal_x[1]:
     
176.             self.fish_y = 2*legal_x[1] - self.fish_y
     
177. 
     
178.         return self.fish_x, self.fish_y
     
179. 
     
180.     # 发现小甲鱼，快跑快跑！
     
181.     def escape(self, turtle_x, turtle_y):
     
182.         #边界上的小鱼单独考虑
     
183.         if self.fish_x == 0 or self.fish_x == legal_x[1]:
     
184.             if self.fish_y > turtle_y:
     
185.                 self.fish_y += 1
     
186.             elif self.fish_y < turtle_y:
     
187.                 self.fish_y -= 1
     
188.             else:
     
189.                 move_y = r.choice([1, -1])
     
190.                 self.fish_y = self.fish_y + move_y
     
191.         elif self.fish_y == 0 or self.fish_y == legal_y[1]:
     
192.             if self.fish_x > turtle_x:
     
193.                 self.fish_x += 1
     
194.             elif self.fish_x < turtle_x:
     
195.                 self.fish_x -= 1
     
196.             else:
     
197.                 move_x = r.choice([1, -1])
     
198.                 self.fish_x = self.fish_x + move_x
     
199.         #不在边界上的小鱼
     
200.         else:
     
201.             if abs(self.fish_x - turtle_x) < abs(self.fish_y - turtle_y):
     
202.                 if self.fish_y > turtle_y:
     
203.                     self.fish_y += 1
     
204.                 else:
     
205.                     self.fish_y -= 1
     
206.             elif abs(self.fish_x - turtle_x) > abs(self.fish_y - turtle_y):
     
207.                 if self.fish_x > turtle_x:
     
208.                     self.fish_x += 1
     
209.                 else:
     
210.                     self.fish_x -= 1
     
211.             else:
     
212.                 move = r.choice([1, -1])
     
213.                 if r.choice([0, 1]):
     
214.                     self.fish_x = self.fish_x + move
     
215.                 else:
     
216.                     self.fish_y = self.fish_y + move
     
217. 
     
218.         # 边界检测
     
219.         if self.fish_x < 0:
     
220.             self.fish_x = -self.fish_x
     
221.         if self.fish_x > legal_x[1]:
     
222.             self.fish_x = 2 * legal_x[1] - self.fish_x
     
223.         if self.fish_y < 0:
     
224.             self.fish_y = -self.fish_y
     
225.         if self.fish_y > legal_x[1]:
     
226.             self.fish_y = 2 * legal_x[1] - self.fish_y
     
227. 
     
228.         return self.fish_x, self.fish_y
     
229. 
     
230. #主程序
     
231. print('===============game start===============')
     
232. 
     
233. 
     
234. turtle = Turtle()
     
235. #定义 10条鱼
     
236. fish = {i : 10 for i in range(10)}
     
237. 
     
238. for i in range(10):
     
239.     fish[i] = Fish()
     
240. 
     
241. #乌龟初始位置
     
242. loc_turtle = (turtle.turtle_x, turtle.turtle_y)
     
243. print('小甲鱼的初始位置', loc_turtle)
     
244. #小鱼的初始位置
     
245. loc = {i : (fish[i].fish_x, fish[i].fish_y) for i in fish.keys() }
     
246. 
     
247. l = []
     
248. for i in loc.keys():
     
249.     l.append(i)
     
250. l.sort()
     
251. print(f'鱼的初始位置：{l[0]+1}号小鱼：坐标', loc[l[0]])
     
252. for i in range(1, len(l)):
     
253.     print(f'           {i+1}号小鱼：坐标 {loc[l[i]]}')
     
254. 
     
255. while True:
     
256.     print('========================================')
     
257.     #print('鱼' , fish.keys())
     
258.     if len(fish) == 0:
     
259.         print('小甲鱼：win~~~   ヾ(&#3665;&#9593;&#9697;&#9593;)&#65417;"')
     
260.         break
     
261. 
     
262.     if turtle.turtle_blood == 0:
     
263.         print('小甲鱼：轻轻地我走了，正如我轻轻地来~~~    (╥╯^╰╥)')
     
264.         break
     
265. 
     
266.     # 记录下能发现小甲鱼的小鱼的条数
     
267.     dist_fish = []
     
268.     for every_loc in loc.keys():
     
269.         every_dis = math.sqrt((loc[every_loc][0] - loc_turtle[0]) ** 2 + (loc[every_loc][1] - loc_turtle[1]) ** 2)
     
270.         if every_dis <= 3:
     
271.             dist_fish.append(every_loc)
     
272. 
     
273.     #记录每一条小鱼每移动一次到达的位置
     
274.     for every_fish in fish.keys():
     
275.         if every_fish in dist_fish:
     
276.             loc[every_fish] = fish[every_fish].escape(loc_turtle[0], loc_turtle[1])
     
277.             print(f' 小鱼{every_fish}号：救命啊，我被发现了，快跑快跑！！！    (&#65377;&#335;_&#335;)')
     
278.             continue
     
279.         loc[every_fish] = fish[every_fish].move()
     
280.     # 好看地打印出每条小鱼的坐标
     
281.     l = []
     
282.     for i in loc.keys():
     
283.         l.append(i)
     
284.     l.sort()
     
285.     print(f' 小鱼的位置：{l[0] + 1}号小鱼：坐标', loc[l[0]])
     
286.     for i in range(1, len(l)):
     
287.         print(f'           {i + 1}号小鱼：坐标 {loc[l[i]]}')
     
288. 
     
289.     # 记录在小甲鱼能看到的每一条小鱼到达的位置，和到小甲鱼的距离
     
290.     dist = {}
     
291.     for every_loc in loc.keys():
     
292.         every_dis = math.sqrt((loc[every_loc][0] - loc_turtle[0]) ** 2 + (loc[every_loc][1] - loc_turtle[1]) ** 2)
     
293.         if every_dis <= 10.0:
     
294.             dist[loc[every_loc]] = every_dis
     
295. 
     
296.     if len(dist) > 0:   #在小甲鱼视野范围中的小鱼，启动快速模式
     
297.         print(f' 小甲鱼：我发现了{len(dist)}条小鱼！', end='')
     
298.         min_dist = min(dist.values())
     
299.         for every_dist in dist.keys():
     
300.             if dist[every_dist] == min_dist:
     
301.                 if turtle.power >= 2:  #如果小甲鱼的能量大于 2,就可以使用超级无敌加速模式
     
302.                     loc_turtle = turtle.quick_move(every_dist[0], every_dist[1])
     
303.                     for z in loc.keys():
     
304.                         if loc[z] == every_dist:
     
305.                             print(f'  开启超级无敌加速模式！追击敌方{z}号小鱼')
     
306.                             break
     
307.                     break
     
308.                 else:
     
309.                     loc_turtle = turtle.move()
     
310.                     print('  啊，没能量了，小鱼等等我!    ヽ(#`Д&#180;)&#65417;')
     
311. 
     
312.     else:   #没有小鱼在小甲鱼的视野中，保持普通模式
     
313.         if turtle.turtle_blood >= 20:
     
314.             loc_turtle = turtle.move()
     
315.             print(' 小甲鱼：悠哉哉~~~   (￣▽￣)~*')
     
316.         else:   #饥饿中的小甲鱼，开始迫切地找食物！
     
317.             loc_turtle = turtle.hungry_move()
     
318.             print(' 小甲鱼：我得找吃的，好饿呀~~~   (ㄒoㄒ)')
     
319. 
     
320.     print(' 小甲鱼的位置：坐标', loc_turtle)
     
321.     loc_copy = loc.copy()
     
322.     for fish_num in loc_copy.keys():
     
323.         if loc[fish_num] == loc_turtle:
     
324.             turtle.eat()
     
325.             del fish[fish_num]
     
326.             del loc[fish_num]
     
327.             print(f' {fish_num}号小鱼：啊，我被吃掉了！')
     
328.             if len(fish) == 0:
     
329.                 break
     
330.             print(f' 小甲鱼：好吃好吃！还剩{len(fish)}条小鱼   (&#3665;&#8226;&#1550; &#8226;&#3665;)&#10023;')

复制代码

zxynb

沙发

yinda_peng

zxynb 发表于 2023-6-8 19:34
沙发

可恶！自己抢

yinda_peng

厉害的厉害的

hornwong

厉害

zxynb

yinda_peng 发表于 2023-6-8 20:16
可恶！自己抢

O(∩_∩)O哈哈~

zxynb

啊，文字互动里面的下标处理的不太好，发的时候都没发现，哈哈。打代码打的头晕了
我吃了个晚饭才发现

guanjie2023

厉害了小伙子,学两个月就能做游戏开发了

落花盈满绣！