def start(self, rows: int, columns: int, mines: int):
assert columns > 0 and rows > 0 and 0 < mines < rows * columns
# Initialize game data
self.rows, self.cols, self.mines = rows, columns, mines
self.remain = rows * columns
self.marked, self.moves, self.status = 0, 0, STATUS.RUNNING
self.start_time, self.__duration = time.time(), 0.
self.__map = Map(rows, columns, self.mines)
self.__mask = [[MASK.UNKNOWN for _ in range(columns)]
for _ in range(rows)]
def main(filename):
"""Parse the input file and output the results."""
with open(filename) as f:
map_ = [list(l) for l in f.read().splitlines()]
map_ = Map(map_)
map_.init()
print("Initial")
show_map(map_)
round_ = 0
while True:
round_ += 1
if not start_round(map_):
break
print(f"Finished Round {round_}")
show_map(map_)
show_map(map_)
total_hp = sum([u.hp for u in map_.units.values() if not u.is_dead])
round_ -= 1
print(
f"Rounds {round_}, Total HP: {total_hp}, Outcome: {round * total_hp}")
def run(self, config=None, first_run=False):
# setup and check if village still exists / is accessible
self.config = config
self.wrapper.delay = self.get_config(section="bot",
parameter="delay_factor",
default=1.0)
if not self.village_id:
data = self.wrapper.get_url("game.php?screen=overview&intro")
if data:
self.game_data = Extractor.game_state(data)
if self.game_data:
self.village_id = str(self.game_data['village']['id'])
self.logger = logging.getLogger(
"Village %s" % self.game_data['village']['name'])
self.logger.info("Read game state for village")
else:
data = self.wrapper.get_url("game.php?village=%s&screen=overview" %
self.village_id)
if data:
self.game_data = Extractor.game_state(data)
self.logger = logging.getLogger(
"Village %s" % self.game_data['village']['name'])
self.logger.info("Read game state for village")
self.wrapper.reporter.report(
self.village_id, "TWB_START",
"Starting run for village: %s" %
self.game_data['village']['name'])
if not self.game_data:
self.logger.error("Error reading game data for village %s" %
self.village_id)
return None
if self.village_set_name and self.game_data['village'][
'name'] != self.village_set_name:
self.logger.name = "Village %s" % self.village_set_name
if not self.get_config(section="villages", parameter=self.village_id):
return None
if self.get_config(section="server",
parameter="server_on_twplus",
default=False):
self.twp.run(
world=self.get_config(section="server", parameter="world"))
vdata = self.get_config(section="villages", parameter=self.village_id)
if not self.get_village_config(
self.village_id, parameter="managed", default=False):
return False
if not self.game_data:
return False
if not self.resman:
self.resman = ResourceManager(wrapper=self.wrapper,
village_id=self.village_id)
self.resman.update(self.game_data)
self.wrapper.reporter.report(self.village_id, "TWB_PRE_RESOURCE",
str(self.resman.actual))
if not self.rep_man:
self.rep_man = ReportManager(wrapper=self.wrapper,
village_id=self.village_id)
self.rep_man.read(full_run=False)
if not self.def_man:
self.def_man = DefenceManager(wrapper=self.wrapper,
village_id=self.village_id)
self.def_man.map = self.area
if not self.def_man.units:
self.def_man.units = self.units
last_attack = self.def_man.under_attack
self.def_man.manage_flags_enabled = self.get_config(
section="world", parameter="flags_enabled", default=False)
self.def_man.support_factor = self.get_village_config(
self.village_id, "support_others_factor", default=0.25)
self.def_man.allow_support_send = self.get_village_config(
self.village_id, parameter="support_others", default=False)
self.def_man.allow_support_recv = self.get_village_config(
self.village_id,
parameter="request_support_on_attack",
default=False)
self.def_man.auto_evacuate = self.get_village_config(
self.village_id,
parameter="evacuate_fragile_units_on_attack",
default=False)
self.def_man.update(data.text,
with_defence=self.get_config(
section="units",
parameter="manage_defence",
default=False))
disabled_units = []
if not self.get_config(
section="world", parameter="archers_enabled", default=True):
disabled_units.extend(["archer", "marcher"])
if not self.get_config(section="world",
parameter="building_destruction_enabled",
default=True):
disabled_units.extend(["ram", "catapult"])
if self.def_man.under_attack and not last_attack:
self.logger.warning("Village under attack!")
self.wrapper.reporter.report(
self.village_id, "TWB_ATTACK",
"Village: %s under attack" % self.game_data['village']['name'])
# setup and check if village still exists / is accessible
if self.get_config(section="world",
parameter="quests_enabled",
default=False):
if self.get_quests():
self.logger.info(
"There where completed quests, re-running function")
self.wrapper.reporter.report(self.village_id, "TWB_QUEST",
"Completed quest")
return self.run(config=config)
if not self.builder:
self.builder = BuildingManager(wrapper=self.wrapper,
village_id=self.village_id)
self.builder.resman = self.resman
# manage buildings (has to always run because recruit check depends on building levels)
build_config = self.get_village_config(self.village_id,
parameter="building",
default=None)
if not build_config:
self.logger.warning(
"Village %d does not have 'building' config override!" %
self.village_id)
build_config = self.get_config(section="building",
parameter="default",
default="purple_predator")
new_queue = TemplateManager.get_template(category="builder",
template=build_config)
if not self.builder.raw_template or self.builder.raw_template != new_queue:
self.builder.queue = new_queue
self.builder.raw_template = new_queue
if not self.get_config(section="world",
parameter="knight_enabled",
default=False):
self.builder.queue = [
x for x in self.builder.queue if "statue" not in x
]
self.builder.max_lookahead = self.get_config(section="building",
parameter="max_lookahead",
default=2)
self.builder.max_queue_len = self.get_config(
section="building", parameter="max_queued_items", default=2)
self.builder.start_update(build=self.get_config(
section="building", parameter="manage_buildings", default=True),
set_village_name=self.village_set_name)
if not self.units:
self.units = TroopManager(wrapper=self.wrapper,
village_id=self.village_id)
self.units.resman = self.resman
self.units.max_batch_size = self.get_config(section="units",
parameter="batch_size",
default=25)
# set village templates
unit_config = self.get_village_config(self.village_id,
parameter="units",
default=None)
if not unit_config:
self.logger.warning(
"Village %d does not have 'building' config override!" %
self.village_id)
unit_config = self.get_config(section="units",
parameter="default",
default="basic")
self.units.template = TemplateManager.get_template(
category="troops", template=unit_config, output_json=True)
entry = self.units.get_template_action(self.builder.levels)
if entry and self.units.wanted != entry["build"]:
# update wanted units if template has changed
self.logger.info("%s as wanted units for current village" %
(str(entry["build"])))
self.units.wanted = entry["build"]
if self.units.wanted_levels != {}:
self.logger.info("%s as wanted upgrades for current village" %
(str(self.units.wanted_levels)))
# get total amount of troops in village
self.units.update_totals()
if self.get_config(section="units", parameter="upgrade",
default=False) and self.units.wanted_levels != {}:
self.units.attempt_upgrade()
if self.get_village_config(
self.village_id, parameter="snobs",
default=None) and self.builder.levels['snob'] > 0:
if not self.snobman:
self.snobman = SnobManager(wrapper=self.wrapper,
village_id=self.village_id)
self.snobman.troop_manager = self.units
self.snobman.resman = self.resman
self.snobman.wanted = self.get_village_config(self.village_id,
parameter="snobs",
default=0)
self.snobman.building_level = self.builder.get_level("snob")
self.snobman.run()
# recruitment management
if self.get_config(section="units", parameter="recruit",
default=False):
self.units.can_fix_queue = self.get_config(
section="units",
parameter="remove_manual_queued",
default=False)
self.units.randomize_unit_queue = self.get_config(
section="units",
parameter="randomize_unit_queue",
default=True)
# prioritize_building: will only recruit when builder has sufficient funds for queue items
if self.get_village_config(
self.village_id,
parameter="prioritize_building",
default=False) and not self.resman.can_recruit():
self.logger.info(
"Not recruiting because builder has insufficient funds")
elif self.get_village_config(
self.village_id, parameter="prioritize_snob", default=False
) and self.snobman and self.snobman.can_snob and self.snobman.is_incomplete:
self.logger.info(
"Not recruiting because snob has insufficient funds")
else:
# do a build run for every
for building in self.units.wanted:
if not self.builder.get_level(building):
self.logger.debug(
"Recruit of %s will be ignored because building is not (yet) available"
% building)
continue
self.units.start_update(building)
self.logger.debug("Current resources: %s" % str(self.resman.actual))
self.logger.debug("Requested resources: %s" %
str(self.resman.requested))
# attack management
if self.units.can_attack:
if not self.area:
self.area = Map(wrapper=self.wrapper,
village_id=self.village_id)
self.area.get_map()
if self.area.villages:
self.units.can_scout = self.get_config(
section="farms",
parameter="force_scout_if_available",
default=True)
self.logger.info(
"%d villages from map cache, (your location: %s)" %
(len(self.area.villages), ':'.join(
[str(x) for x in self.area.my_location])))
if not self.attack:
self.attack = AttackManager(wrapper=self.wrapper,
village_id=self.village_id,
troopmanager=self.units,
map=self.area)
self.attack.repman = self.rep_man
self.attack.target_high_points = self.get_config(
section="farms",
parameter="attack_higher_points",
default=False)
self.attack.farm_minpoints = self.get_config(
section="farms", parameter="min_points", default=24)
self.attack.farm_maxpoints = self.get_config(
section="farms", parameter="max_points", default=1080)
self.attack.farm_default_wait = self.get_config(
section="farms",
parameter="default_away_time",
default=1200)
self.attack.farm_high_prio_wait = self.get_config(
section="farms",
parameter="full_loot_away_time",
default=1800)
self.attack.farm_low_prio_wait = self.get_config(
section="farms",
parameter="low_loot_away_time",
default=7200)
if entry:
self.attack.template = entry['farm']
if self.get_config(
section="farms", parameter="farm",
default=False) and not self.def_man.under_attack:
self.attack.extra_farm = self.get_village_config(
self.village_id,
parameter="additional_farms",
default=[])
self.attack.max_farms = self.get_config(
section="farms", parameter="max_farms", default=25)
self.attack.run()
self.units.can_gather = self.get_village_config(
self.village_id, parameter="gather_enabled", default=False)
if not self.def_man or not self.def_man.under_attack:
self.units.gather(selection=self.get_village_config(
self.village_id, parameter="gather_selection", default=1),
disabled_units=disabled_units)
# market management
if self.get_config(section="market",
parameter="auto_trade",
default=False) and self.builder.get_level("market"):
self.logger.info("Managing market")
self.resman.trade_max_per_hour = self.get_config(
section="market", parameter="trade_max_per_hour", default=1)
self.resman.trade_max_duration = self.get_config(
section="market", parameter="max_trade_duration", default=1)
if self.get_config(section="market",
parameter="trade_multiplier",
default=False):
self.resman.trade_bias = self.get_config(
section="market",
parameter="trade_multiplier_value",
default=1.0)
self.resman.manage_market(drop_existing=self.get_config(
section="market", parameter="auto_remove", default=True))
res = self.wrapper.get_action(village_id=self.village_id,
action="overview")
self.game_data = Extractor.game_state(res)
self.resman.update(self.game_data)
if self.get_config(section="world",
parameter="trade_for_premium",
default=False) and self.get_village_config(
self.village_id,
parameter="trade_for_premium",
default=False):
self.resman.do_premium_stuff()
self.set_cache_vars()
self.logger.info("Village cycle done, returning to overview")
self.wrapper.reporter.report(self.village_id, "TWB_POST_RESOURCE",
str(self.resman.actual))
self.wrapper.reporter.add_data(self.village_id,
data_type="village.resources",
data=json.dumps(self.resman.actual))
self.wrapper.reporter.add_data(self.village_id,
data_type="village.buildings",
data=json.dumps(self.builder.levels))
self.wrapper.reporter.add_data(self.village_id,
data_type="village.troops",
data=json.dumps(
self.units.total_troops))
self.wrapper.reporter.add_data(self.village_id,
data_type="village.config",
data=json.dumps(vdata))
parser.add_argument('--height',
type=int,
default=10,
help="Height to use for map")
parser.add_argument('--seed',
type=int,
default=random.random() * 1000,
help="Seed random generator with given value")
parser.add_argument('--ui',
type=str,
default="text",
help="UI to load (curses, gtk, text)")
return parser.parse_args()
if __name__ == "__main__":
args = parse_commandline()
print("Building {0}x{1} map".format(args.width, args.height))
map = Map(height=args.height, width=args.width, seed=args.seed)
map.generate()
player = Character(name="Player")
wumpus = Character(name="Wumpus")
map.place_character(player)
map.place_character(wumpus)
print(map)
def run(self, config=None):
# setup and check if village still exists / is accessible
self.config = config
if not self.village_id:
data = self.wrapper.get_url("game.php?screen=overview&intro")
if data:
self.game_data = Extractor.game_state(data)
if self.game_data:
self.village_id = str(self.game_data['village']['id'])
self.logger = logging.getLogger("Village %s" % self.game_data['village']['name'])
self.logger.info("Read game state for village")
else:
data = self.wrapper.get_url("game.php?village=%s&screen=overview" % self.village_id)
if data:
self.game_data = Extractor.game_state(data)
self.logger = logging.getLogger("Village %s" % self.game_data['village']['name'])
self.logger.info("Read game state for village")
if str(self.village_id) not in self.config['villages']:
return False
self.twp.run(world=self.config['server']['world'])
vdata = self.config['villages'][str(self.village_id)]
if not vdata['managed']:
return False
if not self.game_data:
return False
# setup modules
if not self.resman:
self.resman = ResourceManager(wrapper=self.wrapper, village_id=self.village_id)
self.resman.update(self.game_data)
if not self.rep_man:
self.rep_man = ReportManager(wrapper=self.wrapper, village_id=self.village_id)
self.rep_man.read(full_run=False)
if not self.def_man:
self.def_man = DefenceManager(wrapper=self.wrapper, village_id=self.village_id)
self.def_man.update(data.text)
if self.def_man.under_attack:
self.logger.warning("Village under attack!")
# setup and check if village still exists / is accessible
if self.config['world']['quests_enabled']:
if self.get_quests():
self.logger.info("There where completed quests, re-running function")
return self.run()
if not self.builder:
self.builder = BuildingManager(wrapper=self.wrapper, village_id=self.village_id)
self.builder.resman = self.resman
# manage buildings (has to always run because recruit check depends on building levels)
build_config = vdata['building'] if vdata['building'] else self.config['building']['default']
self.builder.queue = TemplateManager.get_template(category="builder", template=build_config)
self.builder.max_lookahead = self.config['building']['max_lookahead']
self.builder.max_queue_len = self.config['building']['max_queued_items']
self.builder.start_update(build=self.config['building']['manage_buildings'])
if not self.units:
self.units = TroopManager(wrapper=self.wrapper, village_id=self.village_id)
self.units.max_batch_size = self.config['units']['batch_size']
self.units.resman = self.resman
# set village templates
unit_config = vdata['units'] if vdata['units'] else self.config['units']['default']
self.units.template = TemplateManager.get_template(category="troops", template=unit_config, output_json=True)
entry = self.units.get_template_action(self.builder.levels)
if entry and self.units.wanted != entry["build"]:
# update wanted units if template has changed
self.logger.info("%s as wanted units for current village" % (str(entry["build"])))
self.units.wanted = entry["build"]
if entry and 'upgrades' in entry and self.units.wanted_levels != entry['upgrades']:
self.logger.info("%s as wanted upgrades for current village" % (str(entry["upgrades"])))
self.units.wanted_levels = entry['upgrades']
# get total amount of troops in village
self.units.update_totals()
if self.config['units']['upgrade'] and self.units.wanted_levels != {}:
self.units.attempt_upgrade(self.units.wanted_levels)
if 'snobs' in vdata and self.builder.levels['snob'] > 0:
if not self.snobman:
self.snobman = SnobManager(wrapper=self.wrapper, village_id=self.village_id)
self.snobman.troop_manager = self.units
self.snobman.resman = self.resman
self.snobman.wanted = vdata['snobs']
self.snobman.building_level = self.builder.levels['snob']
self.snobman.run()
if self.config['units']['recruit']:
# prioritize_building: will only recruit when builder has sufficient funds for queue items
if vdata['prioritize_building'] and not self.resman.can_recruit():
self.logger.info("Not recruiting because builder has insufficient funds")
elif vdata['prioritize_snob'] and self.snobman and self.snobman.can_snob and self.snobman.is_incomplete:
self.logger.info("Not recruiting because snob has insufficient funds")
else:
# do a build run for every
for building in self.units.wanted:
if building not in self.builder.levels or self.builder.levels[building] == 0:
self.logger.debug("Recruit of %s will be ignored because building is not available" % building)
continue
self.units.start_update(building)
self.logger.debug("Current resources: %s" % str(self.resman.actual))
self.logger.debug("Requested resources: %s" % str(self.resman.requested))
if self.units.can_attack:
if not self.area:
self.area = Map(wrapper=self.wrapper, village_id=self.village_id)
self.area.get_map()
if self.area.villages:
self.logger.info("%d villages from map cache, (your location: %s)" % (
len(self.area.villages), ':'.join([str(x) for x in self.area.my_location])))
if not self.attack:
self.attack = AttackManager(wrapper=self.wrapper, village_id=self.village_id,
troopmanager=self.units, map=self.area)
self.attack.repman = self.rep_man
if entry:
self.attack.template = entry['farm']
if self.config['farms']['farm']:
self.attack.extra_farm = vdata['additional_farms']
self.attack.max_farms = self.config['farms']['max_farms']
self.attack.run()
if not self.def_man.under_attack:
self.units.gather()
if self.config['market']['auto_trade'] and "market" in self.builder.levels and self.builder.levels["market"] > 0:
self.logger.info("Managing market")
self.resman.trade_max_per_hour = self.config['market']['trade_max_per_hour']
self.resman.trade_max_duration = self.config['market']['max_trade_duration']
if self.config['market']['trade_multiplier']:
self.resman.trade_bias = self.config['market']['trade_multiplier_value']
self.resman.manage_market(drop_existing=self.config['market']['auto_remove'])
self.logger.info("Village cycle done, returning to overview")
res = self.wrapper.get_action(village_id=self.village_id, action="overview")
self.game_data = Extractor.game_state(res)
self.resman.update(self.game_data)
def __init__(self):
self.room_map = Map(a_scale=1, backgroundX=0, backgroundY=0)
self.players = []
pyglet.clock.schedule_interval(self.update, 1/60.0)
pyglet.clock.schedule_interval(self.check_ground, 1/60.0)
def setUp(self):
self.map = Map()
def __init__(self, teams=2):
self.map = Map(self)
self.team_to_character = [Team() for _ in range(teams)]