class StudentAI():
def __init__(self,row,col,p):
self.row = row
self.col = col
self.p = p
self.board = Board(row,col,p)
self.board.initialize_game()
self.color = ''
self.opponent = {1:2,2:1}
self.color = 2
def get_move(self, move):
if len(move) != 0:
self.board.make_move(move, self.opponent[self.color])
else:
self.color = 1
moves = self.board.get_all_possible_moves(self.color)
tree_depth = 4
# for beta alpha pruning
alpha = -math.inf
beta = math.inf
# best moves list
best_moves = []
# Get best moves
for row in moves:
def train_one_episode(self):
# This is training function for one episode, start a new board and
# update Q value until win or loss
# QUESTION IS HOW TO DECIDE OPPONENT MOVE? BY SELF-TRAIN? AND HOW TO SELF-TRAIN?
new_board = Board()
new_board.initialize_game()
turn = ''
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = 2
def __init__(self, col, row, k, g):
self.k = k
self.col = col
self.row = row
self.board = Board(col, row, k, g)
self.g = True if g == 1 else False
self.win = 10**k
def __init__(self, col, row, k, g):
"""Board class used to track the moves."""
Board.__init__(self, col, row, k, g)
self.available = set()
if not g:
for i in range(row):
for j in range(col):
self.available.add((i, j))
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
class StudentAI():
def __init__(self,col,row,p):
self.col = col
self.row = row
self.p = p
self.board = Board(col,row,p)
self.board.initialize_game()
self.color = ''
self.opponent = {1:2,2:1}
self.color = 2
self.count = 0
def get_move(self,move):
if len(move) != 0:
self.board.make_move(move,self.opponent[self.color])
else:
self.color = 1
moves = self.board.get_all_possible_moves(self.color)
# index = randint(0,len(moves)-1)
# inner_index = randint(0,len(moves[index])-1)
# move = moves[index][inner_index]
if len(moves) == 1 and len(moves[0]) == 1:
move = moves[0][0]
if self.count < 15:
mct = MonteCarloTree(self.board, self.color, self.opponent, (10, 0, -10))
move = mct.get_action(10, 0)
self.board.make_move(move, self.color)
else:
mct = MonteCarloTree(self.board, self.color, self.opponent, (10, 0, -10))
move = mct.get_action(10, 0)
self.board.make_move(move, self.color)
return move
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.search_lim = 5
self.current_node = TreeNode(None, self.color)
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = 2
self.mcts = MCTS(TreeNode(self.board, self.color, None, None))
self.total_time_remaining = 479
self.time_divisor = row * col * 0.5
self.timed_move_count = 2
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.movecount = 0
self.simulate_times = 100
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.bestMove = None
self.blackVal = 0 #-------
self.whiteVal = 0 #-------
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.number_of_move = 0
self.EARLY_GAME = 10
self.MID_GAME = 20
self.END_GAME = 30
self.run_time_depth = 5
self.opponent = {1: 2, 2: 1}
self.color = 2
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.halftime = time.time() + 240
self.endtime = time.time() + 360
self.finaltime = time.time() + 460
self.root = Node(0, 0)
def simulate_lr(self, color):
# simulate one time
# record all X features to feature_matrix
# update the y value accordingly
print("entering simulations")
newboard = Board(self.col, self.row, self.p)
newboard.initialize_game()
feature_list_b = []
feature_list_w = []
win = 0
### TODO: Fixing Current move in a new board
curr_turn = self.opponent[color]
for turn in range(50):
if newboard.is_win(color) == color:
win = 1
break
elif newboard.is_win(self.opponent[color]) == self.opponent[color]:
break
move = self.minimax_move(newboard.get_all_possible_moves(curr_turn))
newboard.make_move(move, curr_turn)
b, w = self.get_X(self.board)
feature_list_b.append(b)
feature_list_w.append(w)
self.feature_matrix = np.append(self.feature_matrix, np.array([b, w]), axis=0)
print(self.feature_matrix)
curr_turn = self.opponent[curr_turn]
else:
win = 0.5
# matrix = np.array([feature_list_b, feature_list_w])
# feature_matrix = np.hstack((matrix, np.zeros((matrix.shape[0], 1))))
# TODO: Fixing y value update
if win == 1 and color == 1:
for fb in feature_list_b:
index = np.where(fb in self.feature_matrix[:, 0:self.feature_size])
if index == []:
self.feature_matrix = np.append(self.feature_matrix, np.array([b, w]), axis=0)
self.feature_matrix[index, self.feature_size] += 1
elif win == 0 and color == 1:
for fw in feature_list_w:
index = np.where(fw in self.feature_matrix[:, 0:self.feature_size])
if index == []:
self.feature_matrix = np.append(self.feature_matrix, np.array([b, w]), axis=0)
self.feature_matrix[index, self.feature_size] += 1
return win
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.search_depth = 5
self.debug = True
self.time_used = 0
self.transposition_table = dict()
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.depth = 0
self.turn = 0
self.control = asyncio.get_event_loop()
self.iterative_depth_limit = self.INITIAL_DEPTH_LIMIT
self.time_left = TimeFlags.UNDER
self.time_used = 0
self.upper_depth_limit = float('inf')
def __init__(self, col, row, p):
"""
Intializes manualAI
@param row: no of rows in the board
@param col: no of columns in the board
@param k: no of rows to be filled with checker pieces at the start
@return :
@raise :
"""
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = 2
self.opponent = {1: 2, 2: 1} # to switch turns after each turn
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
##ADDED
self.calc_time = 1999
self.visited_tree = []
self.C = 1.6
self.colors = {1: "B", 2: "W"}
self.letters = {"B": 1, "W": 2}
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.movecount = 1
self.file = f"{self.col}-{self.row}-{self.color}-{randint(0, 500)}-test.txt"
self.start = time.time()
self.theta1, self.theta2 = self.get_theta()
self.cutoff = self.get_cutoff()
class StudentAI():
def __init__(self,col,row,p):
self.col = col
self.row = row
self.p = p
self.board = Board(col,row,p)
self.board.initialize_game()
self.color = ''
self.opponent = {1:2,2:1}
self.color = 2
def get_move(self, move):
#print(self.color)
if len(move) != 0:
self.board.make_move(move,self.opponent[self.color])
else:
self.color = 1
moves = self.board.get_all_possible_moves(self.color)
#self.train()
self.simulate_lr(self.color)
#index = randint(0,len(moves)-1)
#inner_index = randint(0,len(moves[index])-1)
#move = moves[index][inner_index]
ql = QLearning()
move = ql.make_action(self.board, moves)
self.board.make_move(move, self.color)
self.movecount += 1
return move
class StudentAI():
col = 0
row = 0
k = 0
g = 0
def __init__(self,col,row,k,g):
self.g = g
self.col = col
self.row = row
self.k = k
self.board = Board(col,row,k,g)
def get_move(self,move):
self.board.make_move(move,1)
if self.g == 0:
return Move(randint(0,self.col-1),randint(0,self.row-1))
else:
return Move(randint(0,self.col-1),0)
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.depth = 0
self.turn = 0
self.control = asyncio.get_event_loop()
self.iterative_depth_limit = self.INITIAL_DEPTH_LIMIT
self.time_left = TimeFlags.UNDER
self.time_used = 0
self.upper_depth_limit = float('inf')
self.time_limit = 480 # 8 minutes
self.late_game_flag = False
self.heuristic_flag = 1 #use ieee1, if 2, use ieee2
self.flag_just_changed = 0
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
#---------------------------------#
self.area = self.row * self.col
self.count = 0
if self.area <= 39:
self.depth = 8
elif self.area <= 49:
self.depth = 5
elif self.area <= 79:
self.depth = 4
else:
self.depth = 4
class ManualAI():
"""
This class describes the ManualAI.
"""
def __init__(self, col, row, p):
"""
Intializes manualAI
@param row: no of rows in the board
@param col: no of columns in the board
@param k: no of rows to be filled with checker pieces at the start
@return :
@raise :
"""
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = 2
self.opponent = {1: 2, 2: 1} # to switch turns after each turn
def get_move(self, move):
"""
get_move function for manualAI called from the gameloop in the main module.
@param move: A Move object describing the move.
@return res_move: A Move object describing the move manualAI wants to make. This move is basically console input.
@raise :
"""
if move.seq:
# if move.seq is not an empty list
self.board.make_move(move, self.opponent[self.color])
else:
self.color = 1
moves = self.board.get_all_possible_moves(self.color)
#print(moves)
while True:
try:
for i, checker_moves in enumerate(moves):
print(i, ':[', end="")
for j, move in enumerate(checker_moves):
print(j, ":", move, end=", ")
print("]")
index, inner_index = map(
lambda x: int(x),
input("Select Move {int} {int}: ").split(
)) # input is from console is handled here.
res_move = moves[index][inner_index]
except KeyboardInterrupt:
raise KeyboardInterrupt
except:
print('invalid move')
continue
else:
break
self.board.make_move(res_move, self.color)
return res_move
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.startnode = Node()
self.startnode.board = Board(col, row, p)
self.startnode.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.maxiter = 100
self.curriter = 0
def __init__(self,col,row,p):
self.col = col
self.row = row
self.p = p
self.board = Board(col,row,p)
self.board.initialize_game()
self.color = ''
self.opponent = {1:2,2:1}
self.color = 2
# new params
'''
new data clearification:
feature_matrix = [[X1, X2, ..., X_feature_size, Y],
...
[X1m, X2m, ..., X_feature_size_m, Y]]
'''
self.movecount = 0
self.feature_size = 5
self.thetas = np.random.rand(self.feature_size)
self.feature_matrix = np.empty((0, self.feature_size))
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
# ---------- What we added -----------
self.calc_time = datetime.timedelta(seconds=3)
self.max_moves = 35
self.wins = {}
self.plays = {}
self.max_depth = 0
self.C = 1.4
self.colors = {1: "B", 2: "W"}
self.letters = {"B": 1, "W": 2}
self.states = []
def simulate(self, player):
win = 0
counter = 0
fake_board = Board(self.col, self.row, self.p)
self.copy_board(fake_board)
# print("DIT ME DIEN")
# fake_board.show_board()
# totaltime = 0
while win == 0:
moves = fake_board.get_all_possible_moves(player)
if len(moves) == 1:
index = 0
elif len(moves) == 0:
win = self.opponent[player]
break
else:
index = randint(0, len(moves) - 1)
if len(moves[index]) == 1:
inner_index = 0
else:
inner_index = randint(0, len(moves[index]) - 1)
move = moves[index][inner_index]
fake_board.make_move(move, player)
counter += 1
# bt = time.time()
if fake_board.tie_counter >= fake_board.tie_max:
win = -1
# totaltime += time.time() - bt
# print("self.board.is_win():", time.time() - bt)
player = self.opponent[player]
# #print("total time is_win:", totaltime)
# #bt = time.time()
# for i in range(counter):
# self.board.undo()
# #rint("total time undo:", time.time() - bt)
# fake_board.show_board()
return win
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = [Board(col, row, p) for i in range(num_processes)]
for board in self.board:
board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.search_lim = 5
self.current_node = TreeNode(None, self.color)
self.sim_total = 0
self.sim_counter = 0
def __init__(self, col, row, p):
self.col = col
self.row = row
self.p = p
self.board = Board(col, row, p)
self.board.initialize_game()
self.color = ''
self.opponent = {1: 2, 2: 1}
self.color = 2
self.ct = 0
#self.dif_val = False
self.size = self.col * self.row
if self.size < 40: #6x6
#print(8)
self.search_depth = 8
elif self.size < 50: #7x7
#print(7)
self.search_depth = 5
elif self.size < 80: #8x8
#print(6)
self.search_depth = 4
else:
self.search_depth = 4
