print ("Welcome to Checkers!", "\n")
board= [ ["-" , "x" , "-" , "x" , "-" , "x", "-", "x" ,  8 ] ,
      ["x" , "-" , "x" , "-" , "x" , "-", "x", "-" , 7 ],
      ["-" , "x" , "-" , "x" , "-" , "x", "-", "x" ,  6 ],
      ["-" , "-" , "-" , "-" , "-" , "-", "-", "-" ,  5 ],
      ["-" , "-" , "-" , "-" , "-" , "-", "-", "-" ,  4 ],
      ["o" , "-" , "o" , "-" , "o" , "-", "o", "-" ,  3 ],
      ["-" , "o" , "-" , "o" , "-" , "o", "-", "o" ,  2 ],
      ["o" , "-" , "o" , "-" , "o" , "-", "o", "-" ,  1 ],
      ["A" , "B" , "C" , "D" , "E" , "F", "G", "H"] ]
for i in range (len(board)) :
    for j in range (len(board[i])) :
        print (board[i][j], end = " ")
    print ()

letter = {"A":0, "B":1 , "C":2 , "D":3 , "E":4 , "F":5 , "G":6, "H":7}
number = {"8":0, "7":1, "6":2, "5":3, "4":4, "3":5, "2":6, "1":7}
rettel = {0:"A", 1:"B", 2:"C", 3:"D", 4:"E", 5:"F", 6:"G", 7:"H"}
rebmun = {0:"8", 1:"7", 2:"6", 3:"5", 4:"4", 5:"3", 6:"2", 7:"1"}

def move_d():
    global dmove
    dmove = input("Dark pieces to play. Enter your move:")


def move_l():
    global lmove
    lmove = input("Light pieces to play. Enter your move:")


def convertdmove(dmove):

        da = dmove[0]
        db = dmove[1]
        dc = dmove[3]
        dd = dmove[4]
        global dx1
        global dy1
        global dx2
        global dy2
        dx1 = number[db]
        dx1 = int(dx1)
        dy1 = letter[da]
        dy1 = int(dy1)
        dx2 = number[dd]
        dx2 = int(dx2)
        dy2 = letter[dc]
        dy2 = int(dy2)


def convertlmove(lmove):

    if len(lmove)==5:
        la = lmove[0]
        lb = lmove[1]
        lc = lmove[3]
        ld = lmove[4]
        global lx1
        global ly1
        global lx2
        global ly2
        lx1 = number[lb]
        lx1 = int(lx1)
        ly1 = letter[la]
        ly1 = int(ly1)
        lx2 = number[ld]
        lx2 = int(lx2)
        ly2 = letter[lc]
        ly2 = int(ly2)

def dmovement(board,dx1,dy1,dx2,dy2):
    board[dx1][dy1],board[dx2][dy2]=board[dx2][dy2],board[dx1][dy1]
    return board

def lmovement(board,lx1,ly1,lx2,ly2):
    board[lx1][ly1],board[lx2][ly2]=board[lx2][ly2],board[lx1][ly1]
    return board

def validity_check_d():
    if len(dmove)>=5:
        if board[dx1][dy1]=="x":
            if dx2==dx1+1 and dy2==dy1-1:
                dmovement(board,dx1,dy1,dx2,dy2)
            elif dx2==dx1+1 and dy2==dy1+1:
                dmovement(board,dx1,dy1,dx2,dy2)
            elif dx2!=dx1+1 or dy2!=dy1-1 or dy2!=dy1+1:
                print("Invalid input.Try again.")
                move_d()
                convertdmove(dmove)
                validity_check_d()
        elif board[dx1][dy1]!="x":
            print("Invalid input. Wrong piece. Try again.")
            move_d()
            convertdmove(dmove)
            validity_check_d()
    elif len(dmove)<5:
            print("Invalid input. Try again.")
            move_d()
            convertdmove(dmove)
            validity_check_d()
    if dmove=="END" or lmove=="end" or lmove=="End":
        end()

def validity_check_l():
    if len(lmove)>=5:
        if board[lx1][ly1]=="o":
                if lx2==lx1-1 and ly2==ly1-1:
                    lmovement(board,lx1,ly1,lx2,ly2)
                elif lx2==lx1-1 and ly2==ly1+1:
                    lmovement(board,lx1,ly1,lx2,ly2)
                elif lx2!=lx1+1 or ly2!=ly1-1 or ly2!=ly1+1:
                    print("Invalid input.Try again.")
                    move_l()
                    convertlmove(lmove)
                    validity_check_l()
        elif board[lx1][ly1]!="o":
            print("Invalid input. Wrong piece. Try again.")
            move_l()
            convertlmove(lmove)
            validity_check_l()
    elif len(lmove)<5:
        print("Invalid input. Try again.")
        move_l()
        convertlmove(lmove)
        validity_check_l()
    if lmove=="END" or lmove=="end" or lmove=="End":
        end()



def darkcapture():
    global dcapture
    dcapture = 0
    while dcapture>=0:
        if dx2==dx1-2 and dy2==dy1-2:
            board[dx1][dy1]="-"
            board[dx1-1][dy1-1]="-"
            board[dx1-2][dy1-2]="x"
        elif dx2==dx1-2 and dy2==dy1-2:
            board[dx1][dy1]="-"
            board[dx1-1][dy1+1]="-"
            board[dx1-2][dy1+2]="x"
        elif dx2==dx1+2 and dy2==dy1-2:
            board[dx1][dy1]="-"
            board[dx1+1][dy1-1]="-"
            board[dx1+2][dy1-2]="x"
        elif dx2==dx1+2 and dy2==ly1+2:
            board[dx1][dy1]="-"
            board[dx1+1][dy1+1]="-"
            board[dx1+2][dy1+2]="x"
        dcapture += 1

def lightcapture():
    global lcapture
    lcapture = 0
    while lcapture>=0:
        if lx2==lx1-2 and ly2==ly1-2:
            board[lx1][ly1]="-"
            board[lx1-1][ly1-1]="-"
            board[lx1-2][ly1-2]="o"
        elif lx2==lx1-2 and ly2==ly1-2:
            board[lx1][ly1]="-"
            board[lx1-1][ly1+1]="-"
            board[lx1-2][ly1+2]="o"
        elif lx2==lx1+2 and ly2==ly1-2:
            board[lx1][ly1]="-"
            board[lx1+1][ly1-1]="-"
            board[lx1+2][ly1-2]="o"
        elif lx2==lx1+2 and ly2==ly1+2:
            board[lx1][ly1]="-"
            board[lx1+1][ly1+1]="-"
            board[lx1+2][ly1+2]="x"
        lcapture += 1

def checkcapture_men_d():
    for dx1 in range (0,7):
        for dy1 in range(0,7):
            if dx1+2 < 8 or dy1+2 < 8:
                if "x" in board[dx1][dy1]:
                    if "o" in board[dx1-1][dy1-1]:
                        if "-" in board[dx1-2][dy1-2]:
                            if dx2==dx1-2 and dy2==dy1-2:
                                darkcapture()
                            else:
                                print("Invalid input. Mandatory capture on", rettel[dx2],rebmun[dy2],".")
                                move_d()
                                convertdmove(dmove)
                                checkcapture_men_d(board)
                                darkcapture()
                        elif "o" in board[dx1-1][dy1+1]:
                            if "-" in board[dx1-2][dy1+2]:
                                if dx2==dx1-2 and dy2==dy1+2:
                                    darkcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[dy2],rebmun[dx2],".")
                                    move_d()
                                    convertdmove(dmove)
                                    checkcapture_men_d()
                                    darkcapture()
                        elif "o" in board[dx1+1][dy1-1]:
                            if "-" in board[dx1+2][dy1-2]:
                                if dx2==dx1+2 and dy2==dy1-2:
                                    darkcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[dy2],rebmun[dx2],".")
                                    move_d()
                                    convertdmove(dmove)
                                    checkcapture_men_d()
                                    darkcapture()
                        elif "o" in board[dx1+1][dy1+1]:
                            if "-" in board[dx1+2][dy1+2]:
                                if dx2==dx1+2 and dy2==dy1+2:
                                    darkcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[dy2],rebmun[dx2],".")
                                    move_d()
                                    convertdmove(dmove)
                                    checkcapture_men_d()
                                    darkcapture()
                else:
                    continue
            else:
                continue

def checkcapture_men_l():
    for lx1 in range (8):
        for ly1 in range(8):
            if lx1+2 < 8 or ly1+2 < 8:
                if board[lx1][ly1]==" o ":
                    if board[lx1-1][ly1-1]==" x ":
                        if board[lx1-2][ly1-2]==" - ":
                            if lx2==lx1-2 and ly2==ly1-2:
                                lightcapture()
                            else:
                                print("Invalid input. Mandatory capture on", rettel[ly2],rebmun[lx2],".")
                                move_l()
                                convertlmove(lmove)
                                validity_check_l(lmove,board,lx1,ly1,lx2,ly2)
                                checkcapture_men_l()
                                lightcapture()
                        elif "x" in board[lx1-1][ly1+1]:
                            if "-" in board[lx1-2][ly1+2]:
                                if lx2==lx1-2 and ly2==ly1+2:
                                    lightcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[ly2],rebmun[lx2],".")
                                    move_l()
                                    convertlmove(lmove)
                                    checkcapture_men_l()
                                    lightcapture()
                        elif "x" in board[lx1+1][ly1-1]:
                            if "-" in board[lx1+2][ly1-2]:
                                if lx2==lx1+2 and ly2==ly1-2:
                                    lightcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[ly2],rebmun[lx2],".")
                                    move_l()
                                    convertlmove(lmove)
                                    checkcapture_men_l()
                                    lightcapture()
                        elif "x" in board[lx1+1][ly1+1]:
                            if "-" in board[lx1+2][ly1+2]:
                                if lx2==lx1+2 and ly2==ly1+2:
                                    lightcapture()
                                else:
                                    print("Invalid input. Mandatory capture on", rettel[ly2],number[lx2],".")
                                    move_l()
                                    convertlmove(lmove)
                                    checkcapture_men_l()
                                    lightcapture()
                else:
                    continue
            else:
                continue



def darkmove():
    move_d()
    convertdmove(dmove)
    checkcapture_men_d()
    validity_check_d()
    for i in range (len(board)) :
        for j in range (len(board[i])) :
            print (board[i][j], end = " ")
        print ()
    print ("\n","Dark player played:", dmove)


def lightmove():
    move_l()
    convertlmove(lmove)
    checkcapture_men_l()
    validity_check_l()
    for i in range (len(board)) :
        for j in range (len(board[i])) :
            print (board[i][j], end = " ")
        print ()
    print ("\n","Light player played:", lmove)

def end():
        print("END.", "\n", "LIGHT PIECES =", lcapture, "POINTS.", "\n", "DARK PIECES = ", dcapture,"POINTS." )
        if lcapture>dcapture:
            print("LIGHT PIECES WON!", "\n")
        if dcapture>lcapture:
            print("DARK PIECES WON!", "\n")
        if dcapture==lcapture:
            print("DRAW!")


turn = 1
while turn>=1:
    if turn%2==0:
        darkmove()
    else:
        lightmove()
    turn +=1