evaluator_code.py

'''
The structure of the code is as below:
1. Header Files
2. Sample implementations of your class (Player and ManualPlayer)
3. Game Logic
4. Game simulator
'''

import os
import random
import signal
import sys
import team1  ##my bot
import threading
import time

from os import name as nm
from other_bots import team36
from other_bots import team45
from other_bots import team5
from other_bots import team53
from other_bots import team76  ##better bot
from other_bots import team80  ##better bot
from other_bots import team81


class ManualPlayer:
    def __init__(self):
        pass

    def move(self, temp_board, temp_block, old_move, flag):
        print('Enter your move: <format:row column> (you\'re playing with', flag + ")")
        mvp = input()
        mvp = mvp.split()
        return (int(mvp[0]), int(mvp[1]))


class Player1:
    def __init__(self):
        # You may initialize your object here and use any variables for storing throughout the game
        pass

    def move(self, temp_board, temp_block, old_move, flag):
        # List of permitted blocks, based on old move.
        blocks_allowed = determine_blocks_allowed(old_move, temp_block)
        # Get list of empty valid cells
        cells = get_empty_out_of(temp_board, blocks_allowed, temp_block)
        # Choose a move based on some algorithm, here it is a random move.
        return cells[random.randrange(len(cells))]


class Player2:
    def __init__(self):
        # You may initialize your object here and use any variables for storing throughout the game
        pass

    def move(self, temp_board, temp_block, old_move, flag):
        # List of permitted blocks, based on old move.
        blocks_allowed = determine_blocks_allowed(old_move, temp_block)
        # Get list of empty valid cells
        cells = get_empty_out_of(temp_board, blocks_allowed, temp_block)
        # Choose a move based on some algorithm, here it is a random move.
        return cells[random.randrange(len(cells))]


def determine_blocks_allowed(old_move, block_stat):
    blocks_allowed = []
    if old_move[0] % 3 == 0 and old_move[1] % 3 == 0:
        blocks_allowed = [1, 3]
    elif old_move[0] % 3 == 0 and old_move[1] % 3 == 2:
        blocks_allowed = [1, 5]
    elif old_move[0] % 3 == 2 and old_move[1] % 3 == 0:
        blocks_allowed = [3, 7]
    elif old_move[0] % 3 == 2 and old_move[1] % 3 == 2:
        blocks_allowed = [5, 7]
    elif old_move[0] % 3 == 0 and old_move[1] % 3 == 1:
        blocks_allowed = [0, 2]
    elif old_move[0] % 3 == 1 and old_move[1] % 3 == 0:
        blocks_allowed = [0, 6]
    elif old_move[0] % 3 == 2 and old_move[1] % 3 == 1:
        blocks_allowed = [6, 8]
    elif old_move[0] % 3 == 1 and old_move[1] % 3 == 2:
        blocks_allowed = [2, 8]
    elif old_move[0] % 3 == 1 and old_move[1] % 3 == 1:
        blocks_allowed = [4]
    else:
        sys.exit(1)
    final_blocks_allowed = []
    for i in blocks_allowed:
        if block_stat[i] == '-':
            final_blocks_allowed.append(i)
    return final_blocks_allowed


# Initializes the game
def get_init_board_and_blockstatus():
    board = []
    for i in range(9):
        row = ['-'] * 9
        board.append(row)

    block_stat = ['-'] * 9
    return board, block_stat


# Checks if player has messed with the board. Don't mess with the board that is passed to your move function.
def verification_fails_board(board_game, temp_board_state):
    return board_game == temp_board_state


# Checks if player has messed with the block. Don't mess with the block array that is passed to your move function.
def verification_fails_block(block_stat, temp_block_stat):
    return block_stat == temp_block_stat


# Gets empty cells from the list of possible blocks. Hence gets valid moves.
def get_empty_out_of(gameb, blal, block_stat):
    cells = []  # it will be list of tuples
    # Iterate over possible blocks and get empty cells
    for idb in blal:
        id1 = idb // 3
        id2 = idb % 3
        for i in range(id1 * 3, id1 * 3 + 3):
            for j in range(id2 * 3, id2 * 3 + 3):
                if gameb[i][j] == '-':
                    cells.append((i, j))

    # If all the possible blocks are full, you can move anywhere
    if cells == []:
        new_blal = []
        all_blal = [0, 1, 2, 3, 4, 5, 6, 7, 8]
        for i in all_blal:
            if block_stat[i] == '-':
                new_blal.append(i)

        for idb in new_blal:
            id1 = idb // 3
            id2 = idb % 3
            for i in range(id1 * 3, id1 * 3 + 3):
                for j in range(id2 * 3, id2 * 3 + 3):
                    if gameb[i][j] == '-':
                        cells.append((i, j))
    return cells


# Returns True if move is valid
def check_valid_move(game_board, block_stat, current_move, old_move):

    # first we need to check whether current_move is tuple of not
    # old_move is guaranteed to be correct
    if type(current_move) is not tuple:
        return False

    if len(current_move) != 2:
        return False

    a = current_move[0]
    b = current_move[1]

    if type(a) is not int or type(b) is not int:
        return False
    if a < 0 or a > 8 or b < 0 or b > 8:
        return False

    # Special case at start of game, any move is okay!
    if old_move[0] == -1 and old_move[1] == -1:
        return True

    # List of permitted blocks, based on old move.
    blocks_allowed = determine_blocks_allowed(old_move, block_stat)
    # We get all the empty cells in allowed blocks. If they're all full, we get all the empty cells in the entire board.
    cells = get_empty_out_of(game_board, blocks_allowed, block_stat)
    # Checks if you made a valid move.
    if current_move in cells:
        return True
    else:
        return False


def update_lists(game_board, block_stat, move_ret, fl):
    game_board[move_ret[0]][move_ret[1]] = fl
    block_no = (move_ret[0] // 3) * 3 + move_ret[1] // 3
    id1 = block_no // 3
    id2 = block_no % 3
    mflg = 0
    flag = 0
    for i in range(id1 * 3, id1 * 3 + 3):
        for j in range(id2 * 3, id2 * 3 + 3):
            if game_board[i][j] == '-':
                flag = 1

    if block_stat[block_no] == '-':
        if (
            game_board[id1 * 3][id2 * 3] == game_board[id1 * 3 + 1][id2 * 3 + 1]
            and game_board[id1 * 3 + 1][id2 * 3 + 1]
            == game_board[id1 * 3 + 2][id2 * 3 + 2]
            and game_board[id1 * 3 + 1][id2 * 3 + 1] != '-'
            and game_board[id1 * 3 + 1][id2 * 3 + 1] != 'D'
        ):
            mflg = 1
        if (
            game_board[id1 * 3 + 2][id2 * 3] == game_board[id1 * 3 + 1][id2 * 3 + 1]
            and game_board[id1 * 3 + 1][id2 * 3 + 1] == game_board[id1 * 3][id2 * 3 + 2]
            and game_board[id1 * 3 + 1][id2 * 3 + 1] != '-'
            and game_board[id1 * 3 + 1][id2 * 3 + 1] != 'D'
        ):
            mflg = 1
        if mflg != 1:
            for i in range(id2 * 3, id2 * 3 + 3):
                if (
                    game_board[id1 * 3][i] == game_board[id1 * 3 + 1][i]
                    and game_board[id1 * 3 + 1][i] == game_board[id1 * 3 + 2][i]
                    and game_board[id1 * 3][i] != '-'
                    and game_board[id1 * 3][i] != 'D'
                ):
                    mflg = 1
                    break
        if mflg != 1:
            for i in range(id1 * 3, id1 * 3 + 3):
                if (
                    game_board[i][id2 * 3] == game_board[i][id2 * 3 + 1]
                    and game_board[i][id2 * 3 + 1] == game_board[i][id2 * 3 + 2]
                    and game_board[i][id2 * 3] != '-'
                    and game_board[i][id2 * 3] != 'D'
                ):
                    mflg = 1
                    break
    if flag == 0:
        block_stat[block_no] = 'D'
    if mflg == 1:
        block_stat[block_no] = fl

    return mflg


# Check win
def terminal_state_reached(game_board, block_stat, point1, point2):
    ### we are now concerned only with block_stat
    bs = block_stat
    ## Row win
    if (
        (bs[0] == bs[1] and bs[1] == bs[2] and bs[1] != '-' and bs[1] != 'D')
        or (bs[3] != '-' and bs[3] != 'D' and bs[3] == bs[4] and bs[4] == bs[5])
        or (bs[6] != 'D' and bs[6] != '-' and bs[6] == bs[7] and bs[7] == bs[8])
    ):
        return True, 'W'
    ## Col win
    elif (
        (bs[0] == bs[3] and bs[3] == bs[6] and bs[0] != '-' and bs[0] != 'D')
        or (bs[1] == bs[4] and bs[4] == bs[7] and bs[4] != '-' and bs[4] != 'D')
        or (bs[2] == bs[5] and bs[5] == bs[8] and bs[5] != '-' and bs[5] != 'D')
    ):
        return True, 'W'
    ## Diag win
    elif (bs[0] == bs[4] and bs[4] == bs[8] and bs[0] != '-' and bs[0] != 'D') or (
        bs[2] == bs[4] and bs[4] == bs[6] and bs[2] != '-' and bs[2] != 'D'
    ):
        return True, 'W'
    else:
        smfl = 0
        for i in range(9):
            if block_stat[i] == '-':
                smfl = 1
                break
        if smfl == 1:
            return False, 'Continue'

        else:
            if point1 > point2:
                return True, 'P1'
            elif point2 > point1:
                return True, 'P2'
            else:
                return True, 'D'


def decide_winner_and_get_message(player, status, message):
    if status == 'P1':
        return ('P1', 'MORE BLOCKS')
    elif status == 'P2':
        return ('P2', 'MORE BLOCKS')
    elif player == 'P1' and status == 'L':
        return ('P2', message)
    elif player == 'P1' and status == 'W':
        return ('P1', message)
    elif player == 'P2' and status == 'L':
        return ('P1', message)
    elif player == 'P2' and status == 'W':
        return ('P2', message)
    else:
        return ('NONE', 'DRAW')
    return


def print_lists(gb, bs):
    print('=========== Game Board ===========')
    for i in range(9):
        if i > 0 and i % 3 == 0:
            print()
        for j in range(9):
            if j > 0 and j % 3 == 0:
                print(" ", gb[i][j], end=" ")
            else:
                print(gb[i][j], end=" ")

        print()
    print("==================================")

    print("=========== Block Status =========")
    for i in range(0, 9, 3):
        print(bs[i] + " " + bs[i + 1] + " " + bs[i + 2])
    print("==================================")
    print()


def simulate(obj1, obj2):

    # Game board is a 9x9 list of lists & block_stat is a list of 9 elements indicating if a block has been won.
    game_board, block_stat = get_init_board_and_blockstatus()

    pl1 = obj1
    pl2 = obj2

    # Player with flag 'x' will start the game
    pl1_fl = 'x'
    pl2_fl = 'o'

    old_move = (-1, -1)  # For the first move

    WINNER = ''
    MESSAGE = ''
    TIMEALLOWED = 30
    p1_pts = 0
    p2_pts = 0

    print_lists(game_board, block_stat)

    while 1:  # Main game loop
        temp_board_state = game_board[:]
        temp_block_stat = block_stat[:]
        t1 = time.time()
        ret_move_pl1 = pl1.move(temp_board_state, temp_block_stat, old_move, pl1_fl)
        t2 = time.time()
        if t2 - t1 > TIMEALLOWED:
            WINNER, MESSAGE = decide_winner_and_get_message('P1', 'L', 'TIMED OUT')
            break

        # Check if list is tampered.
        if not (
            verification_fails_board(game_board, temp_board_state)
            and verification_fails_block(block_stat, temp_block_stat)
        ):
            WINNER, MESSAGE = decide_winner_and_get_message(
                'P1', 'L', 'MODIFIED CONTENTS OF LISTS'
            )
            break

        # Check if the returned move is valid
        if not check_valid_move(game_board, block_stat, ret_move_pl1, old_move):
            WINNER, MESSAGE = decide_winner_and_get_message(
                'P1', 'L', 'MADE AN INVALID MOVE'
            )
            break

        print("Player 1 made the move:", ret_move_pl1, 'with', pl1_fl)
        # Update the 'game_board' and 'block_stat' move
        p1_pts += update_lists(game_board, block_stat, ret_move_pl1, pl1_fl)

        gamestatus, mesg = terminal_state_reached(
            game_board, block_stat, p1_pts, p2_pts
        )
        if gamestatus == True:
            print_lists(game_board, block_stat)
            WINNER, MESSAGE = decide_winner_and_get_message('P1', mesg, 'COMPLETE')
            break

        old_move = ret_move_pl1
        print_lists(game_board, block_stat)

        temp_board_state = game_board[:]
        temp_block_stat = block_stat[:]
        t1 = time.time()
        ret_move_pl2 = pl2.move(temp_board_state, temp_block_stat, old_move, pl2_fl)
        t2 = time.time()
        if t2 - t1 > TIMEALLOWED:
            WINNER, MESSAGE = decide_winner_and_get_message('P2', 'L', 'TIMED OUT')
            break

        if not (
            verification_fails_board(game_board, temp_board_state)
            and verification_fails_block(block_stat, temp_block_stat)
        ):
            WINNER, MESSAGE = decide_winner_and_get_message(
                'P2', 'L', 'MODIFIED CONTENTS OF LISTS'
            )
            break

        if not check_valid_move(game_board, block_stat, ret_move_pl2, old_move):
            WINNER, MESSAGE = decide_winner_and_get_message(
                'P2', 'L', 'MADE AN INVALID MOVE'
            )
            break

        print("Player 2 made the move:", ret_move_pl2, 'with', pl2_fl)

        p2_pts += update_lists(game_board, block_stat, ret_move_pl2, pl2_fl)

        # Now check if the last move resulted in a terminal state
        gamestatus, mesg = terminal_state_reached(
            game_board, block_stat, p1_pts, p2_pts
        )
        if gamestatus == True:
            print_lists(game_board, block_stat)
            WINNER, MESSAGE = decide_winner_and_get_message('P2', mesg, 'COMPLETE')
            break
        else:
            old_move = ret_move_pl2
            print_lists(game_board, block_stat)

    print(WINNER)  ##one who wins
    print(string)  ##determine who is P1 ('X'),P2 ('O')
    print(
        MESSAGE
    )  ## Game message (TIMED OUT -> loosing player timeout, COMPLETE --> clear win, MORE BLOCKS --> when player win becoz he won more sub 3X3 grid, DRAW --> draw game)


if __name__ == '__main__':
    ## get game playing objects

    if len(sys.argv) != 2:
        print('Usage: python simulator.py <option>')
        print('<option> can be 1 => Human vs. Human')
        print('                2 => BOT vs. Human')
        print('                3 => BOT vs. BOT')
        sys.exit(1)

    obj1 = ''
    obj2 = ''
    option = sys.argv[1]
    if option == '1':
        obj1 = ManualPlayer()
        obj2 = ManualPlayer()

    elif option == '2':
        obj1 = team1.Player1()
        obj2 = ManualPlayer()
    elif option == '3':
        obj1 = team45.Player45()
        obj2 = team1.Player1()
    else:
        print('Invalid option')
        sys.exit(1)

    num = random.uniform(0, 1)
    if num > 0.5:
        string = "P1 is obj2"
        simulate(obj2, obj1)
    else:
        string = "P1 is obj1"
        simulate(obj1, obj2)