ChessMastah_05.py

#!/usr/bin/env python
import os,sys,random

# Chessmastah, started Jan 2012 by Svein Arne Roed
#
# Available at https://sites.google.com/site/marsarsite/files or
# http://www.python-forum.org/pythonforum/viewtopic.php?f=2&t=31849
#
# Contact: svein+roed 'a+t' Gmail
#
# Version 0.5 hereby released :
#
# Castling
# En passant
# Choice between Knight and Queen when promoting a Pawn
# Game now ends in a draw if:
# * only kings are left
# * no possible moves (and isn't in check)
# * 50 consecutive moves without movement of a Pawn or a capture
# Various fixes and cleanup, thanks to cProfile - more efficient code
# Play against (random) computer
#
# "AI" not rewritten to classes yet, so computer is simply picking
# a random move.
#
# Thanks to python-forum.org's users Akavall and Micseydel
# for constructive feedback.


class Player(object):

    allsquares = [(x, y) for x in range(8) for y in range(8)]
    dullmoves = 0

    def __init__(self, colour, nature, name):

        self.colour   = colour
        self.nature   = nature
        self.name     = name
        self.can_castle_long_this_turn  = False
        self.can_castle_short_this_turn = False
        self.playedturns = 0

    def __str__(self):
        if self.nature is 'AI':
            return self.name+' ('+self.nature+')'+' as '+self.colour
        else:
            return self.name+' as '+self.colour

    def set_opponent(self, opponent):
        self.opponent = opponent

    def getpieces(self, board):
        return [pos for pos in board if board[pos].colour is self.colour]

    def potentialtargets(self, playerspieces):
        return [pos for pos in self.allsquares if pos not in playerspieces]

    def kingpos(self, board):
        for mine in self.getpieces(board):
            if board[mine].piecename is 'k':
                return mine

    def validmoves(self, board):
        self.set_castling_flags(board)

        mypieces=self.getpieces(board)
        for mine in mypieces:
            for target in self.potentialtargets(mypieces):
                if self.canmoveto(board, mine, target):
                    if not self.makesuscheck(mine, target, board):
                        yield (mine, target)

    def set_castling_flags(self, board):
        kingpos = self.kingpos(board)
        if self.king_can_castle(board, kingpos):

            if self.rook_can_castle_long(board, kingpos):
                self.can_castle_long_this_turn = True
            else:
                self.can_castle_long_this_turn = False

            if self.rook_can_castle_short(board, kingpos):
                self.can_castle_short_this_turn = True
            else:
                self.can_castle_short_this_turn = False
        else:
            self.can_castle_long_this_turn = False
            self.can_castle_short_this_turn = False

    def king_can_castle(self, board, kingpos):
        if board[kingpos].nrofmoves is 0 and not self.isincheck(board):
            return True

    def rook_can_castle_long(self, board, kingpos):
        if self.longrook in board and board[self.longrook].nrofmoves is 0:
            if self.hasclearpath(self.longrook, kingpos, board):
                tmptarget = (kingpos[0],kingpos[1]-1)
                if not self.makesuscheck(kingpos, tmptarget, board):
                    return True

    def rook_can_castle_short(self, board, kingpos):
        if self.shortrook in board and board[self.shortrook].nrofmoves is 0:
            if self.hasclearpath(self.shortrook, kingpos, board):
                tmptarget = (kingpos[0],kingpos[1]+1)
                if not self.makesuscheck(kingpos, tmptarget, board):
                    return True

    def getposition(self, move):
        startcol  = int(ord(move[0].lower())-97)
        startrow  = int(move[1])-1
        targetcol = int(ord(move[2].lower())-97)
        targetrow = int(move[3])-1
        start     = (startrow, startcol)
        target    = (targetrow, targetcol)

        return start, target

    def reacheddraw(self, board):

        if not list(self.validmoves(board)) and not self.isincheck(board):
            return True

        if len(list(self.getpieces(board))) == \
           len(list(self.opponent.getpieces(board))) == 1:
            return True

        if Player.dullmoves/2 == 50:
            if self.nature is 'AI':
                return True
            else:
                if raw_input("Call a draw? (yes/no) : ") in ['yes','y','Yes']:
                    return True

    def ischeckmate(self, board):

        if not list(self.validmoves(board)) and self.isincheck(board):
            return True

    def turn(self, board):
       
        turnstring = "\n%s's turn," % self.name
        warning = " *** Your King is in check *** "
        if self.isincheck(board):
            turnstring = turnstring + warning

        return turnstring

    def getmove(self, board):

        print "\n"
        while True:

            # If player is computer, get a move from computer
            if self.nature is 'AI':
                #return aiengine.getAImove(self, board)
                return random.choice(list(self.validmoves(board)))

            else:
                # Player is human, get a move from input
                move=raw_input("\nMake a move : ")
                if move == 'exit':
                    break

                else:
                    start, target = self.getposition(move)
                    if (start, target) in self.validmoves(board):
                        return start, target
                    else:
                        raise IndexError

    def makesuscheck(self, start, target, board):
        # Make temporary move to test for check
        self.domove(board, start, target)

        retval = self.isincheck(board)
        
        # Undo temporary move
        self.unmove(board, start, target)

        return retval

    def isincheck(self, board):
        kingpos = self.kingpos(board)
        for enemy in self.opponent.getpieces(board):
            if self.opponent.canmoveto(board, enemy, kingpos):
                return True

    def domove(self, board, start, target):

        self.savedtargetpiece = None
        if target in board:
            self.savedtargetpiece = board[target]

        board[target] = board[start]
        board[target].position = target
        del board[start]

        board[target].nrofmoves += 1

        if board[target].piecename is 'p' and not self.savedtargetpiece:

            if abs(target[0]-start[0]) == 2:
                board[target].turn_moved_twosquares = self.playedturns

            elif abs(target[1]-start[1]) == abs(target[0]-start[0]) == 1:
                # Pawn has done en passant, remove the victim
                if self.colour is 'white':
                    passant_victim = (target[0]-1, target[1])
                else:
                    passant_victim = (target[0]+1, target[1])
                self.savedpawn = board[passant_victim]
                del board[passant_victim]

        if board[target].piecename is 'k':
            if target[1]-start[1] == -2:
                # King is castling long, move longrook
                self.domove(board, self.longrook, self.longrook_target)
            elif target[1]-start[1] == 2:
                # King is castling short, move shortrook
                self.domove(board, self.shortrook, self.shortrook_target)

    def unmove(self, board, start, target):

        board[start] = board[target]
        board[start].position = start
        if self.savedtargetpiece:
            board[target] = self.savedtargetpiece
        else:
            del board[target]

        board[start].nrofmoves -= 1

        if board[start].piecename is 'p' and not self.savedtargetpiece:

            if abs(target[0]-start[0]) == 2:
                del board[start].turn_moved_twosquares

            elif abs(target[1]-start[1]) == abs(target[0]-start[0]) == 1:
                # We have moved back en passant Pawn, restore captured Pawn
                if self.colour is 'white':
                    formerpos_passant_victim = (target[0]-1, target[1])
                else:
                    formerpos_passant_victim = (target[0]+1, target[1])
                board[formerpos_passant_victim] = self.savedpawn

        if board[start].piecename is 'k':
            if target[1]-start[1] == -2:
                # King's castling long has been unmoved, move back longrook
                self.unmove(board, self.longrook, self.longrook_target)
            elif target[1]-start[1] == 2:
                # King's castling short has been unmoved, move back shortrook
                self.unmove(board, self.shortrook, self.shortrook_target)

    def pawnpromotion(self, board, target):
        if self.nature is 'AI':
            # See if Knight makes opponent checkmate
            board[target].promote('kn')
            if self.opponent.ischeckmate(board):
                return
            else:
                promoteto = 'q'
                
        else:
            promoteto = 'empty'
            while promoteto.lower() not in ['kn','q']:
                promoteto = \
                raw_input("You may promote your pawn:\n[Kn]ight [Q]ueen : ")

        board[target].promote(promoteto)

    def hasclearpath(self, start, target, board):

        startcol, startrow = start[1], start[0]
        targetcol, targetrow = target[1], target[0]

        if abs(startrow - targetrow) <= 1 and abs(startcol - targetcol) <= 1:
            # The base case
            return True
        else:
            if targetrow > startrow and targetcol == startcol:
                # Straight down
                tmpstart = (startrow+1,startcol)
            elif targetrow < startrow and targetcol == startcol:
                # Straight up
                tmpstart = (startrow-1,startcol)
            elif targetrow == startrow and targetcol > startcol:
                # Straight right
                tmpstart = (startrow,startcol+1)
            elif targetrow == startrow and targetcol < startcol:
                # Straight left
                tmpstart = (startrow,startcol-1)
            elif targetrow > startrow and targetcol > startcol:
                # Diagonal down right
                tmpstart = (startrow+1,startcol+1)
            elif targetrow > startrow and targetcol < startcol:
                # Diagonal down left
                tmpstart = (startrow+1,startcol-1)
            elif targetrow < startrow and targetcol > startcol:
                # Diagonal up right
                tmpstart = (startrow-1,startcol+1)
            elif targetrow < startrow and targetcol < startcol:
                # Diagonal up left
                tmpstart = (startrow-1,startcol-1)

            # If no pieces in the way, test next square
            if tmpstart in board:
                return False
            else:
                return self.hasclearpath(tmpstart, target, board)

    def canmoveto(self, board, start, target):

        startpiece = board[start].piecename.upper()

        if startpiece == 'R' and not self.check_rook(start, target):
            return False
        elif startpiece == 'KN' and not self.check_knight(start, target):
            return False
        elif startpiece == 'P' and not self.check_pawn(start, target, board):
            return False
        elif startpiece == 'B' and not self.check_bishop(start, target):
            return False
        elif startpiece == 'Q' and not self.check_queen(start, target):
            return False
        elif startpiece == 'K' and not self.check_king(start, target):
            return False

        # Only the 'Knight' may jump over pieces
        if startpiece in 'RPBQK':
            if not self.hasclearpath(start, target, board):
                return False

        return True

    def check_rook(self, start, target):

        # Check for straight lines of movement(start/target on same axis)
        if start[0] == target[0] or start[1] == target[1]:
            return True

    def check_knight(self, start, target):

        # 'Knight' may move 2+1 in any direction and jump over pieces
        if abs(target[0]-start[0]) == 2 and abs(target[1]-start[1]) == 1:
            return True
        elif abs(target[0]-start[0]) == 1 and abs(target[1]-start[1]) == 2:
            return True

    def check_pawn(self, start, target, board):

        # Disable backwards and sideways movement
        if 'white' in self.colour and target[0] < start[0]:
            return False
        elif 'black' in self.colour and target[0] > start[0]:
            return False
        if start[0] == target[0]:
            return False

        if target in board:
            # Only attack if one square diagonaly away
            if abs(target[1]-start[1]) == abs(target[0]-start[0]) == 1:
                return True
        else:
            # Make peasants move only one forward (except first move)
            if start[1] == target[1]:
                # Normal one square move
                if abs(target[0]-start[0]) == 1:
                    return True
                # 1st exception to the rule, 2 square move first time
                if board[start].nrofmoves is 0:
                    if abs(target[0]-start[0]) == 2:
                        return True

            # 2nd exception to the rule, en passant
            if start[0] == self.enpassantrow:
                if abs(target[0]-start[0]) == 1:
                    if abs(target[1]-start[1]) == 1:
                        if target[1]-start[1] == -1:
                            passant_victim = (start[0], start[1]-1)
                        elif target[1]-start[1] == 1:
                            passant_victim = (start[0], start[1]+1)
                        if passant_victim in board and \
                        board[passant_victim].colour is not self.colour and \
                        board[passant_victim].piecename is 'p'and \
                        board[passant_victim].nrofmoves == 1 and \
                        board[passant_victim].turn_moved_twosquares == \
                        self.playedturns-1:
                            return True

    def check_bishop(self, start, target):

        # Check for non-horizontal/vertical and linear movement
        if abs(target[1]-start[1]) == abs(target[0]-start[0]):
            return True

    def check_queen(self, start, target):

        # Will be true if move can be done as Rook or Bishop
        if self.check_rook(start, target) or self.check_bishop(start, target):
            return True

    def check_king(self, start, target):

        # King can move one square in any direction
        if abs(target[0]-start[0]) <= 1 and abs(target[1]-start[1]) <= 1:
            return True

        # ..except when castling
        if self.can_castle_short_this_turn:
            if target[1]-start[1] == 2 and start[0] == target[0]:
                return True

        if self.can_castle_long_this_turn:
            if target[1]-start[1] == -2 and start[0] == target[0]:
                return True

class Piece(object):

    def __init__(self, piecename, position, player):
        self.colour    = player.colour
        self.nature    = player.nature
        self.piecename = piecename
        self.position  = position
        self.nrofmoves = 0

    def __str__(self):
        if self.colour is 'white':
            if self.piecename is 'p':
                return 'WP'
            else:
                return self.piecename.upper()
        else:
            return self.piecename

    def canbepromoted(self):
        if str(self.position[0]) in '07':
            return True

    def promote(self, to):
        self.piecename = to.lower()


class Game(object):

    def __init__(self, playera, playerb):

        self.board = dict()
        for player in [playera, playerb]:
            if player.colour is 'white':
                brow, frow = 0, 1
                player.enpassantrow = 4
            else:
                brow, frow = 7, 6
                player.enpassantrow = 3

            player.longrook  = (brow, 0)
            player.longrook_target = \
            (player.longrook[0], player.longrook[1]+3)
            
            player.shortrook = (brow, 7)
            player.shortrook_target = \
            (player.shortrook[0], player.shortrook[1]-2)
            

            [self.board.setdefault((frow,x), Piece('p', (frow,x), player)) \
            for x in range(8)]
            [self.board.setdefault((brow,x), Piece('r', (brow,x), player)) \
            for x in [0,7]]
            [self.board.setdefault((brow,x), Piece('kn',(brow,x), player)) \
            for x in [1,6]]
            [self.board.setdefault((brow,x), Piece('b', (brow,x), player)) \
            for x in [2,5]]
            self.board.setdefault((brow,3),  Piece('q', (brow,3), player))
            self.board.setdefault((brow,4),  Piece('k', (brow,4), player))

    def printboard(self):

        topbottom=['*','a','b','c','d','e','f','g','h','*']
        sides=['1','2','3','4','5','6','7','8']
        tbspacer=' '*6
        rowspacer=' '*5
        cellspacer=' '*4
        empty=' '*3

        print
        for field in topbottom:
            print "%4s" % field,
        print

        print tbspacer+("_"*4+' ')*8

        for row in range(8):
            print(rowspacer+(('|'+cellspacer)*9))
            print "%4s" % sides[row],('|'),
            for col in range(8):
                if (row, col) not in self.board:
                    print empty+'|',
                else:
                    print "%2s" % self.board[(row, col)],('|'),
            print "%2s" % sides[row],
            print
            print rowspacer+'|'+(("_"*4+'|')*8)
        print

        for field in topbottom:
            print "%4s" % field,

        print "\n"

    def refreshscreen(self, player):
        if player.colour is 'white':
            playera, playerb = player, player.opponent
        else:
            playera, playerb = player.opponent, player
        os.system('clear')
        print "   Now playing: %s vs %s" % (playera, playerb)
        self.printboard()

    def run(self, player):

        self.refreshscreen(player)

        while True:

            print player.turn(self.board)

            try:
                start, target = player.getmove(self.board)

            except (IndexError, ValueError):
                self.refreshscreen(player)
                print "\n\nPlease enter a valid move."

            except TypeError:
                # No start, target if user exit
                break

            else:
                if target in self.board or self.board[start].piecename is 'p':
                    Player.dullmoves = 0
                else:
                    Player.dullmoves += 1

                player.domove(self.board, start, target)
                player.playedturns += 1

                # Check if there is a Pawn up for promotion
                if self.board[target].piecename is 'p':
                    if self.board[target].canbepromoted():
                        player.pawnpromotion(self.board, target)

                player = player.opponent

                if player.reacheddraw(self.board):
                    return 1, player

                elif player.ischeckmate(self.board):
                    return 2, player

                else:
                    self.refreshscreen(player)

    def end(self, player, result):

        looser = player.name
        winner = player.opponent.name

        if result == 1:
            endstring = "\n%s and %s reached a draw." % (winner, looser)
        elif result == 2:
            endstring = "\n%s put %s in checkmate." % (winner, looser)

        os.system('clear')
        self.printboard()

        return endstring

def newgame():

    os.system('clear')

    print """
      Welcome to Chessmastah, the fantastic console chess environment.
      Please type in the name of the contestants.

      If you want to play against the computer, leave one name blank
      and press [Enter].

      Or if you fancy, leave both names blank and watch the computer
      duke it out with itself.
      """

    playera, playerb = getplayers()
    playera.set_opponent(playerb)
    playerb.set_opponent(playera)

    game = Game(playera, playerb)

    infostring = \
    """
    Very well, %s and %s, let's play.
    
    Player A: %s (uppercase)
    Player B: %s (lowercase)
    (Use moves on form 'a2b3' or type 'exit' at any time.) """
    print infostring % (playera.name, playerb.name, playera, playerb)

    raw_input("\n\nPress [Enter] when ready")

    # WHITE starts
    player = playera

    try:
        result, player = game.run(player)

    except TypeError:
        # No result if user exit
        pass

    else:
        print game.end(player, result)
        raw_input("\n\nPress any key to continue")

def getplayers():

    ainames = ['chesschick','foxysquare']

    name1 = raw_input("\nPlayer A (white): ")
    if not name1:
        playera = Player('white', 'AI', ainames[0])
    else:
        playera = Player('white', 'human', name1)

    name2 = raw_input("\nPlayer B (black): ")
    if not name2:
        playerb = Player('black', 'AI', ainames[1])
    else:
        playerb = Player('black', 'human', name2)

    return playera, playerb

def main():
    """ Kickstart everything. Display menu after game has ended. """
    
    menu="""
    Thanks for playing the Chessmastah, would you like to go again?
    Press [Enter] to play again or type 'exit'.  >>  """

    try:
        while True:
            newgame()

            choice=raw_input(menu)

            if choice == 'exit':
                print "\nAs you wish. Welcome back!"
                break

    except KeyboardInterrupt:
        sys.exit("\n\nOkok. Aborting.")


if __name__ == '__main__':
    #cProfile.run('main()')
    main()