MPagodNaAko

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:")
    return dmove


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



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)
        return dx1,dy1,dx2,dy2



def convertlmove(lmove):

    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)

    #if len(lmove)>5:



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

def dmovement1(board):
    board[dx1][dy1],board[dx2][dy2]=board[dx2][dy2],board[dx1][dy1]
    board[dx2][dy2],board[dx3][dy3]=board[dx3][dy3],board[dx2][dy2]
    return board

#def dmovement2(board):
    #board[dx1][dy1],board[dx2][dy2]=board[dx2][dy2],board[dx1][dy1]
    #board[dx2][dy2],board[dx3][dy3]=board[dx3][dy3],board[dx2][dy2]
    #board[dx3][dy3],board[dx4][dy4]=board[dx4][dy4],board[dx3][dy3]
    #return board


def lmovement(board):
    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)
            elif dx2==dx1+1 and dy2==dy1+1:
                dmovement(board)
            elif dx2==dx1+2 or dx2==dx1-2 or dy2==dy1-2 or dy2==dy1+2:
                darkcapture()
            elif dx2!=dx1+1 or dy2!=dy1+1 or dy2!=dy1-1 or dx2!=dx1+2 or dx2!=dx1-2 or dy2!=dy1-2 or dy2!=dy1+2:
                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()
    elif dmove=="END" or dmove=="end" or dmove=="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)
                elif lx2==lx1-1 and ly2==ly1+1:
                    lmovement(board)
                elif lx2==lx1+2 or lx2==lx1-2 or ly2==ly1-2 or ly2==ly1+2:
                    lightcapture()
                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 lmove=="END" or lmove=="end" or lmove=="End":
        end()
    elif len(lmove)<5 and not ("END" or "end" or "End"):
        print("Invalid input. Try again.")
        move_l()
        convertlmove(lmove)
        validity_check_l()


def darkcapture():
    global dcapture
    dcapture = 0
    for x in range (8):
        for y in range(8):
            if board[x][y]=="x" or board[x][y]=="X":
                if x-2 >= 0 or y-2 >= 0:
                    if board[x-1][y-1]=="o" or board[x-1][y-1]=="O":
                        if board[x-2][y-2]=="-":
                            if dx2==x-2 and dy2==y-2:
                                board[x-1][y-1]="-"
                                dmovement(board)
                                dcapture +=1
                                return dcapture
                            elif dx2!=x-2 and dy2!=y-2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x], rettel[y-2],rebmun[x-2])
                                move_d()
                                convertdmove(dmove)
                                darkcapture()
                if x-2 >= 0 or y+2 < 8:
                    if board[x-1][y+1]=="o" or board[x-1][y+1]=="O":
                        if board[x-2][y+2]=="-":
                            if dx2==x-2 and dy2==y+2:
                                board[x-1][y+1]="-"
                                dmovement(board)
                                dcapture += 1
                                return dcapture
                            elif dx2!=x-2 or dy2!=y+2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x],rettel[y+2],rebmun[x-2])
                                move_d()
                                convertdmove(dmove)
                                darkcapture()
                if x+2 < 8 and y-2 >= 0:
                    if board[x+1][y-1]=="o" or board[x+1][y-1]=="O":
                        if board[x+2][y-2]=="-":
                            if dx2==x+2 or dy2==y-2:
                                board[x+1][y-1]="-"
                                dmovement(board)
                                dcapture += 1
                                return dcapture
                            elif dx2!=x+2 and dy2!=y-2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x],rettel[y-2],rebmun[x+2])
                                move_d()
                                convertdmove(dmove)
                                darkcapture()
                if x+2 < 8 or y+2 < 8:
                    if board[x+1][y+1]=="o" or board[x+1][y+1]=="O":
                        if board[x+2][y+2]=="-":
                            if dx2==x+2 and dy2==x+2:
                                 board[x+1][y+1]="-"
                                 dmovement(board)
                                 dcapture += 1
                                 return dcapture
                            elif dx2!=x+2 and dy2!=y+2:
                                print("Invalid input. Mandatory capture on",rettel[y],rebmun[x],rettel[y+2],rebmun[x+2])
                                move_d()
                                convertdmove(dmove)
                                darkcapture()
                    else:
                        continue
                else:
                    continue
            else:
                continue

def lightcapture():
    global lcapture
    lcapture = 0
    for x in range (8):
        for y in range(8):
            if board[x][y]=="o" or board[x][y]=="O":
                if x-2 >= 0 or y-2 >= 0:
                    if board[x-1][y-1]=="x" or board[x-1][y-1]=="X":
                        if board[x-2][y-2]=="-":
                            if lx2==x-2 and ly2==y-2:
                                board[x-1][y-1]="-"
                                lmovement(board)
                                lcapture += 1
                                return lcapture
                            elif lx2!=x-2 or ly2!=y-2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x],rettel[y-2],rebmun[x-2])
                                move_l()
                                convertlmove(lmove)
                                lightcapture()
                if x-2 >= 0 or y+2 < 8:
                    if board[x-1][y+1]=="x" or board[x-1][y+1]=="X":
                        if board[x-2][y+2]=="-":
                            if lx2==x-2 and ly2==y+2:
                                board[x-1][y+1]="-"
                                lmovement(board)
                                lcapture += 1
                                return lcapture
                            elif lx2!=x-2 or ly2!=y+2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x],rettel[y+2],rebmun[x-2])
                                move_l()
                                convertlmove(lmove)
                                lightcapture()
                if x+2 < 8 and y-2 >= 0:
                    if board[x+1][y-1]=="x" or board[x+1][y-1]=="X":
                        if board[x+2][y-2]=="-":
                            if lx2==x+2 and ly2==y-2:
                                board[x+1][y-1]="-"
                                lmovement(board)
                                lcapture += 1
                                return lcapture
                            elif lx2!=x+2 or ly2!=y-2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x],rettel[y-2],rebmun[x+2])
                                move_l()
                                convertlmove(lmove)
                                lightcapture()
                if x+2 < 8 or y+2 <8:
                    if board[x+1][y+1]=="x" or board[x+1][y+1]=="X":
                        if board[x+2][y+2]=="-":
                            if lx2==x+2 and ly2==y+2:
                                board[x+1][y+1]="-"
                                lmovement(board)
                                lcapture += 1
                                return
                            elif lx2!=x+2 and ly2==y+2:
                                print("Invalid input. Mandatory capture on", rettel[y],rebmun[x], rettel[y+2],number[x+2])
                                move_l()
                                convertlmove(lmove)
                                lightcapture()
                        else:
                            continue
                    else:
                        continue
                else:
                    continue


def end():
    lcapture = lightcapture()
    dcapture = darkcapture()
    print("ENDING GAME", "\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!")

def darkking():
    if dx2==7 and dy2==0:
        board[dx2][dy2]="X"
    elif dx2==7 and dy2==2:
        board[dx2][dy2]="X"
    elif dx2==7 and dy2==4:
        board[dx2][dy2]="X"
    elif dx2==7 and dy2==6:
        board[dx2][dy2]="X"

def lightking():
    if lx2==0 and ly2==1:
        board[lx2][ly2]="O"
    elif lx2==0 and ly2==3:
        board[lx2][ly2]="O"
    elif lx2==0 and ly2==5:
        board[lx2][ly2]="O"
    elif lx2==0 and ly2==7:
        board[lx2][ly2]="O"

def darkkingcheck():
    if dx1%2==0 or dx2%2==0 or dx1==0 or dx2==0:
                if dy1==1 or dy1==3 or dy1==5 or dy1==7 or dy2==1 or dy2==3 or dy2==5 or dy2==7:
                    dmovement()
    elif dx1==1 or dx1==3 or dx1==5 or dx1==7 or dx2==1 or dx2==3 or dx2==5 or dx2==7:
                if dy1%2==0 or dy2%2==0 or dy1==0 or dy2==0:
                   dmovement()
    else:
        print("Invalid input.Try again.")
        move_d()
        convertdmove(dmove)
        darkkingcheck()

def lightkingcheck():
    if lx1%2==0 or lx2%2==0 or lx1==0 or lx2==0:
                if ly1==1 or ly1==3 or ly1==5 or ly1==7 or ly2==1 or ly2==3 or ly2==5 or ly2==7:
                    lmovement(board)
    elif lx1==1 or lx1==3 or lx1==5 or lx1==7 or lx2==1 or lx2==3 or lx2==5 or lx2==7:
                if ly1%2==0 or ly2%2==0 or ly1==0 or ly2==0:
                   dmovement(board)
    else:
        print("Invalid input.Try again.")
        move_l()
        convertlmove(lmove)
        lightkingcheck()



def darkmove():
    move_d()
    convertdmove(dmove)
    validity_check_d()
    if board[7]=="x":
        darkking()
        darkkingcheck()

    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)
    validity_check_l()
    if board[0]=="o":
        lightking()
        lightkingcheck()
    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)



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