chess-first-cut.py

## b = InitialChessBoard()
## print str(b)
#. rnbqkbnr
#. pppppppp
#.         
#.         
#.         
#.         
#. PPPPPPPP
#. RNBQKBNR
#. 
## pw = HumanPlayer(white)
## pb = HumanPlayer(black)
## b.outcome
## m = b.parse_move('resign')
## b1 = m.update(b)
## b1.outcome
#. 'black'

def main():
    play_chess(HumanPlayer, HumanPlayer)

def play_chess(white_strategy, black_strategy):
    return play(InitialChessBoard(), [white_strategy, black_strategy])

def play(board, strategies):
    players = [strategy(side)
               for strategy, side in zip(strategies, board.get_sides())]
    while board.get_outcome() is None:
        board = board.play_turn(players)
    for player in players:
        player.on_game_over(board)

class HumanPlayer:

    def __init__(self, side):
        self.side = side

    def pick_move(self, board):
        board.show()
        while True:
            string = raw_input('%s, your move? ' % self.side.capitalize())
            try:
                move = board.parse_move(string)
            except MoveIllegal:
                print 'Illegal move.'
            else:
                return move

    def on_game_over(self, board):
        board.show()
        if board.get_outcome() is None:
            pass
        elif board.get_outcome() == self.side:
            print '%s, you win!' % self.side.capitalize()
        elif board.get_outcome() == 'draw':
            print 'You draw.'
        else:
            print '%s, you lose!' % self.side.capitalize()

def InitialChessBoard():
    squares = ['----------',
               '-rnbqkbnr-',
               '-pppppppp-',
               '-        -',
               '-        -',
               '-        -',
               '-        -',
               '-PPPPPPPP-',
               '-RNBQKBNR-',
               '----------',]
    return ChessBoard(white, squares, (False, False), None)

class MoveIllegal(Exception):
    pass

class ChessBoard:

    def __init__(self, mover, squares, castled, outcome):
        self.mover = mover
        self.squares = squares
        self.castled = castled
        self.outcome = outcome

    def __str__(self):
        return '\n'.join(line[1:-1] for line in self.squares[1:-1])

    def get_mover(self):
        return self.mover

    def has_castled(self, player):
        return self.castled[player == black]

    def get_outcome(self):
        "Return None, 'draw', black, or white (meaning the winner)."
        return self.outcome

    def resign(self):
        return ChessBoard(opponent(self.mover),
                          self.squares,
                          self.castled,
                          opponent(self.mover))

    def show(self):
        print self

    def get_sides(self):
        return (white, black)

    def play_turn(self, (white_player, black_player)):
        player = white_player if self.get_mover() == white else black_player
        move = player.pick_move(self)
        if move in self.get_moves():
            return move.update(self)
        raise Exception("Bad move")

    def parse_move(self, string):
        for move in self.get_moves():
            if move.matches(string):
                return move
        raise Exception("Illegal or ill-formed move")

    def get_moves(self):
        return [ResignMove()] + self.get_piece_moves()

    def get_piece_moves(self):
        return []                    # XXX

white, black = 'white', 'black'

def opponent(side):
    return black if side == white else white

class ResignMove:
    def __eq__(self, other):
        return isinstance(other, ResignMove)
    def update(self, board):
        return board.resign()
    def matches(self, string):
        return string.lower() == 'resign'

if __name__ == '__main__':
    main()