[PATCH] Remove arguments, patch vixen, add hunter AI
[progcomp2012.git] / agents / hunter / basic_python.py
1 #!/usr/bin/python -u
2
3 #NOTE: The -u option is required for unbuffered stdin/stdout.
4 #       If stdin/stdout are buffered, the manager program will not recieve any messages and assume that the agent has timed out.
5
6 """
7  basic_python.py - A sample Stratego AI for the UCC Programming Competition 2012
8
9  Written in python, the slithery language 
10  Simply makes random moves, as long as possible
11
12  author Sam Moore (matches) [SZM]
13  website http://matches.ucc.asn.au/stratego
14  email progcomp@ucc.asn.au or matches@ucc.asn.au
15  git git.ucc.asn.au/progcomp2012.git
16 """
17
18 import sys
19 import random
20
21 ranks = ['B','1','2','3','4','5','6','7','8','9','s','F', '?', '+']
22
23 def is_integer(s):
24         """ Using exceptions for this feels... wrong..."""
25         try:
26                 int(s)
27                 return True
28         except ValueError:
29                 return False
30
31 def move(x, y, direction, multiplier):
32         """ Moves point (x,y) in direction, returns a pair """
33         if direction == "UP":
34                 return (x,y-multiplier)
35         elif direction == "DOWN":
36                 return (x,y+multiplier)
37         elif direction == "LEFT":
38                 return (x-multiplier, y)
39         elif direction == "RIGHT":
40                 return (x+multiplier, y)
41         return (x,y)
42
43
44
45 def oppositeColour(colour):
46         """ Returns the opposite colour to that given """
47         if colour == "RED":
48                 return "BLUE"
49         elif colour == "BLUE":
50                 return "RED"
51         else:
52                 return "NONE"
53
54 class Piece:
55         """ Class representing a piece 
56                 Pieces have colour, rank and co-ordinates       
57         """
58         def __init__(self, colour, rank, x, y):
59                 self.colour = colour
60                 self.rank = rank
61                 self.x = x
62                 self.y = y
63                 self.lastMoved = -1
64                 self.beenRevealed = False
65                 self.positions = [(x, y)]
66
67         def copy(self):
68                 p = Piece(self.colour, self.rank, self.x, self.y)
69                 p.lastMoved = self.lastMoved
70                 p.beenRevealed = self.beenRevealed
71                 p.positions = []
72                 for pos in self.positions:
73                         p.positions.append((pos[0], pos[1]))
74                 return p
75
76         def mobile(self):
77                 return self.rank != 'F' and self.rank != 'B' and self.rank != '?' and self.rank != '+'
78
79         def valuedRank(self):
80                 if ranks.count(self.rank) > 0:
81                         return len(ranks) - 2 - ranks.index(self.rank)
82                 else:
83                         return 0
84         
85
86 def valuedRank(rank):
87         if ranks.count(rank) > 0 and rank != '?':
88                 return len(ranks) - 2 - ranks.index(rank)
89         else:
90                 return 0
91
92
93
94 class BasicAI:
95         """
96                 BasicAI class to play a game of stratego
97                 Implements the protocol correctly. Stores the state of the board in self.board
98                 Only makes random moves.
99                 Override method "MakeMove" for more complex moves
100         """
101         def __init__(self):     
102                 """ Constructs the BasicAI agent, and starts it playing the game """
103                 #sys.stderr.write("BasicAI __init__ here...\n");
104                 self.turn = 0
105                 self.board = []
106                 self.units = []
107                 self.enemyUnits = []
108
109                 self.totalAllies = {'B':6,'1':1,'2':1,'3':2,'4':3,'5':4,'6':4,'7':4,'8':5,'9':8,'s':1,'F':1}
110                 self.totalEnemies = {'B':6,'1':1,'2':1,'3':2,'4':3,'5':4,'6':4,'7':4,'8':5,'9':8,'s':1,'F':1}
111                 self.hiddenEnemies = {'B':6,'1':1,'2':1,'3':2,'4':3,'5':4,'6':4,'7':4,'8':5,'9':8,'s':1,'F':1}
112                 self.hiddenAllies = {'B':6,'1':1,'2':1,'3':2,'4':3,'5':4,'6':4,'7':4,'8':5,'9':8,'s':1,'F':1}
113                 self.lastMoved = None
114
115         def LegalPosition(self, x, y):
116                 return x >= 0 and y >= 0 and x < len(self.board) and y < len(self.board[x])
117                 
118
119         def Setup(self):
120                 """ Implements Setup part of protocol. Always uses the same setup. Override to create custom setups """
121                 #sys.stderr.write("BasicAI Setup here...\n");
122                 setup = sys.stdin.readline().split(' ')
123                 if len(setup) != 4:
124                         sys.stderr.write("BasicAI setup fails, expected 4 tokens, got " + str(len(setup)) + " "+str(setup) + "\n")
125                 self.colour = setup[0]
126                 self.opponentName = setup[1]
127                 self.width = int(setup[2])
128                 self.height = int(setup[3])
129                 for x in range(0, self.width):
130                         self.board.append([])
131                         for y in range(0, self.height):         
132                                 self.board[x].append(None)
133                 if self.colour == "RED":
134                         print "FB8sB479B8\nBB31555583\n6724898974\n967B669999"
135                 elif self.colour == "BLUE":
136                         print "967B669999\n6724898974\nBB31555583\nFB8sB479B8"
137                 return True
138
139         def MoveCycle(self):
140                 #sys.stderr.write("BasicAI MakeMove here...\n");
141                 if self.InterpretResult() == False or self.ReadBoard() == False or self.MakeMove() == False:
142                         return False
143                 self.turn += 1
144                 return self.InterpretResult()
145
146         def MakeMove(self):
147                 """ Randomly moves any moveable piece, or prints "NO_MOVE" if there are none """
148                 #TODO: Over-ride this function in base classes with more complex move behaviour
149
150                 #sys.stderr.write("BasicAI MakeMove here...\n")
151                 #self.debugPrintBoard()
152
153                 if len(self.units) <= 0:
154                         return False
155
156                 index = random.randint(0, len(self.units)-1)
157                 startIndex = index
158
159                 directions = ("UP", "DOWN", "LEFT", "RIGHT")
160                 while True:
161                         piece = self.units[index]
162                         if piece != None and piece.mobile():
163                                 dirIndex = random.randint(0, len(directions)-1)
164                                 startDirIndex = dirIndex
165                                 
166                                 while True:
167                                         #sys.stderr.write("Trying index " + str(dirIndex) + "\n")
168                                         p = move(piece.x, piece.y, directions[dirIndex],1)
169                                         if p[0] >= 0 and p[0] < self.width and p[1] >= 0 and p[1] < self.height:
170                                                 target = self.board[p[0]][p[1]]
171                                                 if target == None or (target.colour != piece.colour and target.colour != "NONE" and target.colour != "BOTH"):   
172                                                         print str(piece.x) + " " + str(piece.y) + " "+directions[dirIndex]
173                                                         return True
174                                         dirIndex = (dirIndex + 1) % len(directions)
175                                         if startDirIndex == dirIndex:
176                                                 break
177
178                         index = (index + 1) % len(self.units)
179                         if startIndex == index:
180                                 print "NO_MOVE"
181                                 return True
182                                                         
183                         
184         def ReadBoard(self):
185                 """ Reads in the board. 
186                         On the very first turn, sets up the self.board structure
187                         On subsequent turns, the board is simply read, but the self.board structure is not updated here.
188                 """
189                 #sys.stderr.write("BasicAI ReadBoard here...\n");
190                 for y in range(0,self.height):
191                         row = sys.stdin.readline().strip()
192                         if len(row) < self.width:
193                                 sys.stderr.write("Row has length " + str(len(row)) + " vs " + str(self.width) + "\n")
194                                 return False
195                         for x in range(0,self.width):
196                                 if self.turn == 0:
197                                         if row[x] == '.':
198                                                 pass
199                                         elif row[x] == '#':
200                                                 self.board[x][y] = Piece(oppositeColour(self.colour), '?',x,y)
201                                                 self.enemyUnits.append(self.board[x][y])
202                                         elif row[x] == '+':
203                                                 self.board[x][y] = Piece("NONE", '+', x, y)
204                                         else:
205                                                 self.board[x][y] = Piece(self.colour, row[x],x,y)
206                                                 self.units.append(self.board[x][y])
207                                 else:
208                                         pass
209                 return True
210                 
211
212         def InterpretResult(self, string = None):
213                 """ Interprets the result of a move, and updates the board. 
214                         The very first move is ignored. 
215                         On subsequent moves, the self.board structure is updated
216                 """
217                 #sys.stderr.write("BasicAI InterpretResult here...\n")
218                 if string == None:
219                         string = sys.stdin.readline()
220
221                 result = string.split(' ')
222
223                 #sys.stderr.write("     Read status line \"" + str(result) + "\"\n")
224                 if self.turn == 0:
225                         return True
226
227                 if result[0].strip() == "QUIT": #Make sure we exit when the manager tells us to!
228                         return False
229
230                 if result[0].strip() == "NO_MOVE": #No move was made, don't need to update anything
231                         return True
232
233                 if len(result) < 4: #Should be at least 4 tokens (X Y DIRECTION OUTCOME) in any other case
234                         return False
235
236                 x = int(result[0].strip())
237                 y = int(result[1].strip())
238
239
240                 #sys.stderr.write("     Board position " + str(x) + " " + str(y) + " is OK!\n")         
241
242                 direction = result[2].strip()
243
244                 multiplier = 1
245                 outcome = result[3].strip()
246                 outIndex = 3
247                 if is_integer(outcome):
248                         multiplier = int(outcome)
249                         outcome = result[4].strip()
250                         outIndex = 4
251                 
252                 p = move(x,y,direction, multiplier)
253
254                 #Determine attacking piece
255                 attacker = self.board[x][y]
256                 self.board[x][y] = None
257
258                 if attacker == None:
259                         return False
260
261                 lastMoved = attacker
262
263                 defender = self.board[p[0]][p[1]]
264
265                 #Update attacker's position (Don't overwrite the board yet though)
266
267                 attacker.x = p[0]
268                 attacker.y = p[1]
269                 attacker.positions.insert(0, (attacker.x, attacker.y))
270
271                 
272                 #Determine ranks of pieces if supplied
273                 if len(result) >= outIndex + 3:
274                         if defender == None:
275                                 return False
276                         attacker.rank = result[outIndex+1].strip()
277                         if attacker.beenRevealed == False:
278                                 if attacker.colour == self.colour:
279                                         self.hiddenAllies[attacker.rank] -= 1
280                                 elif attacker.colour == oppositeColour(self.colour):
281                                         self.hiddenEnemies[attacker.rank] -= 1
282                         attacker.beenRevealed = True
283                         defender.rank = result[outIndex+2].strip()
284                         if defender.beenRevealed == False:
285                                 if defender.colour == self.colour:
286                                         self.hiddenAllies[defender.rank] -= 1
287                                 elif defender.colour == oppositeColour(self.colour):
288                                         self.hiddenEnemies[defender.rank] -= 1
289
290                         defender.beenRevealed = True
291
292                         
293                 
294                 if outcome == "OK":
295                         self.board[p[0]][p[1]] = attacker
296                         
297                 elif outcome == "KILLS":
298                         self.board[p[0]][p[1]] = attacker
299
300                         if defender.colour == self.colour:
301                                 self.totalAllies[defender.rank] -= 1
302                                 self.units.remove(defender)
303                         elif defender.colour == oppositeColour(self.colour):
304                                 self.totalEnemies[defender.rank] -= 1
305                                 self.enemyUnits.remove(defender)
306         
307                 elif outcome == "DIES":
308                         if attacker.colour == self.colour:
309                                 self.totalAllies[attacker.rank] -= 1
310                                 self.units.remove(attacker)
311                         elif attacker.colour == oppositeColour(self.colour):
312                                 self.totalEnemies[attacker.rank] -= 1
313                                 self.enemyUnits.remove(attacker)
314
315                 elif outcome == "BOTHDIE":
316                         self.board[p[0]][p[1]] = None
317
318                         if defender.colour == self.colour:
319                                 self.totalAllies[defender.rank] -= 1
320                                 self.units.remove(defender)
321                         elif defender.colour == oppositeColour(self.colour):
322                                 self.totalEnemies[defender.rank] -= 1
323                                 self.enemyUnits.remove(defender)
324
325                         if attacker.colour == self.colour:
326                                 self.totalAllies[attacker.rank] -= 1
327                                 self.units.remove(attacker)
328                         elif attacker.colour == oppositeColour(self.colour):
329                                 self.totalEnemies[attacker.rank] -= 1
330                                 self.enemyUnits.remove(attacker)
331
332                 elif outcome == "FLAG":
333                         #sys.stderr.write("     Game over!\n")
334                         return False
335                 elif outcome == "ILLEGAL":
336                         #sys.stderr.write("     Illegal move!\n")
337                         return False
338                 else:
339                         #sys.stderr.write("     Don't understand outcome \"" + outcome + "\"!\n");
340                         return False
341
342                 #sys.stderr.write("     Completed interpreting move!\n");               
343                 return True
344
345         def debugPrintBoard(self):
346                 """ For debug purposes only. Prints the board to stderr.
347                         Does not indicate difference between allied and enemy pieces
348                         Unknown (enemy) pieces are shown as '?'
349                 """
350                 for y in range(0, self.height):
351                         for x in range(0, self.width):
352                                 if self.board[x][y] == None:
353                                         sys.stderr.write(".");
354                                 else:
355                                         sys.stderr.write(str(self.board[x][y].rank));
356                         sys.stderr.write("\n")
357
358 if __name__ == "__main__":
359         basicAI = BasicAI()
360         if basicAI.Setup():
361                 while basicAI.MoveCycle():
362                         pass
363

UCC git Repository :: git.ucc.asn.au