def evaluate_army_movement(self, ai_stat: AI_GameStatus, move: AI_Move):
if len(ai_stat.map.army_list) == 0:
return
target_str = ""
self.previous_attack_target = None
if self.state == AI_Mazedonian.AI_State.PASSIVE:
# for now, just move it out of the way.
army_is_on_field = False
if ai_stat.map.army_list[0].base_tile in ai_stat.map.own_farm_field_tiles:
army_is_on_field = True
if not army_is_on_field:
has_farm = False
for b in ai_stat.map.building_list:
if b.type == BuildingType.FARM:
has_farm = True
if has_farm:
# walk to random field
path = []
idx = random.randint(0, len(ai_stat.map.own_farm_field_tiles) - 1)
# print(f"from: {ai_stat.map.army_list[0].base_tile.offset_coordinates} to {ai_stat.map.own_farm_field_tiles[idx].offset_coordinates}")
path = essentials.a_star(ai_stat.map.army_list[0].base_tile,
ai_stat.map.own_farm_field_tiles[idx],
ai_stat.map.walkable_tiles)
if len(path) > 1:
move.move_army_to = path[1].offset_coordinates
move.doMoveArmy = True
target_str = "corn field"
#elif self.state == AI_Mazedonian.AI_State.DEFENSIVE or self.state == AI_Mazedonian.AI_State.AGGRESSIVE:
else:
if len(self.priolist_targets) > 0:
if self.threshold_target_value <= self.priolist_targets[0].weighted_score:
# hint("on warpath: {} {}".format(self.threshold_target_value, self.priolist_targets[0].score))
# attack
start_tile = ai_stat.map.army_list[0].base_tile
target_tile = self.priolist_targets[0].target.base_tile
path = essentials.a_star(start_tile, target_tile, ai_stat.map.walkable_tiles)
if len(path) > 1:
self.previous_attack_target = self.priolist_targets[0]
move.move_army_to = path[1].offset_coordinates
move.doMoveArmy = True
target = self.priolist_targets[0]
s = "army" if type(target.target) is AI_Army else "building"
target_str = f"Movement: target: {s} @ loc: {target.target.offset_coordinates}"
if BASIC_DEBUG:
self._dump('moving to: {} from {} to {}'.format(str(move.move_army_to),
start_tile.offset_coordinates,
target_tile.offset_coordinates))
else:
self._dump("targets value to low. Will not attack")
if move.doMoveArmy:
self._dump(target_str)
def weight_options(self, ai_stat: AI_GameStatus, move: AI_Move,
all_options: List[Union[BuildOption, RecruitmentOption,
RaiseArmyOption, WaitOption]],
movement_options: List[ArmyMovementOption]):
used_weights: List[str] = []
for opt in all_options: # --------------------- Action options ----------
if opt.score == Priority.P_NO:
continue
opt.weighted_score = opt.score.value
for w in self.weights:
if w.condition(opt, ai_stat):
used_weights.append(w.condition.__name__)
opt.weighted_score = opt.weighted_score + w.weight
used_weights.append(" | ")
for opt in movement_options: # --------------------- Movement options ----------
if opt.score == Priority.P_NO:
continue
opt.weighted_score = opt.score.value
for w in self.m_weights:
if w.condition(opt, ai_stat):
used_weights.append(w.condition.__name__)
opt.weighted_score = opt.weighted_score + w.weight
all_options.sort(key=lambda x: x.weighted_score, reverse=True)
movement_options.sort(key=lambda x: x.weighted_score, reverse=True)
if len(all_options) > 0:
best_option = all_options[0]
if type(best_option) == WaitOption:
move.move_type = MoveType.DO_NOTHING
move.str_rep_of_action = "waiting"
elif type(best_option) == BuildOption:
move.move_type = MoveType.DO_BUILD
move.loc = best_option.site
move.type = best_option.type
move.str_rep_of_action = f"building a {best_option.type} at " + str(
move.loc)
elif type(best_option) == UpgradeOption:
move.move_type = MoveType.DO_UPGRADE_BUILDING
move.loc = best_option.site
move.type = best_option.type
move.str_rep_of_action = f"upgrading building to {move.type}"
elif type(best_option) == RecruitmentOption:
move.move_type = MoveType.DO_RECRUIT_UNIT
move.type = best_option.type
move.str_rep_of_action = f"recruiting a {best_option.type}"
elif type(best_option) == RaiseArmyOption:
move.move_type = MoveType.DO_RAISE_ARMY
move.loc = best_option.site
move.str_rep_of_action = "raising new army at"
else:
error("unexpected type")
if len(movement_options) > 0:
best_m_option = movement_options[0]
if best_m_option.weighted_score >= self.properties[
'threshold_army_movement']:
move.move_army_to = best_m_option.next_step
move.doMoveArmy = True
for opt in all_options:
s = f"Option of type {type(opt)}, score: {opt.weighted_score} ({opt.score})"
if not (type(opt) == WaitOption or type(opt) == RaiseArmyOption):
s = s + f" -> Type: {opt.type}"
self._dump(s)
for m_opt in movement_options:
stmp = 'army' if type(m_opt.target) is AI_Army else ''
stmp = 'building' if type(m_opt.target) is AI_Building else ''
s = f"M-Option target: {type(m_opt)} target({stmp}), score: {m_opt.weighted_score} ({m_opt.score})"
self._dump(s)
s = f"DECISION: {move.str_rep_of_action}"
if move.doMoveArmy:
s += f" moving army to {move.move_army_to}"
self._dump(s)