找不到终端 curses

1. 我在网上学习编写2048程序游戏，复制其代码后发现出现_curses.error: setupterm: could not find terminal的错误。请问是什么原因。
   
2. 
   
3. 
   
4. 
   
5. import curses
   
6. from random import randrange,choice
   
7. from collections import defaultdict
   
8. 
   
9. letter_codes = [ord(ch) for ch in 'WASDRQwasdrq']
   
10. actions = ['Up','Left','Down','Right','Restart','Exit']
    
11. actions_dict = dict(zip(letter_codes,actions*2))
    
12. 
    
13.         #user input        
    
14. def get_user_action(keyboard):
    
15.         char = "N"
    
16.         while char not in actions_dict:
    
17.                 char = keyboard.getch()
    
18.         return actions_dict[char]
    
19. 
    
20. def transpose(field):
    
21.         return [list(row) for row in zip(*field)]
    
22. 
    
23. def invert(field):
    
24.         return [row[::-1] for row in field]
    
25. 
    
26. class GameField(object):
    
27.         def __init__(self,height=4,width=4,win=2048):
    
28.                 self.height = height
    
29.                 self.width = width
    
30.                 self.win_value = 2048
    
31.                 self.score = 0
    
32.                 self.highscore = 0
    
33.                 self.reset()
    
34. 
    
35.         def reset(self):
    
36.                 if self.score > self.highscore:
    
37.                         self.highscore = self.score
    
38.                 self.score = 0
    
39.                 self.field = [[0 for i in range(self.width)] for j in range(self.height)]
    
40.                 self.spawn()
    
41.                 self.spawn()
    
42. 
    
43.         def move(self,direction):
    
44.                 def move_row_left(row):
    
45.                         def tighten(row):
    
46.                                 new_row = [i for i in row if i!=0]
    
47.                                 new_row += [0 for i in range(len(row) - len(new_row))]
    
48.                                 return new_row
    
49. 
    
50.                         def merge(row):
    
51.                                 pair = False
    
52.                                 new_row = []
    
53.                                 for i in range(len(row)):
    
54.                                         if pair:
    
55.                                                 new_row.append(2*row[i])
    
56.                                                 self.score += 2*row[i]
    
57.                                                 pair = False
    
58.                                         else:
    
59.                                                 if i+1 < len(row) and row[i] == row[i +1]:
    
60.                                                         pair = True
    
61.                                                         new_row.append(0)
    
62.                                                 else:
    
63.                                                         new_row.append(row[i])
    
64.                                 assert len(new_row) == len(row)
    
65.                                 return new_row
    
66.                         return tighten(merge(tighten(row)))        
    
67.                 moves = {}
    
68.                 moves['Left'] = lambda field: [move_row_left(row) for row in field]
    
69.                 moves['Right'] = lambda field: invert(moves['Left'](invert(field)))
    
70.                 moves['Up'] = lambda field: transpose(moves['Left'](transpose(field)))
    
71.                 moves["Down"] = lambda field:transpose(moves['Right'](transpose(field)))
    
72. 
    
73.                 if direction in moves:
    
74.                         if self.move_is_possible(direction):
    
75.                                 self.field = moves[direction](self.field)
    
76.                                 self.spawn()
    
77.                                 return True
    
78.                         else:
    
79.                                 return False
    
80. 
    
81.         #win or lose
    
82.         def is_win(self):
    
83.                 return any(any(i>=self.win_value for i in row) for row in self.field)
    
84. 
    
85.         def is_gameover(self):
    
86.                 return not any(self.move_is_possible(move) for move in actions)
    
87. 
    
88.         #whether it can move
    
89. 
    
90.         def draw(self,screen):
    
91.                 help_string1 = 'wsad:means:up,down,left,right'
    
92.                 help_string2 = '(R)restart,(Q)Exit'
    
93.                 gameover_strings = 'you lose'
    
94.                 win_strings = 'you win'
    
95.                 def cast(string):
    
96.                         screen.addstr(string + '\n')
    
97.                 #DRAW horizon line
    
98.                 def draw_hor_separator():
    
99.                         line = '+' + ('+------'*self.width + '+')[1:]
    
100.                         separator = defaultdict(lambda:line)
     
101.                         if not hasattr(draw_hor_separator,"counter"):
     
102.                                 draw_hor_separator.counter = 0
     
103.                         cast(separator[draw_hor_separator.counter])
     
104.                         draw_hor_separator.counter += 1
     
105. 
     
106.                 def draw_row(row):
     
107.                         cast(''.join('|{: ^5}'.format(num) if num > 0 else '|                ' for num in row) + '|')
     
108.                         screen.clear()
     
109. 
     
110.                         cast('score:' + str(self.score))
     
111.                         if 0 != self.highscore:
     
112.                                 cast('highscore:'+str(self.highscore))
     
113. 
     
114.                         for row in self.field:
     
115.                                 draw_hor_separator()
     
116.                                 draw_row()
     
117. 
     
118.                         draw_hor_separator()
     
119.                         if self.is_win():
     
120.                                 cast(win_strings)
     
121.                         else:
     
122.                                 if self.is_gameover():
     
123.                                         cast(gameover_strings)
     
124.                                 else:
     
125.                                         cast(help_string1)
     
126.                         cast(help_string2)
     
127. 
     
128.         def spawn(self):
     
129.                 new_element = 4 if randrange(100) > 89 else 2
     
130.                 (i,j) = choice([(i,j) for i in range(self.width) for j in range(self.height) if self.field[i][j] == 0])
     
131.                 self.field[i][j] = new_element
     
132. 
     
133.         def move_is_possible(self,direction):
     
134.                 def row_is_left_movable(row):
     
135.                         def change(i):
     
136.                                 if row[i] == 0 and row[i+1] != 0:
     
137.                                         return True
     
138.                                 if row[i] !=0 and row[i+1] == row[i]:
     
139.                                         return True
     
140.                                 return False
     
141.                         return any(change[i] for i in range(len(row)-1))
     
142. 
     
143.                 check = {}
     
144.                 check['Left'] = lambda field: any(row_is_left_movable(row) for row in field)
     
145.                 check['Right'] = lambda field: check['Left'](invert(field))
     
146.                 check['Left'] = lambda field: check['Left'](transpose(field))
     
147.                 check['Down'] = lambda field: check['Right'](transpose(field))
     
148. 
     
149.                 if direction in check:
     
150.                         return check[direction][self.field]
     
151.                 else:
     
152.                         return False
     
153. 
     
154. def main(stdscr):
     
155. 
     
156.         def init():
     
157.         #rebuild game table
     
158.                 game_field.reset()
     
159.                 return 'Game'
     
160. 
     
161.         def not_game(state):
     
162.         #draw gameover or win screen
     
163.                 game_field.draw(stdscr)
     
164.         #define actions
     
165.                 action = get_user_action(stdscr)
     
166.                 responses = defaultdict(lambda:state)
     
167.                 responses['Restart'],responses['Exit'] = 'Init','Exit'
     
168.                 return responses[action]
     
169. 
     
170.         def game():
     
171.                 #draw table
     
172.                 game_field.draw(stdscr)
     
173.                 #get action
     
174.                 action = get_user_action(stdscr)
     
175. 
     
176.                 if action == 'Restart':
     
177.                         return 'Init'
     
178.                 if action == 'Exit':
     
179.                         return 'Exit'
     
180.                 #if success move
     
181.                 if game_field.move(action):
     
182.                         if game_field.is_win():
     
183.                                 return 'Win'
     
184.                         if game_field.is_gameover():
     
185.                                 return 'Gameover'
     
186.                 return 'Game'
     
187. 
     
188.         state_actions = {
     
189.                         'Init': init,
     
190.                         'Win': lambda:not_game('Win'),
     
191.                         'Gameover':lambda:not_game('Gameover'),
     
192.                         'Game': game
     
193.                         }
     
194. 
     
195.         curses.use_default_colors()
     
196.         game_field = GameField(win = 32)
     
197.         state = 'Init'
     
198.         #circle
     
199.         while state != 'Exit':
     
200.                 state = state_actions[state]()
     
201. 
     
202. curses.wrapper(main)
     

复制代码

是在linux环境吗？
那么可以设置环境变量
export TERM=linux
export TERMINFO=/etc/terminfo
来解决