75行，turtle_now_x=random.choice([now_x+1,now_x+2,now_x-1,now_x-2,now_x])报错

猪猪虾

提示now_x未定义

1. 
   
2. #游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏。
   
3.     #假设游戏场景为范围（x, y）为0<=x<=10，0<=y<=10
   
4.     #游戏生成1只乌龟和10条鱼
   
5.     #它们的移动方向均随机
   
6.     #乌龟的最大移动能力是2（Ta可以随机选择1还是2移动），鱼儿的最大移动能力是1
   
7.     #当移动到场景边缘，自动向反方向移动
   
8.     #乌龟初始化体力为100（上限）
   
9.     #乌龟每移动一次，体力消耗5
   
10.     #当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
    
11.     #鱼暂不计算体力
    
12.     #当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束
    
13. import easygui as g
    
14. import random
    
15. location_x=[1,10]
    
16. location_y=[1,10]
    
17. 
    
18. class Fish:
    
19.     def __init__(self):                          #定义鱼的初始情况,__init__返回值为空
    
20.        fish_location_save=[]                #存放乌龟和鱼重合位置的类似于（1，2）形式的坐标
    
21.        fish_x_location=[]                   #单独存放乌龟和鱼重合位置的X的坐标
    
22.        fish_y_location=[]                   #单独存放乌龟和鱼重合位置的y的坐标
    
23.        #一次性随即设定10个位置,即生成10条鱼
    
24.        while len(fish_location_save)!=10 :
    
25.            fish_now_x=random.randint(1,10)
    
26.            fish_now_y=random.randint(1,10)
    
27.            fish_location=(fish_now_x,fish_now_y)   #生成元祖，类似于（x,y）形式，然后存于self.fish_location_save列表
    
28.            if fish_location not in fish_location_save:
    
29.               fish_location_save.append(fish_location)
    
30.               fish_x_location.append(fish_now_x)
    
31.               fish_y_location.append(fish_now_y)
    
32. 
    
33.               
    
34.     def fish_move(self):
    
35.        #10条鱼，他们都可动可不动
    
36.        new_fish_location_save=[]                #存放移动后新的乌龟和鱼重合位置的类似于（1，2）形式的坐标
    
37.        new_fish_x_location=[]                   #单独移动后新的乌龟和鱼重合位置的X的坐标
    
38.        new_fish_y_location=[]                   #单独移动后新的乌龟和鱼重合位置的y的坐标
    
39.        #移动10条鱼的位置
    
40.        while len(new_fish_location_save) != 10:
    
41.            for i in  len(self.fish_location_save):
    
42.                #鱼的最大移动为1，在初始坐标的基础上，x,y+1，或者不动，所以有三种情况
    
43.                new_fish_x=random.choice([fish_x_location[i],fish_x_location[i]+1,fish_x_location[i]-1])
    
44.                new_fish_y=random.choice([fish_y_location[i],fish_y_location[i]+1,fish_y_location[i]-1])
    
45.                #判断是否超出边界
    
46.                if new_fish_x not in location_x:
    
47.                    new_fish_x-=1
    
48.                if new_fish_y not in location_y:
    
49.                    new_fish_x-=1
    
50.                me=(new_fish_x,new_fish_y)
    
51.                if me not in new_fish_location_save:
    
52.                    new_fish_location_save.append(me)
    
53.                    new_fish_x_location.append(new_fish_x)
    
54.                    new_fish_y_location.append(new_fish_y)
    
55. 
    
56.        turtle=Turtle()
    
57.        turtlr_location=turtle.turtle_move()
    
58.        if turtlr_location in new_fish_location_save:
    
59.             #乌龟和鱼的位置重合，删掉重合位置的鱼的坐标
    
60.             for i in len(self.fish_location_save):
    
61.                 if fish_location == self.fish_location_save[i]:
    
62.                     me=i
    
63.                     break
    
64.             self.fish_location_save.pop(me)
    
65.            
    
66. class Turtle:
    
67.     def __init__(self):  #定义乌龟的初始情况
    
68.         #初始体力
    
69.         turtle_begin=100
    
70.         #随机设置初始位置
    
71.         now_x=random.randint(1,10)
    
72.         now_y=random.randint(1,10)
    
73.         
    
74.     def turtle_move(self):
    
75.         turtle_now_x=random.choice([now_x+1,now_x+2,now_x-1,now_x-2,now_x])
    
76.         turtle_now_y=random.choice([now_y+1,now_y+2,now_y-1,now_y-2,now_y])
    
77.         #判断是否超出边界
    
78.         if turtle_now_x not in location_x:
    
79.           #反向返回
    
80.           turtle_now_x-=1
    
81.         if turtle_now_y not in location_y:
    
82.           turtle_now_y-=1                                       
    
83.         turtlr_location=(turtle_now_x,turtle_now_y)
    
84.         fish=Fish()
    
85.         fish_location_save=fish.fish_move()
    
86.         if turtlr_location in fish_location_save:
    
87.             turtle_begin += 20
    
88.             print("一条鱼已经被吃掉，还剩%d条鱼"%len(fish_location_save))
    
89.             return  turtlr_location     #返回重合位置的坐标
    
90.         else:
    
91.             return (0,0)                #不重合的时候返回一个不在范围的坐标，避免鱼在盗用的时候报错                     
    
92.         turtle_begin -= 5
    
93.         if turtle_begin == 0:
    
94.             g.msgbox("game over")
    
95.             return turtle_begin
    
96.                                                 
    
97. 
    
98. fish_use=Fish()
    
99. turtlr_use=Turtle()
    
100. fish_use.__init__ ()
     
101. turtlr_use.__init__()
     
102. turtlr_use.turtle_move()
     
103. fish_use.fish_move()
     
104. 
     
105. while turtle_begin !=0 or len(fish_location_save) != 0 :
     
106.      turtlr_use.turtle_move()
     
107.      fish_use.fish_move()
     

复制代码

BngThea

你本来就没定义啊

猪猪虾

BngThea 发表于 2020-4-9 16:11
你本来就没定义啊

这样呢，现在不报错了，跑不出结果了

1. #游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏。
   
2.     #假设游戏场景为范围（x, y）为0<=x<=10，0<=y<=10
   
3.     #游戏生成1只乌龟和10条鱼
   
4.     #它们的移动方向均随机
   
5.     #乌龟的最大移动能力是2（Ta可以随机选择1还是2移动），鱼儿的最大移动能力是1
   
6.     #当移动到场景边缘，自动向反方向移动
   
7.     #乌龟初始化体力为100（上限）
   
8.     #乌龟每移动一次，体力消耗5
   
9.     #当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
   
10.     #鱼暂不计算体力
    
11.     #当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束
    
12. import easygui as g
    
13. import random
    
14. location_x=[1,10]
    
15. location_y=[1,10]
    
16. 
    
17. class Fish:
    
18.     def __init__(self):                          #定义鱼的初始情况,__init__返回值为空
    
19.        self.fish_location_save=[]                #存放乌龟和鱼重合位置的类似于（1，2）形式的坐标
    
20.        self.fish_x_location=[]                   #单独存放乌龟和鱼重合位置的X的坐标
    
21.        self.fish_y_location=[]                   #单独存放乌龟和鱼重合位置的y的坐标
    
22.        #一次性随即设定10个位置,即生成10条鱼
    
23.        while len(self.fish_location_save)!=10 :
    
24.            fish_now_x=random.randint(1,10)
    
25.            fish_now_y=random.randint(1,10)
    
26.            fish_location=(fish_now_x,fish_now_y)   #生成元祖，类似于（x,y）形式，然后存于self.fish_location_save列表
    
27.            if fish_location not in self.fish_location_save:
    
28.               self.fish_location_save.append(fish_location)
    
29.               self.fish_x_location.append(fish_now_x)
    
30.               self.fish_y_location.append(fish_now_y)
    
31. 
    
32.               
    
33.     def fish_move(self):
    
34.        #10条鱼，他们都可动可不动
    
35.        self.new_fish_location_save=[]                #存放移动后新的乌龟和鱼重合位置的类似于（1，2）形式的坐标
    
36.        self.new_fish_x_location=[]                   #单独移动后新的乌龟和鱼重合位置的X的坐标
    
37.        self.new_fish_y_location=[]                   #单独移动后新的乌龟和鱼重合位置的y的坐标
    
38.        #移动10条鱼的位置
    
39.        while len(self.new_fish_location_save) != 10:
    
40.                #鱼的最大移动为1，在初始坐标的基础上，x,y+1，或者不动，所以有三种情况
    
41.             for i in range(0,10):
    
42.                        new_fish_x=random.choice([self.fish_x_location[i],self.fish_x_location[i]+1,self.fish_x_location[i]-1])
    
43.                        new_fish_y=random.choice([self.fish_y_location[i],self.fish_y_location[i]+1,self.fish_y_location[i]-1])
    
44.                        #判断是否超出边界
    
45.                        if new_fish_x not in location_x:
    
46.                            new_fish_x-=1
    
47.                        if new_fish_y not in location_y:
    
48.                            new_fish_x-=1
    
49.                        me=(new_fish_x,new_fish_y)
    
50.                        if me not in self.new_fish_location_save:
    
51.                            self.new_fish_location_save.append(me)
    
52.                            self.new_fish_x_location.append(new_fish_x)
    
53.                            self.new_fish_y_location.append(new_fish_y)
    
54. 
    
55.        turtle=Turtle()
    
56.        turtlr_location=turtle.turtle_move()
    
57.        if turtlr_location in self.new_fish_location_save:
    
58.             #乌龟和鱼的位置重合，删掉重合位置的鱼的坐标
    
59.             for i in len(self.fish_location_save):
    
60.                 if fish_location == self.fish_location_save[i]:
    
61.                     me=i
    
62.                     break
    
63.             self.fish_location_save.pop(me)
    
64.            
    
65. class Turtle:
    
66.     def __init__(self):  #定义乌龟的初始情况
    
67.         #初始体力
    
68.         self.turtle_begin=100
    
69.         #随机设置初始位置
    
70.         self.now_x=random.randint(1,10)
    
71.         self.now_y=random.randint(1,10)
    
72.         
    
73.     def turtle_move(self):
    
74.         turtle_now_x=random.choice([self.now_x+1,self.now_x+2,self.now_x-1,self.now_x-2,self.now_x])
    
75.         turtle_now_y=random.choice([self.now_y+1,self.now_y+2,self.now_y-1,self.now_y-2,self.now_y])
    
76.         #判断是否超出边界
    
77.         if turtle_now_x not in location_x:
    
78.           #反向返回
    
79.           turtle_now_x-=1
    
80.         if turtle_now_y not in location_y:
    
81.           turtle_now_y-=1                                       
    
82.         turtlr_location=(turtle_now_x,turtle_now_y)
    
83.         fish=Fish()
    
84.         fish_location_save=fish.fish_move()
    
85.         if turtlr_location in fish_location_save:
    
86.             self.turtle_begin += 20
    
87.             print("一条鱼已经被吃掉，还剩%d条鱼"%len(fish_location_save))
    
88.             return  turtlr_location     #返回重合位置的坐标
    
89.         else:
    
90.             return (0,0)                #不重合的时候返回一个不在范围的坐标，避免鱼在盗用的时候报错                     
    
91.         self.turtle_begin -= 5
    
92.         if self.turtle_begin == 0:
    
93.             g.msgbox("game over")
    
94.             return self.turtle_begin
    
95.                                                 
    
96. 
    
97. fish_use=Fish()
    
98. turtlr_use=Turtle()
    
99. fish_use.__init__ ()
    
100. turtlr_use.__init__()
     
101. turtlr_use.turtle_move()
     
102. fish_use.fish_move()
     
103. 
     
104. while turtle_begin !=0 or len(fish_location_save) != 0 :
     
105.      turtlr_use.turtle_move()
     
106.      fish_use.fish_move()
     

复制代码