def main():
cb = ChessBoard()
color = ('w', 'b')
player = 0
cb.set_allowed_color(color[player])
while(1):
print '-------------------------------------\n', str(cb), '\n-------------------------------------\n'
inp = raw_input("Player%s's move: " % (player,))
try:
sx, sy, dx, dy = inp.split(' ')
except:
if inp == 'exit':
break
if not cb.move(int(sx), int(sy), int(dx), int(dy)):
print 'Invalid move'
continue
player = (player + 1) % 2
cb.set_allowed_color(color[player])
class Game:
"""
Class to represent a game instance.
"""
def __init__(self, whites, blacks, gameIndex):
self.game_id = gameIndex
self.validMovesCounter = 0
self.white = whites
self.white.game_id = self.game_id
self.white.game = self
self.black = blacks
self.black.game_id = self.game_id
self.black.game = self
self.chessBoard = ChessBoard()
self.lightBoard = LightBoard()
self.notifyReady()
def notifyReady(self):
self.sendMessageToAll({"type": "status", "status": "ready"})
self.white.state = "PLAYING"
self.black.state = "PLAYING"
def move(self, x1, y1, x2, y2, color):
piece = self.chessBoard.grid[x1][y1]
if piece is not None and piece.color is not color:
raise IllegalMove(
"Trying to move a place that does not belong to the player.")
self.chessBoard.move(x1, y1, x2, y2, disp=False)
self.lightBoard.move(x1, y1, x2, y2)
self.validMovesCounter += 1
def autoMove(self):
return self.chessBoard.auto_move()
def checkEnd(self, color):
outcome = self.chessBoard.end_game()
msg = {"type": "chat", "content": outcome}
self.sendMessageTo(msg, color)
def updateLightBoardTask(self):
for col in [0, 1]:
for i, piece in enumerate(self.chessBoard.pieces[col]):
if piece is not None:
color = piece.color
position = piece.position
natures = self.chessBoard.all_legal_natures(piece)
pieceIndex = i + col * 24
self.lightBoard.setPiece(pieceIndex, color, position,
natures)
msg = {"type": "lightboard", "description": self.lightBoard.wrapUp()}
self.sendMessageToAll(msg)
def updateLightBoard(self):
""" Schedules an update board task. """
reactor.callLater(0.5, self.updateLightBoardTask)
def sendMessageToAll(self, msg):
self.white.sendMessage(msg)
self.black.sendMessage(msg)
def sendMessageTo(self, msg, color):
if color == 0:
self.white.sendMessage(msg)
elif color == 1:
self.black.sendMessage(msg)
else:
pass
def disconnectPlayers(self):
self.white.disconnect()
self.black.disconnect()
def pygame_mainloop():
#pygame board test
cb = ChessBoard()
color = ('w', 'b')
player = 0
cb.set_allowed_color(color[player])
screen = pygame.display.set_mode((640, 480))
board, chess = load_images()
selected=pygame.Surface((32,24),pygame.SWSURFACE|pygame.SRCALPHA,32)
#selected.set_alpha(60)
selected.fill((255,255,0))
selection = False
sx, sy = None, None
offset = 22
print 'player\'s', player, 'turn'
while 1:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
return
elif event.type == pygame.MOUSEBUTTONUP:
x, y = event.pos
x -= offset
y -= offset
if 0 <= x <= 255 and 0 <= y <= 191:
x /= 32
y /= 24
if selection:
selection = False
if cb.move(int(sx), int(sy), int(x), int(y)):
player = (player + 1) % 2
cb.set_allowed_color(color[player])
print 'player\'s', player, 'turn'
sx, sy = None, None
else:
sx, sy = x, y
if cb.getPiece(x, y)[0] == color[player]:
selection = True
else:
sx, sy = None, None
screen.fill((109,165, 165))
screen.blit(board, (offset, offset))
if sx != None and sy != None:
screen.blit(selected, (sx*32+offset+2, sy*24+offset+2))
for y, col in enumerate(cb.getBoard()):
for x, piece in enumerate(col):
if piece[0] != ' ':
screen.blit(chess[piece], (x*32+offset, y*24+offset-12))
pygame.display.update()
time.sleep(0.04)
class TwoPlayersOnOneBoard(GameEngine):
def __init__(self, gameEngine):
"""
Constructor.
:param gameEngine: The initial game engine.
"""
self.chessBoard = ChessBoard()
self.lightBoard = gameEngine.lightBoard
self.display = gameEngine.display
self.loopingCall = gameEngine.loopingCall
self.validMovesCounter = 0
@inlineCallbacks
def updateLightBoard(self):
nb = self.validMovesCounter
for col in [0, 1]:
for i, piece in enumerate(self.chessBoard.pieces[col]):
if nb == self.validMovesCounter:
self.updateDeferred = Deferred()
self.updateDeferred.addCallback(self.chessBoard.all_legal_natures)
self.updateDeferred.addErrback(log.err) # DEBUG
reactor.callLater(0, self.updateDeferred.callback, piece)
natures = yield self.updateDeferred
if nb == self.validMovesCounter:
color = piece.color
position = piece.position
pieceIndex = i + col * 24
self.lightBoard.setPiece(pieceIndex, color, position, natures)
if (piece.position is not None) and (piece.position is not False):
self.makeDisplayDrawBoard()
elif (piece.position is False):
self.display.updatePane()
def moveTask(self, mov):
x1, y1, x2, y2 = mov[0], mov[1], mov[2], mov[3]
try:
self.chessBoard.move(x1, y1, x2, y2, disp=False)
self.lightBoard.move(x1, y1, x2, y2)
color = "Whites" if (self.validMovesCounter % 2 == 0) else "Blacks"
self.display.addMessage(color + " move from ({},{}) to ({},{})".format(x1, y1, x2, y2))
self.validMovesCounter += 1
self.display.setLastMove(x1, y1, x2, y2)
self.makeDisplayDrawBoard()
self.updateLightBoard()
except IllegalMove as e:
self.handleIllegalMove(str(e))
def move(self, x1, y1, x2, y2):
d = Deferred()
d.addCallback(self.moveTask).addErrback(log.err) # DEBUG
reactor.callLater(0, d.callback, (x1, y1, x2, y2))
def autoMove(self):
try:
return self.chessBoard.auto_move()
except IllegalMove as e: # In case the game has ended
self.handleIllegalMove(str(e))
def checkEndTask(self):
outcome = self.chessBoard.end_game()
self.display.addMessage(outcome)
