def test_sum_of_min_distances_ext2(self):
ev = CenterMassEvaluator()
l = [(0,0),(1,0),(3,0),
(0,1), (2,1),
(0,2),(1,2),(4,4)]
cm = ev.center_of_mass_from_coord_list(l)
r = ev.sum_of_min_distances_ext2(cm, l)
class WeightedEvaluatorI():
def __init__(self, wanted_mass, weight_before, weight_after, weight_enemy):
'''
@param weight_before: weight of euler
'''
self.wanted_mass = wanted_mass # center of mass,
#after this value we put weight_after on number of connected components
self.weight_before = weight_before
self.weight_after = weight_after
self.weight_enemy = weight_enemy
self.cm_eval = CenterMassEvaluator()
self.quad_eval = QuadEvaluator()
def evaluate(self, state, my_player, info_set):
enemy = other_player(my_player)
com_mine = self.cm_eval.evaluate(state, my_player, info_set)
com_his = self.cm_eval.evaluate(state,enemy , info_set)
euler_mine = self.quad_eval.evaluate(state, my_player, info_set)
euler_his = self.quad_eval.evaluate(state, enemy, info_set)
if com_mine < self.wanted_mass:
weight = self.weight_before
else:
weight = self.weight_after
h_mine = apply_weight(weight,euler_mine, com_mine)
h_his = apply_weight(weight,1-euler_his, com_his)
h = h_mine - self.weight_enemy * h_his
return h
def test_center_of_mass_from_coord_list(self):
ev = CenterMassEvaluator()
l = [(0,0),(1,0),(2,0),
(0,1), (2,1),
(0,2),(1,2),(2,2)]
cx,cy = ev.center_of_mass_from_coord_list(l)
self.assertEquals((cx,cy),(1,1))
def test__all(self):
stat = TimeStatisticsClass()
ev = CenterMassEvaluator()
state = LinesOfActionState(100, 50)
stat.restart_measure("f")
ev.evaluate(state, WHITE, 10)
stat.restart_measure("f")
stat.stop_measure()
print stat.stats
pass
def test_state_to_coord_repr(self):
ev = CenterMassEvaluator()
state = LinesOfActionState(6, 50)
chord_repr_of_state = ev.state_to_coord_repr(state)
#print
#print chord_repr_of_state
#print state
#ev.evaluate(state, player, action, quad_table_ext)
expected = {'B': [(0, 1), (5, 1), (0, 2), (5, 2), (0, 3), (5, 3), (0, 4), (5, 4)], 'W': [(1, 0), (2, 0), (3, 0), (4, 0), (1, 5), (2, 5), (3, 5), (4, 5)]}
def test(player):
self.assertEqual(len(chord_repr_of_state[player]), len(expected[player]))
for xy in chord_repr_of_state[player]:
self.assertTrue( xy in expected[player])
test(WHITE)
test(BLACK)
def setup(self, player, game_state, turn_time_limit, setup_time_limit):
#TODO: use my_init to config final agent
# we need init state to determine if we have to
self.init_state = game_state
self.prev_state = game_state
#save params
self.safe_delta = 0.085
self.corrected_turn_time_limit = turn_time_limit - self.safe_delta
self.player = player
# choose evaluator
self.evaluator = CenterMassEvaluator()
#TODO: check set_uptime
# == Setup info set ==
self.info_set = {}
self.info_set[QUAD_TABLE_TAG] = {
ITERATIVE: QuadTable,
NON_ITERATIVE: QuadTableNoUpdate
}[self.use_iterative](game_state.board, game_state.size, initialize =True)
# == Setup caching ==
if self.caching: self.turn_cache = TurnCache()
else: self.turn_cache = NoneTurnCache()
def __init__(self, wanted_mass, weight_before, weight_after, weight_enemy):
'''
@param weight_before: weight of euler
'''
self.wanted_mass = wanted_mass # center of mass,
#after this value we put weight_after on number of connected components
self.weight_before = weight_before
self.weight_after = weight_after
self.weight_enemy = weight_enemy
self.cm_eval = CenterMassEvaluator()
self.quad_eval = QuadEvaluator()
class WeightedEvaluatorH():
def __str__(self):
return "WeightedEvaluatorH wanted_mass=%s, weight_before=%s, weight_after=%s, weight_enemy=%s" % (
self.wanted_mass,
self.weight_before,
self.weight_after,
self.weight_enemy
)
def __init__(self, wanted_mass, weight_before, weight_after, weight_enemy):
'''
@param weight_before: weight of euler
'''
self.wanted_mass = wanted_mass # center of mass,
#after this value we put weight_after on number of connected components
self.weight_before = weight_before
self.weight_after = weight_after
self.weight_enemy = weight_enemy
self.cm_eval = CenterMassEvaluator()
self.quad_eval = QuadEvaluator()
def evaluate(self, state, my_player, info_set):
enemy = other_player(my_player)
com_mine = self.cm_eval.evaluate(state, my_player, info_set)
com_his = self.cm_eval.evaluate(state,enemy , info_set)
euler_mine = self.quad_eval.evaluate(state, my_player, info_set)
euler_his = self.quad_eval.evaluate(state, enemy, info_set)
if com_mine < self.wanted_mass:
weight = self.weight_before
else:
weight = self.weight_after
h_mine = (1 - weight) * com_mine + weight * euler_mine
h_his = (1 - weight) * com_his + weight * euler_his
h = h_mine - self.weight_enemy * h_his
return h
class AnytimeSmartAlphaBetaPrintAgentParamsOld(GameAgent):
# ----------------------- Info API -------------------------------
def get_name(self):
return self.alphaBeta.get_name()
def myinit(self, caching, init_max_depth, depth_delta, use_iterative):
'''
use string names names
allow to confine agent'''
self.caching = caching
self.depth_delta = depth_delta
self.use_iterative = use_iterative
self.rand = Random(0)
self.init_max_depth = init_max_depth
self.use_quads = False
#TODO:
self.winner_check = QUAD_WINNER
# ---------------------- Timer ----------------------------------
def start_timer(self):
EndTimer.set_limit_and_start(self.corrected_turn_time_limit)
def stop_timer(self):
EndTimer.stop()
# ---------------------- Game Interface ----------------------------------
def setup(self, player, game_state, turn_time_limit, setup_time_limit):
#TODO: use my_init to config final agent
# we need init state to determine if we have to
self.init_state = game_state
self.prev_state = game_state
#save params
self.safe_delta = 0.085
self.corrected_turn_time_limit = turn_time_limit - self.safe_delta
self.player = player
# choose evaluator
self.evaluator = CenterMassEvaluator()
#TODO: check set_uptime
# == Setup info set ==
self.info_set = {}
self.info_set[QUAD_TABLE_TAG] = {
ITERATIVE: QuadTable,
NON_ITERATIVE: QuadTableNoUpdate
}[self.use_iterative](game_state.board, game_state.size, initialize =True)
# == Setup caching ==
if self.caching: self.turn_cache = TurnCache()
else: self.turn_cache = NoneTurnCache()
# --------------------- The heuristics ------------------------------
def utility(self,state,info_set):
GTimeStatistics.start_measure("heur")
r = self.evaluator.evaluate(state, self.player,info_set)
GTimeStatistics.stop_measure("heur")
return r
def info_print(self,game_state):
pass
# print "The heuristics of game state"
# print game_state
# r1,r2 = self.evaluator.evaluate2(game_state, self.player,end_time)
# r = r1 + r2
# print "r=", r, " their:",r1, " fix:",r2
def _update_info_set_no_action(self, oldstate, newstate, info_set):
new_info_set = {}
for info_tag, info_table in info_set.items():
new_info_set[info_tag] = self.turn_cache.get_wkt(newstate, # use cache
info_tag, info_tag + '.update_no_action',
lambda: info_table.updateWithoutAction(oldstate, newstate) )
return new_info_set
def choose_default_answer(self,current_state):
#succesors = self.turn_cache.get(current_state, LinesOfActionState.getSuccessors)
succesors = current_state.getSuccessors()
# choose default move randomly:
index = self.rand.randint(0, len(succesors)-1)
res_action, res_state = succesors.items()[index]
return res_action, res_state
def move(self, game_state):
self.start_timer()
self.res_action, self.res_state = self.choose_default_answer(game_state)
print "w=",CenterMassEvaluator().evaluate(game_state,WHITE)
print "b=",CenterMassEvaluator().evaluate(game_state,BLACK)
try:
EndTimer.check("m10")
# calculate info set for this game_state
if self.init_state is self.prev_state:
state_info_set = self.info_set #first turn is us: we already has infoset
else:
state_info_set = self._update_info_set_no_action(self.prev_state, game_state, self.info_set)
EndTimer.check("m20")
# calculate info set for result game_state
self.res_info_set = self._update_info_set_no_action(game_state, self.res_state, state_info_set)
#choose our move
# results saved in self.res_action, self.res_state
self.search(game_state, state_info_set, self.init_max_depth)
#save our turn and its info set: to be able calculate next one
except TimeOutException: #TODO for release handle all exceptios
pass
# save data about our move
self.prev_state = self.res_state
self.info_set = self.res_info_set
return self.res_action
# --------------------------- search algorithm ------------------------
def search(self, current_state, info_set, init_max_depth):
'''
@param info_set: info set of current_state
'''
# start iterative search
curr_max_depth = init_max_depth
# print "time left", end_time - time.clock(), "d=", curr_max_depth
while True:
EndTimer.check("start search")
print "time left", EndTimer.time_left(), "d=", curr_max_depth
alg = SmartAlphaBetaSearch(self.player, self.utility, self.turn_cache, self.winner_check,self.use_quads)
self.res_action, self.res_state, self.res_info_set = alg.search(current_state, curr_max_depth, info_set)
curr_max_depth += self.depth_delta #TODO: TODO