贪吃蛇最终型AI，填满格子

JAY饭

       历时几天终于写出了完全填满格子的贪吃蛇AI, 因为是用 IDLE写的，没有导入任何模块，所以复制就可以用
但是，也是因为这样，界面及其简陋，打印起来速度也比较慢，蛇吃完整个格子要走很久，要跑两三万行！！！！
！！！！思路都是借鉴网络上的大神，没有他们的分析，我是怎么也写不出来的。
        代码缺点很明显，写的乱七八糟，没有细致化和模块化，没办法，我这几天完全沉醉其中，没有心思去细致
化，所以肯定也没人会去研究，所以我说下网络大神的逻辑思路，这个是最最重要的！！！！
        虚拟一条蛇去吃：
        if 蛇能吃到食物 and 吃完食物能找到蛇尾：
                return 真蛇去吃
        elif 蛇能吃到食物 and 吃完食物不能找到蛇尾：
                return 真蛇不去吃，但是跟着当前蛇尾走
        elif 蛇不能吃到食物，蛇能找到当前自己的蛇尾（有路径可到达）：
                return 跟着蛇尾走
        else: 吃不到食物，也找不到当前路径：
                return 随意走一步，（没病走两步 ）
        如果嫌跑的时间太长，请将109行的   show(ite) 和110 行的time.sleep 前面加#号,这样就只会看到每次吃完
食物的时刻。结尾有瑕疵，会出现最后一个食物没吃，停在那里，但是还没找出原因。也有少数情况，
停在最后几个格子不动，进入死循环。待处理
以下~：

1. import random
   
2. import time
   
3. 
   
4. class snake():
   
5.    
   
6.     def __init__(self,ite):
   
7.         self.ite = ite
   
8.         self.snk = ['o','o','O']
   
9.         self.way = [[5,4],[5,5],[5,6]]
   
10.         self.tail = [0,0]
    
11.         self.ite[5][4],self.ite[5][5],self.ite[5][6]='o','o','O'
    
12.             
    
13.     def move(self,a,b):
    
14.         if a == self.way[-1][0] and b == self.way[-1][1]:
    
15.             return
    
16.         self.way.append([a,b])
    
17.         self.tail = self.way.pop(0)
    
18.         self.ite[self.tail[0]][self.tail[1]] = ' '
    
19.         for c,(i,j) in enumerate(self.way):
    
20.             self.ite[i][j] = self.snk[c]
    
21.         return self.ite
    
22. 
    
23. class food():
    
24. 
    
25.     def __init__(self,ite):
    
26.         self.ite = ite
    
27. 
    
28.     def prod(self,way):
    
29.         sign = 0
    
30.         for i in range(10):
    
31.             for j in range(10):
    
32.                 if [i,j] not in way:
    
33.                     sign = 1
    
34.                     break
    
35.         if not sign:
    
36.             return 1
    
37.         while True:
    
38.             a,b = random.randint(0,9),random.randint(0,9)
    
39.             if [a,b] not in way:
    
40.                 self.ite[a][b] = 'Q'
    
41.                 break
    
42.         return [a,b]
    
43.    
    
44. def show(ite):
    
45.     #print(' ','--'*10)
    
46.     for i in ite:
    
47.         print('|',end='')
    
48.         for j in i:
    
49.             print(j,end=' ')
    
50.         print('|')
    
51.     #print(' ','--'*10)
    
52.     print()   
    
53. 
    
54. def find(c,d):
    
55.     global visit
    
56.     way_x = tuple(S.way)
    
57.     tail_x = tuple(S.tail)
    
58.     f = []
    
59.     f_long = []
    
60.     f_any = []
    
61.     [[a,b],[sx,sy]] = visit
    
62.     if a == c and b == d:
    
63.         right[(a,b)] = [sx,sy]
    
64.         return 1
    
65.     for ste in step:
    
66.         a1 = a + ste[0]
    
67.         b1 = b + ste[1]
    
68.         if 0<=a1<10 and 0<=b1<10 and [a1,b1] not in S.way[1:]:
    
69.             f_any.append([[a1,b1],ste])
    
70.             count = 0
    
71.             way_x = tuple(S.way)
    
72.             tail_x = tuple(S.tail)
    
73.             snk_x = tuple(S.snk)
    
74.             cot_food,cot_tail = -1,-1
    
75.             cot_food = compare(a1,b1,c,d,count)
    
76.             if cot_food>=0:
    
77.                 a_t,b_t = S.tail[0],S.tail[1]
    
78.                 cot_tail = tail_fl(c,d,-1,-1,a_t,b_t,count)
    
79.             S.way = list(way_x)
    
80.             S.tail = list(tail_x)
    
81.             S.snk = list(snk_x)
    
82.             recover(c,d)
    
83.             if cot_food>=0 and cot_tail>=0:
    
84.                 f.append([cot_food,[a1,b1],ste])
    
85. 
    
86.     if len(f):
    
87.         visit = [min(f)[1],min(f)[2]]
    
88.     else:
    
89.         for ste in step:
    
90.             a1 = a + ste[0]
    
91.             b1 = b + ste[1]
    
92.             if 0<=a1<10 and 0<=b1<10 and [a1,b1] not in S.way[1:]:
    
93.                 a_t,b_t = S.way[0][0],S.way[0][1]
    
94.                 way_x = tuple(S.way)
    
95.                 tail_x = tuple(S.tail)
    
96.                 snk_x = tuple(S.snk)
    
97.                 cot_tail = tail_fl(a1,b1,c,d,a_t,b_t,count)
    
98. 
    
99.                 if cot_tail >=0:
    
100.                     f_long.append([cot_tail,[a1,b1],ste])
     
101.                 S.way = list(way_x)
     
102.                 S.tail = list(tail_x)
     
103.                 S.snk = list(snk_x)
     
104.                 recover(c,d)
     
105.         if len(f_long):
     
106.             visit = [max(f_long)[1],max(f_long)[2]]
     
107.         else:
     
108.             visit = random.choice(f_any)        
     
109.     temp=visit[0]
     
110.     S.move(temp[0],temp[1])
     
111. 
     
112.     if temp[0] == c and temp[1] == d:
     
113.         S.snk.insert(0,'o')
     
114.         S.way.insert(0,S.tail)
     
115.         ite[S.tail[0]][S.tail[1]] = 'o'
     
116.         return 0
     
117.     show(ite)
     
118.     time.sleep(0.5)
     
119. 
     
120. def recover(c,d):
     
121.     for i in range(10):
     
122.         for j in range(10):
     
123.             ite[i][j] = ' '
     
124.     ite[c][d] = 'Q'
     
125.             
     
126. def tail_fl(a,b,c,d,a_t,b_t,count):
     
127.     S.move(a,b)
     
128.     if a == c and b == d:
     
129.         S.snk.insert(0,'o')
     
130.         S.way.insert(0,S.tail)
     
131.         ite[S.tail[0]][S.tail[1]] = 'o'
     
132.     if a == a_t and b == b_t:
     
133.         return count
     
134.     f = []
     
135.     for ste in step:
     
136.         a1 = a + ste[0]
     
137.         b1 = b + ste[1]
     
138.         if 0<=a1<10 and 0<=b1<10 and [a1,b1] not in S.way[1:]:
     
139.             cot = abs(a1-a_t)+abs(b1-b_t)
     
140.             f.append([cot,[a1,b1]])
     
141.     if not len(f):
     
142.         return -1
     
143.     return tail_fl(min(f)[1][0],min(f)[1][1],c,d,a_t,b_t,count+1)   
     
144.    
     
145. def compare(a,b,c,d,count):
     
146.    
     
147.     S.move(a,b)
     
148.     if a == c and b == d:
     
149.         S.snk.insert(0,'o')
     
150.         S.way.insert(0,S.tail)
     
151.         ite[S.tail[0]][S.tail[1]] = 'o'
     
152.         return count
     
153.     f = []
     
154.     for ste in step:
     
155.         a1,b1 = a+ste[0],b+ste[1]
     
156.         if 0<=a1<10 and 0<=b1<10 and [a1,b1] not in S.way[1:]:
     
157.             cot  = abs(a1-c)+abs(b1-d)
     
158.             f.append([cot,[a1,b1]])
     
159.     if not len(f):
     
160.         return -1
     
161.     [a,b] = min(f)[1]
     
162.     return compare(a,b,c,d,count+1)
     
163.                
     
164. ite = [[' ']*10 for i in range(10)]
     
165. S = snake(ite)
     
166. F = food(ite)
     
167. step = [[1,0],[-1,0],[0,1],[0,-1]]
     
168. a,b = F.prod(S.way)
     
169. visit = [[5,6],[0,1]]
     
170. right = {(5,6):[0,1]}
     
171. 
     
172. while True:
     
173.     if [a,b] == S.way[-1]:
     
174.         pro = F.prod(S.way)
     
175.         if pro != 1:
     
176.             [a,b] = pro
     
177.         else:
     
178.             show(ite)
     
179.             break
     
180.     show(ite)
     
181.     visit = [S.way[-1],right[tuple(S.way[-1])]]
     
182.     while True:
     
183.         if find(a,b):
     
184.             break
     
185.     #time.sleep(0.5)

复制代码

JAY饭

已更新，没有问题了代码写的乱真痛苦，出了错都不知道哪儿错了，引以为戒