git@UCC - progcomp2012.git/blob - progcomp/agents/basic_python/basic

1 #!/usr/bin/python -u

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 [email protected] or [email protected]

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 mobile(self):

68 return self.rank != 'F' and self.rank != 'B' and self.rank != '?' and self.rank != '+'

69

70 def valuedRank(self):

71 if ranks.count(self.rank) > 0:

72 return len(ranks) - 2 - ranks.index(self.rank)

73 else:

74 return 0

75

76

77 def valuedRank(rank):

78 if ranks.count(rank) > 0:

79 return len(ranks) - 2 - ranks.index(rank)

80 else:

81 return 0

82

83

84

85 class BasicAI:

86 """

87 BasicAI class to play a game of stratego

88 Implements the protocol correctly. Stores the state of the board in self.board

89 Only makes random moves.

90 Override method "MakeMove" for more complex moves

91 """

92 def __init__(self):

93 """ Constructs the BasicAI agent, and starts it playing the game """

94 #sys.stderr.write("BasicAI __init__ here...\n");

95 self.turn = 0

96 self.board = []

97 self.units = []

98 self.enemyUnits = []

99

100 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}

101 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}

102 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}

103 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}

104 self.lastMoved = None

105

106

107

108 def Setup(self):

109 """ Implements Setup part of protocol. Always uses the same setup. Override to create custom setups """

110 #sys.stderr.write("BasicAI Setup here...\n");

111 setup = sys.stdin.readline().split(' ')

112 if len(setup) != 4:

113 sys.stderr.write("BasicAI setup fails, expected 4 tokens, got " + str(len(setup)) + " "+str(setup) + "\n")

114 self.colour = setup[0]

115 self.opponentName = setup[1]

116 self.width = int(setup[2])

117 self.height = int(setup[3])

118 for x in range(0, self.width):

119 self.board.append([])

120 for y in range(0, self.height):

121 self.board[x].append(None)

122 if self.colour == "RED":

123 print "FB8sB479B8\nBB31555583\n6724898974\n967B669999"

124 elif self.colour == "BLUE":

125 print "967B669999\n6724898974\nBB31555583\nFB8sB479B8"

126 return True

127

128 def MoveCycle(self):

129 #sys.stderr.write("BasicAI MakeMove here...\n");

130 if self.InterpretResult() == False or self.ReadBoard() == False or self.MakeMove() == False:

131 return False

132 self.turn += 1

133 return self.InterpretResult()

134

135 def MakeMove(self):

136 """ Randomly moves any moveable piece, or prints "NO_MOVE" if there are none """

137 #TODO: Over-ride this function in base classes with more complex move behaviour

138

139 #sys.stderr.write("BasicAI MakeMove here...\n")

140 #self.debugPrintBoard()

141

142 if len(self.units) <= 0:

143 return False

144

145 index = random.randint(0, len(self.units)-1)

146 startIndex = index

147

148 directions = ("UP", "DOWN", "LEFT", "RIGHT")

149 while True:

150 piece = self.units[index]

151 if piece != None and piece.mobile():

152 dirIndex = random.randint(0, len(directions)-1)

153 startDirIndex = dirIndex

154

155 while True:

156 #sys.stderr.write("Trying index " + str(dirIndex) + "\n")

157 p = move(piece.x, piece.y, directions[dirIndex],1)

158 if p[0] >= 0 and p[0] < self.width and p[1] >= 0 and p[1] < self.height:

159 target = self.board[p[0]][p[1]]

160 if target == None or (target.colour != piece.colour and target.colour != "NONE" and target.colour != "BOTH"):

161 print str(piece.x) + " " + str(piece.y) + " "+directions[dirIndex]

162 return True

163 dirIndex = (dirIndex + 1) % len(directions)

164 if startDirIndex == dirIndex:

165 break

166

167 index = (index + 1) % len(self.units)

168 if startIndex == index:

169 print "NO_MOVE"

170 return True

171

172

173 def ReadBoard(self):

174 """ Reads in the board.

175 On the very first turn, sets up the self.board structure

176 On subsequent turns, the board is simply read, but the self.board structure is not updated here.

177 """

178 #sys.stderr.write("BasicAI ReadBoard here...\n");

179 for y in range(0,self.height):

180 row = sys.stdin.readline().strip()

181 if len(row) < self.width:

182 sys.stderr.write("Row has length " + str(len(row)) + " vs " + str(self.width) + "\n")

183 return False

184 for x in range(0,self.width):

185 if self.turn == 0:

186 if row[x] == '.':

187 pass

188 elif row[x] == '#':

189 self.board[x][y] = Piece(oppositeColour(self.colour), '?',x,y)

190 self.enemyUnits.append(self.board[x][y])

191 elif row[x] == '+':

192 self.board[x][y] = Piece("NONE", '+', x, y)

193 else:

194 self.board[x][y] = Piece(self.colour, row[x],x,y)

195 self.units.append(self.board[x][y])

196 else:

197 pass

198 return True

199

200

201 def InterpretResult(self):

202 """ Interprets the result of a move, and updates the board.

203 The very first move is ignored.

204 On subsequent moves, the self.board structure is updated

205 """

206 #sys.stderr.write("BasicAI InterpretResult here...\n")

207 result = sys.stdin.readline().split(' ')

208 #sys.stderr.write(" Read status line \"" + str(result) + "\"\n")

209 if self.turn == 0:

210 return True

211

212 if result[0].strip() == "QUIT": #Make sure we exit when the manager tells us to!

213 return False

214

215 if result[0].strip() == "NO_MOVE": #No move was made, don't need to update anything

216 return True

217

218 if len(result) < 4: #Should be at least 4 tokens (X Y DIRECTION OUTCOME) in any other case

219 return False

220

221 x = int(result[0].strip())

222 y = int(result[1].strip())

223

224

225 #sys.stderr.write(" Board position " + str(x) + " " + str(y) + " is OK!\n")

226

227 direction = result[2].strip()

228

229 multiplier = 1

230 outcome = result[3].strip()

231 outIndex = 3

232 if is_integer(outcome):

233 multiplier = int(outcome)

234 outcome = result[4].strip()

235 outIndex = 4

236

237 p = move(x,y,direction, multiplier)

238

239 #Determine attacking piece

240 attacker = self.board[x][y]

241 self.board[x][y] = None

242

243 if attacker == None:

244 return False

245

246 lastMoved = attacker

247

248 defender = self.board[p[0]][p[1]]

249

250 #Update attacker's position (Don't overwrite the board yet though)

251

252 attacker.x = p[0]

253 attacker.y = p[1]

254 attacker.positions.insert(0, (attacker.x, attacker.y))

255

256

257 #Determine ranks of pieces if supplied

258 if len(result) >= outIndex + 3:

259 if defender == None:

260 return False

261 attacker.rank = result[outIndex+1].strip()

262 if attacker.beenRevealed == False:

263 if attacker.colour == self.colour:

264 self.hiddenAllies[attacker.rank] -= 1

265 elif attacker.colour == oppositeColour(self.colour):

266 self.hiddenEnemies[attacker.rank] -= 1

267 attacker.beenRevealed = True

268 defender.rank = result[outIndex+2].strip()

269 if defender.beenRevealed == False:

270 if defender.colour == self.colour:

271 self.hiddenAllies[defender.rank] -= 1

272 elif defender.colour == oppositeColour(self.colour):

273 self.hiddenEnemies[defender.rank] -= 1

274

275 defender.beenRevealed = True

276

277

278

279 if outcome == "OK":

280 self.board[p[0]][p[1]] = attacker

281

282 elif outcome == "KILLS":

283 self.board[p[0]][p[1]] = attacker

284

285 if defender.colour == self.colour:

286 self.totalAllies[defender.rank] -= 1

287 self.units.remove(defender)

288 elif defender.colour == oppositeColour(self.colour):

289 self.totalEnemies[defender.rank] -= 1

290 self.enemyUnits.remove(defender)

291

292 elif outcome == "DIES":

293 if attacker.colour == self.colour:

294 self.totalAllies[attacker.rank] -= 1

295 self.units.remove(attacker)

296 elif attacker.colour == oppositeColour(self.colour):

297 self.totalEnemies[attacker.rank] -= 1

298 self.enemyUnits.remove(attacker)

299

300 elif outcome == "BOTHDIE":

301 self.board[p[0]][p[1]] = None

302

303 if defender.colour == self.colour:

304 self.totalAllies[defender.rank] -= 1

305 self.units.remove(defender)

306 elif defender.colour == oppositeColour(self.colour):

307 self.totalEnemies[defender.rank] -= 1

308 self.enemyUnits.remove(defender)

309

310 if attacker.colour == self.colour:

311 self.totalAllies[attacker.rank] -= 1

312 self.units.remove(attacker)

313 elif attacker.colour == oppositeColour(self.colour):

314 self.totalEnemies[attacker.rank] -= 1

315 self.enemyUnits.remove(attacker)

316

317 elif outcome == "FLAG":

318 #sys.stderr.write(" Game over!\n")

319 return False

320 elif outcome == "ILLEGAL":

321 #sys.stderr.write(" Illegal move!\n")

322 return False

323 else:

324 #sys.stderr.write(" Don't understand outcome \"" + outcome + "\"!\n");

325 return False

326

327 #sys.stderr.write(" Completed interpreting move!\n");

328 return True

329

330 def debugPrintBoard(self):

331 """ For debug purposes only. Prints the board to stderr.

332 Does not indicate difference between allied and enemy pieces

333 Unknown (enemy) pieces are shown as '?'

334 """

335 for y in range(0, self.height):

336 for x in range(0, self.width):

337 if self.board[x][y] == None:

338 sys.stderr.write(".");

339 else:

340 sys.stderr.write(str(self.board[x][y].rank));

341 sys.stderr.write("\n")

342

343 if __name__ == "__main__":

344 basicAI = BasicAI()

345 if basicAI.Setup():

346 while basicAI.MoveCycle():

347 pass

348