Matchmaker.py

import sys, imp
import string, random, time

COLORS = ['B','W']
TURN_TIME_LIMIT = 15        # seconds
CONSECUTIVE_PASS_LIMIT = 2
PAUSE_BETWEEN_MOVES = False
class Matchmaker:

    def __init__(self):
        self.board = [[' ']*8 for i in range(8)]
        self.size = 8
        self.board[4][4] = 'W'
        self.board[3][4] = 'B'
        self.board[3][3] = 'W'
        self.board[4][3] = 'B'
        # a list of unit vectors (row, col)
        self.directions = [ (-1,-1), (-1,0), (-1,1), (0,-1),(0,1),(1,-1),(1,0),(1,1)]
        
#prints the board
    def PrintBoard(self):

        # Print column numbers
        print("  ",end="")
        for i in range(self.size):
            print(i+1,end=" ")
        print()

        # Build horizontal separator
        linestr = " " + ("+-" * self.size) + "+"

        # Print board
        for i in range(self.size):
            print(linestr)                       # Separator
            print(i+1,end="|")                   # Row number
            for j in range(self.size):
                print(self.board[i][j],end="|")  # board[i][j] and pipe separator 
            print()                              # End line
        print(linestr)
        
#determines the score of the board by adding +1 for every tile owned by player, and -1 for every tile owned by opp
    def score(self, player, opp):
        score = 0
        for i in range(self.size):
            for j in range(self.size):
                if(self.get_square(i,j)==player):
                    score +=1
                elif(self.get_square(i,j)==opp):
                    score -= 1
        return score

#returns true if the square was played, false if the move is not allowed
    def place_piece(self, row, col, player, opp):
        if(self.get_square(row,col)!=" "):
            return False
        
        if(player == opp):
            print("player and opponent cannot be the same")
            return False
        
        legal = False
        #for each direction, check to see if the move is legal by seeing if the adjacent square
        #in that direction is occuipied by the opponent. If it isnt check the next direction.
        #if it is, check to see if one of the players pieces is on the board beyond the oppponents piece,
        #if the chain of opponents pieces is flanked on both ends by the players pieces, flip
        #the opponents pieces 
        for Dir in self.directions:
            #look across the length of the board to see if the neighboring squares are empty,
            #held by the player, or held by the opponent
            for i in range(self.size):
                if  ((( row + i*Dir[0])<self.size)  and (( row + i*Dir[0])>=0 ) and (( col + i*Dir[1])>=0 ) and (( col + i*Dir[1])<self.size )):
                    #does the adjacent square in direction dir belong to the opponent?
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])!= opp and i==1 : # no
                        #no pieces will be flipped in this direction, so skip it
                        break
                    #yes the adjacent piece belonged to the opponent, now lets see if there are a chain
                    #of opponent pieces
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==player and i!=0 and i!=1 :
                        #set a flag so we know that the move was legal
                        legal = True
                        self.flip_tiles(row, col, Dir, i, player)
                        break

        return legal


#sets all tiles along a given direction (Dir) from a given starting point (col and row) for a given distance
# (dist) to be a given value ( player )
    def flip_tiles(self, row, col, Dir, dist, player):
        for i in range(dist):
            self.board[row+ i*Dir[0]][col + i*Dir[1]] = player
        return True
    
#returns the value of a square on the board
    def get_square(self, row, col):
        return self.board[row][col]

#checks all board positions to see if there is a legal move
    def has_move(self, player, opp):
        for i in range(self.size):
            for j in range(self.size):
                if self.islegal(i,j,player,opp):
                    return True
        return False

#checks every direction fromt the position which is input via "col" and "row", to see if there is an opponent piece
#in one of the directions. If the input position is adjacent to an opponents piece, this function looks to see if there is a
#a chain of opponent pieces in that direction, which ends with one of the players pieces.    
    def islegal(self, row, col, player, opp):
        if(self.get_square(row,col)!=" "):
            return False
        for Dir in self.directions:
            for i in range(self.size):
                if  ((( row + i*Dir[0])<self.size)  and (( row + i*Dir[0])>=0 ) and (( col + i*Dir[1])>=0 ) and (( col + i*Dir[1])<self.size )):
                    #does the adjacent square in direction dir belong to the opponent?
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])!= opp and i==1 : # no
                        #no pieces will be flipped in this direction, so skip it
                        break
                    #yes the adjacent piece belonged to the opponent, now lets see if there are a chain
                    #of opponent pieces
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==" " and i!=0 :
                        break

                    #with one of player's pieces at the other end
                    if self.get_square(row+ i*Dir[0], col + i*Dir[1])==player and i!=0 and i!=1 :
                        #set a flag so we know that the move was legal
                        return True
        return False

#returns true if no square in the board contains "_", false otherwise
    def full_board(self):
        for i in range(self.size):
            for j in range(self.size):
                if(self.board[i][j]==' '):
                    return False

        return True
    
#Checks to see if the given player controls the entire board
    def all_pieces(self, player):
        for i in range(self.size):
            for j in range(self.size):
                if(self.get_square(i,j) != player and self.get_square(i,j) != ' '):
                    return False
        return True
                   
def main():
    # Make sure user at least attempted to specify 2 python files
    if len(sys.argv) != 3:
        print("Error: %s requires two input files." % sys.argv[0])
        print("Correct usage: python %s File1.py File2.py" % sys.argv[0])
        exit(1)

    # Instantiate matchmaker, create default board
    mm = Matchmaker()

    # Store team names from command line arguments
    teamNames = []
    teamNames.append(sys.argv[1][:-3])
    teamNames.append(sys.argv[2][:-3])

    #mm = Matchmaker()
    #teamNames = []
    #teamNames.append("TeamA")
    #teamNames.append("TeamB")
        
    # Import files from teams as modules
    # Team modules will be referred to as as Player0 and Player1
    Team0 = imp.load_source(teamNames[0], sys.argv[1])
    Team1 = imp.load_source(teamNames[1], sys.argv[2])
    
    # Instantiate Boards for each of the two teams
    # Specifically: Search object Team0 for a class with the same name
    #   as the filename, instantiate the class, and store it in players
    players = []
    players.append(getattr(Team0,teamNames[0])())
    players.append(getattr(Team1,teamNames[1])())
    
    # Randomly choose first player and begin game
    curPlayerID = random.randint(0,1)
    print("Beginning match between %s and %s." % (teamNames[0], teamNames[1]))
    mm.PrintBoard()
    print()
    
    prevMove = (-1,-1)
    consecutivePasses = 0
   
    while True:
        # Pauses game between moves
        if (PAUSE_BETWEEN_MOVES):    
            input("Paused before player %s. Hit enter." % COLORS[curPlayerID])
                
        # Clarify player colors
        playerColor = COLORS[curPlayerID]
        oppColor = COLORS[1-curPlayerID]
        
        # If neither player has a valid move, end game and score
        if (not mm.has_move(playerColor, oppColor)) and (not mm.has_move(oppColor, playerColor)):
            print("Neither player has an available move.")
            break
        
        # Get player's move and calculate time taken to respond
        startTime = time.time()
        move = players[curPlayerID].play_square(prevMove[0], prevMove[1], playerColor, oppColor)
        stopTime = time.time()
        
        # End game if players are stuck in a loop of playing (-1,-1)
        if move == (-1,-1):
            consecutivePasses += 1
            print("%s (%s) has passed." % (teamNames[curPlayerID], playerColor))
            print()
            mm.PrintBoard()
            print()
            
            if consecutivePasses == CONSECUTIVE_PASS_LIMIT:
                print("Available moves, but both players have passed. Game over.")
                break
            else:
                # Change player
                curPlayerID = 1 - curPlayerID
                continue

        # If player exceeded time limit, player loses
        runTime = stopTime - startTime
        if (runTime > TURN_TIME_LIMIT):
            print("%s took %.1fs to play, which exceeded the time limit (%.1fs)." %
                  (teamNames[curPlayerID], runTime, TURN_TIME_LIMIT))
            print("%s (%s) is the winner." % (teamNames[1-curPlayerID], oppColor))
            return
        # If player has returned an illegal move, player loses
        elif (not mm.islegal(move[0], move[1], playerColor, oppColor)):
            print("%s has entered an illegal move." % teamNames[curPlayerID])
            print("%s (%s) is the winner." % (teamNames[1-curPlayerID], oppColor))
            return
        
        # Valid move acquired
        print("%s (%s) places a piece at (%d,%d) in %.1fs" %
              (teamNames[curPlayerID],playerColor, move[0]+1, move[1]+1,runTime))
        print()
              
        mm.place_piece(move[0], move[1], playerColor, oppColor)
        prevMove = move
        consecutivePasses = 0
        
        mm.PrintBoard()
        print()
        
        # Check whether game has ended        
        if mm.all_pieces(playerColor) or mm.full_board():
            break                    

        # Change player
        curPlayerID = 1 - curPlayerID

    finalScore = mm.score(COLORS[0], COLORS[1])
    if (finalScore == 0):
        print("The game is a draw.")
    elif(finalScore > 0):
        
        print("%s (%s) wins by %d pieces." % (teamNames[0],COLORS[0],finalScore))
    else:
        print("%s (%s) wins by %d pieces." % (teamNames[1],COLORS[1],-finalScore))
main()