lab_cards/amazons.py

from random import *
from os import system, name

def clear():
    if name == 'nt':
        _ = system('cls')
    else:
        _ = system('clear')

class Square:
    def __init__(self, location):
        self.location = location #where the square is as an [x,y] pair
        self.x = location[0]
        self.y = location[1]
        self.state = "empty" #behind the scenes data
        self.display = " "   #what the user will see

#The names of the squares are according to chess convention,
#but the coordinates are according to usual matrix notation.
a1 = Square([0,3])
a2 = Square([0,2])
a3 = Square([0,1])
a4 = Square([0,0])
b1 = Square([1,3])
b2 = Square([1,2])
b3 = Square([1,1])
b4 = Square([1,0])
c1 = Square([2,3])
c2 = Square([2,2])
c3 = Square([2,1])
c4 = Square([2,0])
d1 = Square([3,3])
d2 = Square([3,2])
d3 = Square([3,1])
d4 = Square([3,0])

board=[a1,a2,a3,a4,b1,b2,b3,b4,c1,c2,c3,c4,d1,d2,d3,d4]
board_strings=[]
for box in board:
    board_strings.append(str(box))

setup_seed = sample(board, 4) #We pick four squares for initial amazon placement

setup_seed[0].state = "ba1" #black amazon 1
setup_seed[1].state = "ba2" #black amazon 2
setup_seed[2].state = "wa1" #white amazon 1
setup_seed[3].state = "wa2" #white amazon 2

def display():   #This interprets the states of the squares for display
    for box in board:
        if box.state == "empty":
            box.display = " "
        if box.state == "ba1":
            box.display = "B"
        if box.state == "ba2":
            box.display = "B"
        if box.state == "wa1":
            box.display = "W"
        if box.state == "wa2":
            box.display = "W"
        if box.state == "fire":
            box.display = "X"

def gui():  #This displays the board state to the user
    #clear()
    display()
    print("  a b c d")
    print("4 "+a4.display+" "+b4.display+" "+c4.display+" "+d4.display)
    print("3 "+a3.display+" "+b3.display+" "+c3.display+" "+d3.display)
    print("2 "+a2.display+" "+b2.display+" "+c2.display+" "+d2.display)
    print("1 "+a1.display+" "+b1.display+" "+c1.display+" "+d1.display)

def choice_translate(box):
    if box == "a1":
        return a1
    if box == "a2":
        return a2
    if box == "a3":
        return a3
    if box == "a4":
        return a4
    if box == "b1":
        return b1
    if box == "b2":
        return b2
    if box == "b3":
        return b3
    if box == "b4":
        return b4
    if box == "c1":
        return c1
    if box == "c2":
        return c2
    if box == "c3":
        return c3
    if box == "c4":
        return c4
    if box == "d1":
        return d1
    if box == "d2":
        return d2
    if box == "d3":
        return d3
    if box == "d4":
        return d4
    else:
        return "invalid"


gui()
turn = "w"

amazon_choice = choice_translate(input("Choose a square containing one of your amazons (eg, c3): "))
while amazon_choice == "invalid":
    amazon_choice = choice_translate(input("That's not the name of any square. Try again: "))
if turn == "w":
    while (amazon_choice.state != "wa1") and (amazon_choice.state != "wa2"):
        amazon_choice = choice_translate(input("You don't have a queen there. Try again: "))
if turn == "b":
    while (amazon_choice.state != "ba1") and (amazon_choice.state != "ba2"):
        amazon_choice = choice_translate(input("You don't have a queen there. Try again: "))

gui()

move_choice = choice_translate(input("Choose the square you want to move to: "))
while move_choice == "invalid":
    move_choice = choice_translate(input("That's not the name of any square. Try again: "))

tests=[]
def valid_move(start, end):
    global tests
    test_set=[]
    if end.state != "empty":
        return "Invalid"
    if start.location == end.location:
        return "Invalid"
    if start.x == end.x:
        for box in board:
            if box.y in range(start.y+1,end.y):
                test_set.append(box)
                tests.append([box.x, box.y])
    if start.y == end.y:
        for box in board:
            if box.x in range(start.x+1,end.x):
                test_set.append(box)
                tests.append([box.x, box.y])
    if abs(start.x - end.x) == abs(start.y - end.y):
        if (start.x < end.x) and (start.y < end.y):
            for i in range(1, abs(start.x - end.x)):
                for box in board:
                    if (box.x == start.y+i) and (box.y == start.y+i):
                        test_set.append(box)
                        tests.append([box.x, box.y])
        if (start.x > end.x) and (start.y > end.y):
            for i in range(1, abs(start.x - end.x)):
                for box in board:
                    if (box.x == start.y-i) and (box.y == start.y-i):
                        test_set.append(box)
                        tests.append([box.x, box.y])
        if (start.x > end.x) and (start.y < end.y):
            for i in range(1, abs(start.x - end.x)):
                for box in board:
                    if (box.x == start.x-i) and (box.y == start.y+i):
                        test_set.append(box)
                        tests.append([box.x, box.y])
        if (start.x < end.x) and (start.y > end.y):
            for i in range(1, abs(start.x - end.x)):
                for box in board:
                    if (box.x == start.x+i) and (box.y == end.y-i):
                        test_set.append(box)
                        tests.append([box.x, box.y])
    for test in test_set:
        if test.state != "empty":
            return "Invalid"
    return "Valid"

while valid_move(amazon_choice, move_choice) == "Invalid":
    move_choice = choice_translate(input("That amazon can't move there. Try again: "))

if valid_move(amazon_choice, move_choice) == "Valid":
    move_choice.state = amazon_choice.state
    amazon_choice.state = "empty"

print(tests)
gui()