qchess/src/game.py

   1
   2
   3
   4
   5
   6 # A thread that runs the game
   7 class GameThread(StoppableThread):
   8         def __init__(self, board, players):
   9                 StoppableThread.__init__(self)
  10                 self.board = board
  11                 self.players = players
  12                 self.state = {"turn" : None} # The game state
  13                 self.error = 0 # Whether the thread exits with an error
  14                 self.lock = threading.RLock() #lock for access of self.state
  15                 self.cond = threading.Condition() # conditional for some reason, I forgot
  16                 self.final_result = ""
  17
  18
  19
  20         # Run the game (run in new thread with start(), run in current thread with run())
  21         def run(self):
  22                 result = ""
  23                 while not self.stopped():
  24
  25                         for p in self.players:
  26                                 with self.lock:
  27                                         if isinstance(p, NetworkSender):
  28                                                 self.state["turn"] = p.base_player # "turn" contains the player who's turn it is
  29                                         else:
  30                                                 self.state["turn"] = p
  31                                 #try:
  32                                 if True:
  33                                         [x,y] = p.select() # Player selects a square
  34                                         if self.stopped():
  35                                                 break
  36
  37
  38
  39
  40                                         result = self.board.select(x, y, colour = p.colour)
  41                                         for p2 in self.players:
  42                                                 p2.update(result) # Inform players of what happened
  43
  44
  45                                         log(result)
  46
  47                                         target = self.board.grid[x][y]
  48                                         if isinstance(graphics, GraphicsThread):
  49                                                 with graphics.lock:
  50                                                         graphics.state["moves"] = self.board.possible_moves(target)
  51                                                         graphics.state["select"] = target
  52
  53                                         time.sleep(turn_delay)
  54
  55
  56                                         if len(self.board.possible_moves(target)) == 0:
  57                                                 #print "Piece cannot move"
  58                                                 target.deselect()
  59                                                 if isinstance(graphics, GraphicsThread):
  60                                                         with graphics.lock:
  61                                                                 graphics.state["moves"] = None
  62                                                                 graphics.state["select"] = None
  63                                                                 graphics.state["dest"] = None
  64                                                 continue
  65
  66                                         try:
  67                                                 [x2,y2] = p.get_move() # Player selects a destination
  68                                         except:
  69                                                 self.stop()
  70
  71                                         if self.stopped():
  72                                                 break
  73
  74                                         result = str(x) + " " + str(y) + " -> " + str(x2) + " " + str(y2)
  75                                         log(result)
  76
  77                                         self.board.update_move(x, y, x2, y2)
  78
  79                                         for p2 in self.players:
  80                                                 p2.update(result) # Inform players of what happened
  81
  82
  83
  84                                         if isinstance(graphics, GraphicsThread):
  85                                                 with graphics.lock:
  86                                                         graphics.state["moves"] = [[x2,y2]]
  87
  88                                         time.sleep(turn_delay)
  89
  90                                         if isinstance(graphics, GraphicsThread):
  91                                                 with graphics.lock:
  92                                                         graphics.state["select"] = None
  93                                                         graphics.state["dest"] = None
  94                                                         graphics.state["moves"] = None
  95
  96                         # Commented out exception stuff for now, because it makes it impossible to tell if I made an IndentationError somewhere
  97                         #       except Exception,e:
  98                         #               result = e.message
  99                         #               #sys.stderr.write(result + "\n")
 100                         #
 101                         #               self.stop()
 102                         #               with self.lock:
 103                         #                       self.final_result = self.state["turn"].colour + " " + e.message
 104
 105                                 if self.board.king["black"] == None:
 106                                         if self.board.king["white"] == None:
 107                                                 with self.lock:
 108                                                         self.final_result = self.state["turn"].colour + " DRAW"
 109                                         else:
 110                                                 with self.lock:
 111                                                         self.final_result = "white"
 112                                         self.stop()
 113                                 elif self.board.king["white"] == None:
 114                                         with self.lock:
 115                                                 self.final_result = "black"
 116                                         self.stop()
 117
 118
 119                                 if self.stopped():
 120                                         break
 121
 122
 123                 for p2 in self.players:
 124                         p2.quit(self.final_result)
 125
 126                 log(self.final_result)
 127
 128                 if isinstance(graphics, GraphicsThread):
 129                         graphics.stop()
 130
 131
 132 # A thread that replays a log file
 133 class ReplayThread(GameThread):
 134         def __init__(self, players, src, end=False,max_lines=None):
 135                 self.board = Board(style="empty")
 136                 GameThread.__init__(self, self.board, players)
 137                 self.src = src
 138                 self.max_lines = max_lines
 139                 self.line_number = 0
 140                 self.end = end
 141
 142                 self.reset_board(self.src.readline())
 143
 144         def reset_board(self, line):
 145                 pieces = {"white" : [], "black" : []}
 146                 king = {"white" : None, "black" : None}
 147                 grid = [[None] * w for _ in range(h)]
 148                 for x in range(w):
 149                         for y in range(h):
 150                                 self.board.grid[x][y] = None
 151                 while line != "# Start game":
 152                         if line[0] == "#":
 153                                 line = self.src.readline().strip(" \r\n")
 154                                 continue
 155
 156                         tokens = line.split(" ")
 157                         [x, y] = map(int, tokens[len(tokens)-1].split(","))
 158                         current_type = tokens[1]
 159                         types = map(lambda e : e.strip("'[], "), (tokens[2]+tokens[3]).split(","))
 160
 161                         target = Piece(tokens[0], x, y, types)
 162                         target.current_type = current_type
 163
 164                         try:
 165                                 target.choice = types.index(current_type)
 166                         except:
 167                                 target.choice = -1
 168
 169                         pieces[tokens[0]].append(target)
 170                         if target.current_type == "king":
 171                                 king[tokens[0]] = target
 172                         grid[x][y] = target
 173
 174                         line = self.src.readline().strip(" \r\n")
 175
 176                 self.board.pieces = pieces
 177                 self.board.king = king
 178                 self.board.grid = grid
 179
 180                 # Update the player's boards
 181
 182         def run(self):
 183                 move_count = 0
 184                 line = self.src.readline().strip(" \r\n")
 185                 while line != "# EOF":
 186                         if self.stopped():
 187                                 break
 188
 189
 190
 191                         if line[0] == '#':
 192                                 line = self.src.readline().strip(" \r\n")
 193                                 continue
 194
 195                         tokens = line.split(" ")
 196                         if tokens[0] == "white" or tokens[0] == "black":
 197                                 self.reset_board(line)
 198                                 line = self.src.readline().strip(" \r\n")
 199                                 continue
 200
 201                         move = line.split(":")
 202                         move = move[len(move)-1].strip(" \r\n")
 203                         tokens = move.split(" ")
 204
 205
 206                         try:
 207                                 [x,y] = map(int, tokens[0:2])
 208                         except:
 209                                 self.stop()
 210                                 break
 211
 212                         log(move)
 213
 214                         target = self.board.grid[x][y]
 215                         with self.lock:
 216                                 if target.colour == "white":
 217                                         self.state["turn"] = self.players[0]
 218                                 else:
 219                                         self.state["turn"] = self.players[1]
 220
 221                         move_piece = (tokens[2] == "->")
 222                         if move_piece:
 223                                 [x2,y2] = map(int, tokens[len(tokens)-2:])
 224
 225                         if isinstance(graphics, GraphicsThread):
 226                                 with graphics.lock:
 227                                         graphics.state["select"] = target
 228
 229                         if not move_piece:
 230                                 self.board.update_select(x, y, int(tokens[2]), tokens[len(tokens)-1])
 231                                 if isinstance(graphics, GraphicsThread):
 232                                         with graphics.lock:
 233                                                 graphics.state["moves"] = self.board.possible_moves(target)
 234                                         time.sleep(turn_delay)
 235                         else:
 236                                 self.board.update_move(x, y, x2, y2)
 237                                 if isinstance(graphics, GraphicsThread):
 238                                         with graphics.lock:
 239                                                 graphics.state["moves"] = [[x2,y2]]
 240                                         time.sleep(turn_delay)
 241                                         with graphics.lock:
 242                                                 graphics.state["select"] = None
 243                                                 graphics.state["moves"] = None
 244                                                 graphics.state["dest"] = None
 245
 246
 247
 248
 249
 250                         for p in self.players:
 251                                 p.update(move)
 252
 253                         line = self.src.readline().strip(" \r\n")
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270                 if self.max_lines != None and self.max_lines > count:
 271                         sys.stderr.write(sys.argv[0] + " : Replaying from file; stopping at last line (" + str(count) + ")\n")
 272                         sys.stderr.write(sys.argv[0] + " : (You requested line " + str(self.max_lines) + ")\n")
 273
 274                 if self.end and isinstance(graphics, GraphicsThread):
 275                         #graphics.stop()
 276                         pass # Let the user stop the display
 277                 elif not self.end:
 278                         global game
 279                         game = GameThread(self.board, self.players)
 280                         game.run()
 281
 282
 283
 284
 285 def opponent(colour):
 286         if colour == "white":
 287                 return "black"
 288         else:
 289                 return "white"