Lith_30

# no more pascal triangle
# wanna play knots and crosses instead :!
# hard mode
#    1 | 2 | 3
#   ---|---|---
#    4 | 5 | 6
#   ---|---|---
#    7 | 8 | 9
#    (0,0) | (1,0) | (2,0)
#   -------|-------|-------
#    (0,1) | (1,1) | (2,1)
#   -------|-------|-------
#    (0,2) | (1,2) | (2,2)
import random
def Start():
    print("this is the key")
    print("1 | 2 | 3\n--|---|--\n4 | 5 | 6\n--|---|--\n7 | 8 | 9\n\n")
    valid_input = False
    while not valid_input:
        key = input("Type \'x\' or \'o\': ")
        if key == "x" or key == "X":
            player_key = "X"
            computer_key = "O"
            valid_input = True
        elif key == "o" or key == "O":
            player_key = "O"
            computer_key = "X"
            valid_input = True
    print("you are now playing as \'" + key + "\'")
    final_status = Main_Game(player_key, computer_key)
    if final_status == "player":
        print("You won, good job")
    elif final_status == "computer":
        print("The computer won, better luck next time")
    elif final_status == "tie":
        print("You both tied, not good enough")
    else:
        print("Ran out of turns, bad luck")
def Main_Game(player_key, computer_key) -> str:
    positions = {1: " ", 2: " ", 3: " ", 4: " ", 5: " ", 6: " ", 7: " ", 8: " ", 9: " "}
    game_status = ""
    turns = 0
    while turns < 9:
        positions = Computer_Turn(positions, player_key, computer_key)
        turns += 1
        print("\n")
        Display_Board(positions)
        print("\n")
        game_status = Check_For_Winner(positions, player_key, computer_key)
        if game_status != "":
            return game_status
        if turns < 8:
            position_valid = False
            while not position_valid:
                position = int(input("Enter the position: "))
                position_valid = Check_Valid_Position(positions, position)
            positions[position] = player_key
            turns += 1
            print("\n")
            Display_Board(positions)
            print("\n")
            game_status = Check_For_Winner(positions, player_key, computer_key)
            if game_status != "":
                return game_status
    return ""
def Check_For_Winner(positions, player_key, computer_key) -> str:
    player_win = False
    computer_win = False
    vector_set = [[0, -1], [1, 0], [0, 1], [-1, 0], [1, -1], [1, 1], [-1, 1], [-1, -1]]
    player_positions = Take_Postions(positions, player_key)
    computer_positions = Take_Postions(positions, computer_key)
    player_vectors = Integer_To_Vector(player_positions)
    computer_vectors = Integer_To_Vector(computer_positions)
    for player_vector in player_vectors:
        for vector in vector_set:
            new_pos = Add_Vector(player_vector, vector)
            if new_pos in player_vectors:
                second_pos = Add_Vector(new_pos, vector)
                if second_pos in player_vectors:
                    player_win = True
    for computer_vector in computer_vectors:
        for vector in vector_set:
            new_pos = Add_Vector(computer_vector, vector)
            if new_pos in computer_vectors:
                second_pos = Add_Vector(new_pos, vector)
                if second_pos in computer_vectors:
                    computer_win = True
    if player_win and not computer_win:
        return "player"
    elif not player_win and computer_win:
        return "computer"
    elif player_win and computer_win:
        return "tie"
    return ""
def Computer_Turn(positions, player_key, computer_key) -> dict:
    print("Computer turn...\n")
    player_positons = Take_Postions(positions, player_key)
    if len(player_positons) < 1:
        i = 0
        while not Check_Valid_Position(positions, i):
            i = random.randint(1, 9)
        if Check_Valid_Position(positions, i):
            positions[i] = computer_key
    else:
        computer_positions = Take_Postions(positions, computer_key)
        computer_data = Take_Weightings(Integer_To_Vector(computer_positions), computer_key, positions)
        computer_weightings = computer_data[0]
        computer_win = computer_data[1]
        if computer_win:
            surrounding_vectors = computer_weightings
        else:
            vector_positions = Integer_To_Vector(player_positons)
            weighting_data = Take_Weightings(vector_positions, player_key, positions)
            surrounding_vectors = weighting_data[0]
        position_keys = list(surrounding_vectors.keys())
        if len(position_keys) > 0:
            highest_key = position_keys[0]
            for key in position_keys:
                if surrounding_vectors[key] > surrounding_vectors[highest_key]:
                    highest_key = key
            positions[highest_key] = computer_key
    return positions
def Take_Weightings(vector_positions, key, positions) -> list:
    vector_set = [[0, -1], [1, 0], [0, 1], [-1, 0], [1, -1], [1, 1], [-1, 1], [-1, -1]]
    defence = False
    surrounding_vectors = {}
    for vector in vector_positions:
        for set in vector_set:
            weighting = 1
            surround_vector = Add_Vector(vector, set)
            if 0 <= surround_vector[0] <= 2 and 0 <= surround_vector[1] <= 2:
                index = Vector_To_Integer([surround_vector])[0]
                if Check_Valid_Position(positions, index):
                    secondary_vector = Add_Vector(set, surround_vector)
                    if 0 <= secondary_vector[0] <= 2 and 0 <= secondary_vector[1] <= 2:
                        pos_index = Vector_To_Integer([secondary_vector])[0]
                        if not Check_Valid_Position(positions, pos_index):
                            if positions[pos_index] == key:
                                defence = True
                    surrounding_vectors = Add_To_Weighting_List(surrounding_vectors, index, weighting)
                elif positions[index] == key:
                    side_vector_one = Add_Vector(vector, [-set[0], -set[1]])
                    side_vector_two = Add_Vector(surround_vector, set)
                    if 0 <= side_vector_one[0] <= 2 and 0 <= side_vector_one[1] <= 2:
                        index1 = Vector_To_Integer([side_vector_one])[0]
                        if Check_Valid_Position(positions, index1):
                            surrounding_vectors = Add_To_Weighting_List(surrounding_vectors, index1, weighting + 1)
                            defence = True
                    if 0 <= side_vector_two[0] <= 2 and 0 <= side_vector_two[1] <= 2:
                        index2 = Vector_To_Integer([side_vector_two])[0]
                        if Check_Valid_Position(positions, index2):
                            surrounding_vectors = Add_To_Weighting_List(surrounding_vectors, index2, weighting + 1)
                            defence = True
    return [surrounding_vectors, defence]
def Take_Postions(positions, key) -> list:
    entity_positions = []
    for position in positions:
        if positions[position] == key:
            entity_positions.append(position)
    return entity_positions
def Add_To_Weighting_List(surrounding_vectors, index, weighting) -> dict:
    present = False
    for vectors in surrounding_vectors:
        if vectors == index:
            surrounding_vectors[index] += weighting
            present = True
    if not present:
        surrounding_vectors[index] = weighting
    return surrounding_vectors
def Add_Vector(Vector1, Vector2) -> list:
    return [Vector1[0] + Vector2[0], Vector1[1] + Vector2[1]]
def Integer_To_Vector(positions) -> list:
    vectors = {1: [0, 0], 2: [1, 0], 3: [2, 0], 4: [0, 1], 5: [1, 1], 6: [2, 1], 7: [0, 2], 8: [1, 2], 9: [2, 2]}
    final_vectors = []
    for place in positions:
        final_vectors.append(vectors[place])
    return final_vectors
def Vector_To_Integer(vectors) -> list:
    integers = {1: [0, 0], 2: [1, 0], 3: [2, 0], 4: [0, 1], 5: [1, 1], 6: [2, 1], 7: [0, 2], 8: [1, 2], 9: [2, 2]}
    keys = integers.keys()
    final_values = []
    for vector in vectors:
        for place in keys:
            if vector == integers[place]:
                final_values.append(place)
    return final_values
def Display_Board(positions):
    index = 1
    while index <= 6:
        print(positions[index] + " | " + positions[index + 1] + " | " + positions[index + 2])
        print("--|---|--")
        index += 3
    print(positions[7] + " | " + positions[8] + " | " + positions[9])
def Check_Valid_Position(positions, position) -> bool:
    for locations in positions:
        if locations == position:
            if positions[locations] == " ":
                return True
            else:
                return False
    return False
Start()