starting a repo

Author: kiarashplusplus

lab3/basicplayer.py

@@ -0,0 +1,95 @@
+from util import memoize, run_search_function
+
+def basic_evaluate(board):
+    """
+    The original focused-evaluate function from the lab.
+    The original is kept because the lab expects the code in the lab to be modified. 
+    """
+    if board.is_game_over():
+        # If the game has been won, we know that it must have been
+        # won or ended by the previous move.
+        # The previous move was made by our opponent.
+        # Therefore, we can't have won, so return -1000.
+        # (note that this causes a tie to be treated like a loss)
+        score = -1000
+    else:
+        score = board.longest_chain(board.get_current_player_id()) * 10
+        # Prefer having your pieces in the center of the board.
+        for row in range(6):
+            for col in range(7):
+                if board.get_cell(row, col) == board.get_current_player_id():
+                    score -= abs(3-col)
+                elif board.get_cell(row, col) == board.get_other_player_id():
+                    score += abs(3-col)
+
+    return score
+
+
+def get_all_next_moves(board):
+    """ Return a generator of all moves that the current player could take from this position """
+    from connectfour import InvalidMoveException
+
+    for i in xrange(board.board_width):
+        try:
+            yield (i, board.do_move(i))
+        except InvalidMoveException:
+            pass
+
+def is_terminal(depth, board):
+    """
+    Generic terminal state check, true when maximum depth is reached or
+    the game has ended.
+    """
+    return depth <= 0 or board.is_game_over()
+    
+def minimax_find_board_value(board, depth, eval_fn,
+                             get_next_moves_fn=get_all_next_moves,
+                             is_terminal_fn=is_terminal):
+    """
+    Minimax helper function: Return the minimax value of a particular board,
+    given a particular depth to estimate to
+    """
+    if is_terminal_fn(depth, board):
+        return eval_fn(board)
+
+    best_val = None
+    
+    for move, new_board in get_next_moves_fn(board):
+        val = -1 * minimax_find_board_value(new_board, depth-1, eval_fn,
+                                            get_next_moves_fn, is_terminal_fn)
+        if best_val == None or val > best_val:
+            best_val = val
+
+    return best_val
+
+def minimax(board, depth, eval_fn = basic_evaluate,
+            get_next_moves_fn = get_all_next_moves,
+            is_terminal_fn = is_terminal,
+            verbose = True):
+    """
+    Do a minimax search to the specified depth on the specified board.
+
+    board -- the ConnectFourBoard instance to evaluate
+    depth -- the depth of the search tree (measured in maximum distance from a leaf to the root)
+    eval_fn -- (optional) the evaluation function to use to give a value to a leaf of the tree; see "focused_evaluate" in the lab for an example
+
+    Returns an integer, the column number of the column that the search determines you should add a token to
+    """
+    
+    best_val = None
+    
+    for move, new_board in get_next_moves_fn(board):
+        val = -1 * minimax_find_board_value(new_board, depth-1, eval_fn,
+                                            get_next_moves_fn,
+                                            is_terminal_fn)
+        if best_val == None or val > best_val[0]:
+            best_val = (val, move, new_board)
+            
+    if verbose:
+        print "MINIMAX: Decided on column %d with rating %d" % (best_val[1], best_val[0])
+
+    return best_val[1]
+
+
+basic_player = lambda board: minimax(board, depth=4, eval_fn=basic_evaluate)
+progressive_deepening_player = lambda board: run_search_function(board, search_fn=minimax, eval_fn=basic_evaluate)