def test_reveal_creatures(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", Creature.n2c(["Unknown", "Unknown", "Unknown", "Unknown"]), 1) legion.reveal_creatures(["Ogre"]) assert legion.creature_names == ["Ogre", "Unknown", "Unknown", "Unknown"] legion.reveal_creatures(["Ogre", "Ogre"]) assert legion.creature_names == ["Ogre", "Ogre", "Unknown", "Unknown"] legion.reveal_creatures(["Ogre", "Ogre", "Troll"]) assert legion.creature_names == ["Ogre", "Ogre", "Troll", "Unknown"] legion.reveal_creatures(["Troll"]) assert legion.creature_names == ["Ogre", "Ogre", "Troll", "Unknown"] legion.reveal_creatures(["Troll", "Troll"]) assert legion.creature_names == ["Ogre", "Ogre", "Troll", "Troll"] legion.add_creature_by_name("Ranger") legion.reveal_creatures(["Troll", "Troll", "Ranger"]) assert legion.creature_names == ["Ogre", "Ogre", "Ranger", "Troll", "Troll"] legion = Legion.Legion(player, "Rd01", Creature.n2c(["Unknown", "Unknown", "Unknown", "Unknown"]), 1) legion.reveal_creatures(["Centaur", "Centaur", "Lion"]) assert legion.creature_names == ["Centaur", "Centaur", "Lion", "Unknown"]
def test_available_recruits_and_recruiters(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", Creature.n2c(["Titan", "Gargoyle", "Centaur", "Centaur"]), 1) caretaker = Caretaker.Caretaker() assert legion.available_recruits_and_recruiters("Marsh", caretaker) == [] assert legion.available_recruits_and_recruiters("Desert", caretaker) == [] assert legion.available_recruits_and_recruiters("Plains", caretaker) == [ ("Centaur", "Centaur"), ("Lion", "Centaur", "Centaur")] assert legion.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Gargoyle")] assert legion.available_recruits_and_recruiters("Tower", caretaker) == [ ("Ogre",), ("Centaur",), ("Gargoyle",), ("Warlock", "Titan")] caretaker.counts["Centaur"] = 0 assert legion.available_recruits_and_recruiters("Plains", caretaker) == [ ("Lion", "Centaur", "Centaur")] legion2 = Legion.Legion(player, "Rd02", Creature.n2c(["Titan", "Gargoyle", "Gargoyle", "Gargoyle"]), 1) assert legion2.available_recruits_and_recruiters("Tower", caretaker) == [ ("Ogre",), ("Gargoyle",), ("Warlock", "Titan"), ("Guardian", "Gargoyle", "Gargoyle", "Gargoyle")] assert legion2.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Gargoyle"), ("Cyclops", "Gargoyle", "Gargoyle")] legion3 = Legion.Legion(player, "Rd03", Creature.n2c(["Colossus"]), 1) assert legion3.available_recruits_and_recruiters("Tundra", caretaker) == [ ("Troll", "Colossus"), ("Warbear", "Colossus"), ("Giant", "Colossus"), ("Colossus", "Colossus")] assert legion3.available_recruits_and_recruiters("Mountains", caretaker) == [ ("Lion", "Colossus"), ("Minotaur", "Colossus"), ("Dragon", "Colossus"), ("Colossus", "Colossus")] assert legion3.available_recruits_and_recruiters("Marsh", caretaker) == [] legion4 = Legion.Legion(player, "Rd04", Creature.n2c(["Behemoth", "Cyclops", "Cyclops", "Cyclops"]), 1) assert legion4.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Cyclops"), ("Cyclops", "Cyclops"), ("Gorgon", "Cyclops", "Cyclops")] logging.info(legion4.available_recruits_and_recruiters("Jungle", caretaker)) assert legion4.available_recruits_and_recruiters("Jungle", caretaker) == [ ("Gargoyle", "Cyclops"), ("Gargoyle", "Behemoth"), ("Cyclops", "Cyclops"), ("Cyclops", "Behemoth"), ("Behemoth", "Cyclops", "Cyclops", "Cyclops"), ("Behemoth", "Behemoth"), ]
def split_legion(self, parent_markerid, child_markerid, parent_creature_names, child_creature_names): logging.info("%s %s %s %s", parent_markerid, child_markerid, parent_creature_names, child_creature_names) parent = self.markerid_to_legion.get(parent_markerid) if parent is None: return if child_markerid not in self.markerids_left: raise AssertionError("illegal marker") if ( Counter(parent_creature_names) + Counter(child_creature_names) != Counter(parent.creature_names) and Counter(parent_creature_names) + Counter(child_creature_names) != Counter({"Unknown": len(parent)}) ): raise AssertionError("wrong creatures", "parent.creature_names", parent.creature_names, "parent_creature_names", parent_creature_names, "child_creature_names", child_creature_names) new_legion1 = Legion.Legion(self, parent_markerid, Creature.n2c(parent_creature_names), parent.hexlabel) new_legion2 = Legion.Legion(self, child_markerid, Creature.n2c(child_creature_names), parent.hexlabel) if not parent.is_legal_split(new_legion1, new_legion2): raise AssertionError("illegal split") del new_legion1 parent.creatures = Creature.n2c(parent_creature_names) for creature in parent.creatures: creature.legion = parent self.take_marker(child_markerid) new_legion2.add_observer(self.game) self.markerid_to_legion[child_markerid] = new_legion2 del parent # One action for our player with creature names action = Action.SplitLegion(self.game.name, self.name, parent_markerid, child_markerid, parent_creature_names, child_creature_names) logging.info(action) self.notify(action, names=[self.name]) # Another action for everyone (including our player, who will # ignore it as a duplicate) without creature names. action = Action.SplitLegion(self.game.name, self.name, parent_markerid, child_markerid, len(parent_creature_names) * ["Unknown"], len(child_creature_names) * ["Unknown"]) logging.info(action) self.notify(action)
def test_any_summonable(): creatures = Creature.n2c(["Archangel", "Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Minotaur"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert legion.any_summonable creatures = Creature.n2c(["Angel", "Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Minotaur"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert legion.any_summonable creatures = Creature.n2c(["Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Minotaur"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert not legion.any_summonable
def test_score(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert legion.score == 120
def test_remove_creature_by_name(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert len(legion) == 8 legion.remove_creature_by_name("Gargoyle") assert len(legion) == 7 assert "Gargoyle" in legion.creature_names legion.remove_creature_by_name("Gargoyle") assert len(legion) == 6 assert "Gargoyle" not in legion.creature_names try: legion.remove_creature_by_name("Gargoyle") except ValueError: pass else: assert False legion.remove_creature_by_name("Ogre") legion.remove_creature_by_name("Ogre") legion.remove_creature_by_name("Centaur") legion.remove_creature_by_name("Centaur") legion.remove_creature_by_name("Titan") assert len(legion) == 1 assert legion legion.remove_creature_by_name("Angel") assert len(legion) == 0 assert legion
def test_add_creature_by_name(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert len(legion) == 8 try: legion.add_creature_by_name("Cyclops") except ValueError: pass else: assert False legion.remove_creature_by_name("Gargoyle") assert len(legion) == 7 try: legion.add_creature_by_name("Cyclops") except ValueError: pass else: assert False assert "Gargoyle" in legion.creature_names legion.remove_creature_by_name("Gargoyle") assert len(legion) == 6 assert "Gargoyle" not in legion.creature_names legion.add_creature_by_name("Troll") assert len(legion) == 7 assert "Troll" in legion.creature_names
def test_creature_names(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert legion.creature_names == ["Angel", "Centaur", "Centaur", "Gargoyle", "Gargoyle", "Ogre", "Ogre", "Titan"]
def update_creatures(self, game): """Update creatures in game from self.aps.""" for legion in game.all_legions(): markerid = legion.markerid node = self.aps.get_leaf(markerid) if node and node.creature_names != legion.creature_names: legion.creatures = Creature.n2c(node.creature_names) for creature in legion.creatures: creature.legion = legion
def test_sorted_creatures(): creatures = Creature.n2c(["Archangel", "Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Minotaur"]) legion = Legion.Legion(None, "Rd01", creatures, 1) li = legion.sorted_creatures assert len(li) == len(creatures) == len(legion) names = [creature.name for creature in li] assert names == ["Archangel", "Serpent", "Ranger", "Minotaur", "Gargoyle", "Centaur", "Ogre"]
def test_picname(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert legion.picname == "Cross" legion = Legion.Legion(player, "Rd02", Creature.n2c(["Titan", "Gargoyle", "Centaur", "Centaur"]), 1) assert legion.picname == "Eagle" legion = Legion.Legion(player, "Gr12", Creature.n2c(["Gargoyle", "Gargoyle", "Centaur", "Centaur"]), 1) assert legion.picname == "Ourobouros"
def test_unknown(): creatures = Creature.n2c(["Archangel", "Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Minotaur"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert not legion.any_unknown assert legion.all_known assert not legion.all_unknown creatures = Creature.n2c(["Archangel", "Serpent", "Centaur", "Gargoyle", "Ogre", "Ranger", "Unknown"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert legion.any_unknown assert not legion.all_known assert not legion.all_unknown creatures = Creature.n2c(8 * ["Unknown"]) legion = Legion.Legion(None, "Rd01", creatures, 1) assert legion.any_unknown assert not legion.all_known assert legion.all_unknown
def test_find_creature(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert legion.find_creature("Titan", "DEFENDER") is None for creature in legion.creatures: creature.hexlabel = "DEFENDER" assert legion.find_creature("Titan", "DEFENDER") is not None assert legion.find_creature("Ogre", "DEFENDER") is not None assert legion.find_creature("Titan", "ATTACKER") is None assert legion.find_creature("Ogre", "ATTACKER") is None
def test_num_lords(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) assert legion.num_lords == 2 assert not legion.can_flee legion = Legion.Legion(player, "Rd02", Creature.n2c(["Titan", "Gargoyle", "Centaur", "Centaur"]), 1) assert legion.num_lords == 1 assert not legion.can_flee legion = Legion.Legion(player, "Rd02", Creature.n2c(["Gargoyle", "Gargoyle", "Centaur", "Centaur"]), 1) assert legion.num_lords == 0 assert legion.can_flee
def test_could_recruit(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd02", Creature.n2c(["Titan", "Gargoyle", "Centaur", "Centaur"]), 1) caretaker = Caretaker.Caretaker() assert not legion.could_recruit("Marsh", caretaker) assert not legion.could_recruit("Desert", caretaker) assert legion.could_recruit("Plains", caretaker) assert legion.could_recruit("Brush", caretaker) assert legion.could_recruit("Tower", caretaker)
def test_combat_value(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd01", creatures, 1) # No terrain legion.hexlabel = None assert legion.terrain_combat_value == legion.combat_value # Plains legion.hexlabel = 1 assert legion.terrain_combat_value == legion.combat_value # Woods legion.hexlabel = 2 assert legion.terrain_combat_value == legion.combat_value # Brush legion.hexlabel = 3 assert legion.terrain_combat_value > legion.combat_value # Hills legion.hexlabel = 4 assert legion.terrain_combat_value > legion.combat_value # Jungle legion.hexlabel = 5 assert legion.terrain_combat_value > legion.combat_value # Desert legion.hexlabel = 7 assert legion.terrain_combat_value == legion.combat_value # Marsh legion.hexlabel = 8 assert legion.terrain_combat_value > legion.combat_value # Swamp legion.hexlabel = 14 assert legion.terrain_combat_value > legion.combat_value # Tower legion.hexlabel = 100 assert legion.terrain_combat_value > legion.combat_value # Mountains legion.hexlabel = 1000 assert legion.terrain_combat_value == legion.combat_value # Tundra legion.hexlabel = 2000 assert legion.terrain_combat_value == legion.combat_value
def test_can_summon(): now = time.time() game = Game.Game("g1", "p1", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player1 = Player.Player("p1", game, 0) player1.assign_color("Red") game.players.append(player1) legion1 = Legion.Legion(player1, "Rd01", creatures, 1) player1.markerid_to_legion[legion1.markerid] = legion1 assert not legion1.can_summon player1.split_legion("Rd01", "Rd02", ["Titan", "Centaur", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Gargoyle"]) assert legion1.can_summon legion2 = player1.markerid_to_legion["Rd02"] legion2.move(2, False, None, 1) assert legion1.can_summon assert not legion2.can_summon
def test_is_legal_split(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player = Player.Player("p0", game, 0) parent = Legion.Legion(player, "Rd01", creatures, 1) child1 = Legion.Legion(player, "Rd01", Creature.n2c(["Titan", "Gargoyle", "Ogre", "Ogre"]), 1) child2 = Legion.Legion(player, "Rd03", Creature.n2c(["Angel", "Gargoyle", "Centaur", "Centaur"]), 1) assert parent.is_legal_split(child1, child2) assert not parent.is_legal_split(child1, child1) parent2 = Legion.Legion(player, "Rd01", Creature.n2c(["Titan", "Gargoyle", "Ogre", "Troll", "Centaur"]), 1) child3 = Legion.Legion(player, "Rd01", Creature.n2c(["Titan", "Gargoyle", "Ogre", "Troll"]), 1) child4 = Legion.Legion(player, "Rd03", Creature.n2c(["Centaur"]), 1) assert not parent2.is_legal_split(child3, child4) child5 = Legion.Legion(player, "Rd01", Creature.n2c(["Unknown", "Unknown", "Unknown", "Unknown"]), 1) child6 = Legion.Legion(player, "Rd03", Creature.n2c(["Unknown", "Unknown", "Unknown", "Unknown"]), 1) assert parent.is_legal_split(child5, child6)
def test_available_recruits(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player("p0", game, 0) legion = Legion.Legion(player, "Rd02", Creature.n2c(["Titan", "Lion", "Gargoyle", "Centaur", "Centaur"]), 1) caretaker = Caretaker.Caretaker() assert legion.available_recruits("Marsh", caretaker) == [] assert legion.available_recruits("Desert", caretaker) == ["Lion"] assert legion.available_recruits("Plains", caretaker) == ["Centaur", "Lion"] assert legion.available_recruits("Brush", caretaker) == ["Gargoyle"] assert legion.available_recruits("Tower", caretaker) == ["Ogre", "Centaur", "Gargoyle", "Warlock"]
def test_engaged(): now = time.time() game = Game.Game("g1", "p1", now, now, 2, 6) creatures = Creature.n2c(creaturedata.starting_creature_names) player1 = Player.Player("p1", game, 0) player1.color = "Red" game.players.append(player1) legion1 = Legion.Legion(player1, "Rd01", creatures, 1) player1.markerid_to_legion[legion1.markerid] = legion1 player2 = Player.Player("p2", game, 1) player2.color = "Blue" game.players.append(player2) legion2 = Legion.Legion(player2, "Bu01", creatures, 2) player2.markerid_to_legion[legion2.markerid] = legion2 assert not legion1.engaged assert not legion2.engaged legion2.move(1, False, None, 1) assert legion1.engaged assert legion2.engaged
def forget_creatures(self): """Make all creatures Unknown.""" self.creatures = Creature.n2c(len(self) * ["Unknown"]) for creature in self.creatures: creature.legion = self
def add_creature_by_name(self, creature_name): if len(self) >= 7: raise ValueError("no room to add another creature") creature = Creature.Creature(creature_name) creature.legion = self self.creatures.append(creature)
from slugathon.data import creaturedata, playercolordata from slugathon.game import Legion, Player from slugathon.util import guiutils def cb_destroy(confirmed): print "destroy" graveyard.destroy() gtk.main_quit() def cb_click(self, widget, event): if self.legion.living_creatures: random.choice(self.legion.living_creatures).kill() graveyard.update_gui() creatures = [ Creature.Creature(name) for name in creaturedata.starting_creature_names ] playername = "test" player = Player.Player(playername, None, None) player.color = random.choice(playercolordata.colors) abbrev = player.color_abbrev index = random.randrange(1, 12 + 1) legion = Legion.Legion(player, "%s%02d" % (abbrev, index), creatures, 1) graveyard = Graveyard(legion) graveyard.connect("destroy", guiutils.exit) graveyard.connect("button-press-event", cb_click, graveyard) window = gtk.Window() window.add(graveyard)
def cb_cancel(self, widget, response_id): self.deferred.callback((self.legion, None, None)) self.destroy() if __name__ == "__main__": import time from slugathon.game import Creature, Legion, Player, Game from slugathon.util import guiutils now = time.time() playername = "test" game = Game.Game("g1", playername, now, now, 2, 6) player = Player.Player(playername, game, 0) player.color = "Red" creatures1 = [Creature.Creature(name) for name in ["Titan", "Ogre", "Troll", "Ranger"]] creatures2 = [Creature.Creature(name) for name in ["Angel", "Ogre", "Troll", "Ranger"]] creatures3 = [Creature.Creature(name) for name in ["Archangel", "Centaur", "Lion", "Ranger"]] creatures4 = [Creature.Creature(name) for name in ["Gargoyle", "Cyclops", "Gorgon", "Behemoth"]] creatures5 = [Creature.Creature(name) for name in ["Angel", "Angel", "Warlock", "Guardian"]] legion1 = Legion.Legion(player, "Rd01", creatures1, 1) legion2 = Legion.Legion(player, "Rd02", creatures2, 2) legion3 = Legion.Legion(player, "Rd03", creatures3, 3) legion4 = Legion.Legion(player, "Rd04", creatures4, 4) legion5 = Legion.Legion(player, "Rd05", creatures5, 4) for legion in [legion1, legion2, legion3, legion4, legion5]:
def cb_response(self, widget, response_id): self.destroy() if response_id == gtk.RESPONSE_OK: self.deferred.callback((self.old_legion, self.new_legion1, self.new_legion2)) else: self.deferred.callback((None, None, None)) if __name__ == "__main__": import time from slugathon.data import creaturedata from slugathon.game import Creature, Player, Game from slugathon.util import guiutils now = time.time() creatures = [Creature.Creature(name) for name in creaturedata.starting_creature_names] playername = "test" game = Game.Game("g1", playername, now, now, 2, 6) player = Player.Player(playername, game, 0) player.color = "Red" legion = Legion.Legion(player, "Rd01", creatures, 1) player.selected_markerid = "Rd02" splitlegion, def1 = new(playername, legion, None) def1.addCallback(guiutils.exit) splitlegion.connect("destroy", guiutils.exit) gtk.main()
isinstance(action, Action.StartManeuverBattlePhase) or isinstance(action, Action.StartStrikeBattlePhase) or isinstance(action, Action.StartCounterstrikeBattlePhase) or isinstance(action, Action.StartReinforceBattlePhase)): self._init_battle() if __name__ == "__main__": import time from slugathon.util import guiutils from slugathon.game import Game, Player, Creature from slugathon.data import creaturedata now = time.time() playername = "p1" creatures = Creature.n2c(creaturedata.starting_creature_names) game = Game.Game("g1", "Player 1", now, now, 2, 6) player1 = game.players[0] player1.assign_starting_tower(600) player1.assign_color("Red") player1.pick_marker("Rd01") player1.create_starting_legion() game.active_player = player1 player2 = Player.Player("Player 2", game, 1) player2.assign_starting_tower(500) player2.assign_color("Blue") player2.pick_marker("Bu02") player2.create_starting_legion() game.players.append(player2)
layout.set_text(str(self.creature.hits)) size = surface.get_width() layout.set_width(size) pctx.set_source_rgb(1, 0, 0) x = 0.5 * size y = 0.2 * size pctx.set_source_rgb(1, 1, 1) pctx.set_line_width(1) width, height = layout.get_pixel_size() pctx.rectangle(x - 0.5 * width, y, 0.9 * width, 0.8 * height) pctx.fill() pctx.set_source_rgb(1, 0, 0) pctx.move_to(x, y) pctx.show_layout(layout) if __name__ == "__main__": from slugathon.game import Creature creature = Creature.Creature("Ogre") creature.hits = 3 chit = Chit(creature, "Red", scale=45, rotate=90) window = gtk.Window() window.connect("destroy", gtk.main_quit) window.add(chit.event_box) window.show() chit.show() gtk.main()
eventbox = widget chit = eventbox.chit self.deferred.callback((self.legion, chit.combo)) self.destroy() def cb_cancel(self, widget, response_id): self.deferred.callback((self.legion, None)) self.destroy() if __name__ == "__main__": import time from slugathon.game import Legion, Player, Game from slugathon.util import guiutils creature_names = ["Titan", "Dragon", "Dragon", "Minotaur", "Minotaur"] creatures = Creature.n2c(creature_names) def my_callback((legion, creature)): logging.info("%s acquired %s", legion, creature) guiutils.exit() now = time.time() playername = "p0" game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player(playername, game, 0) player.color = "Red" legion = Legion.Legion(player, "Rd01", creatures, 1) legion.hexlabel = 1000 acquire_angel, def1 = new(playername, legion, 1, 1, game.caretaker, None) acquire_angel.connect("destroy", guiutils.exit) def1.addCallback(my_callback)
def test_score_move_scary_pursuer(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) game.add_player("p1") player0 = game.players[0] player1 = game.players[1] cleverbot = CleverBot.CleverBot("p1", 5) player0.assign_starting_tower(200) player1.assign_starting_tower(100) game.sort_players() game.started = True game.assign_color("p1", "Blue") game.assign_color("p0", "Red") game.assign_first_marker("p0", "Rd01") game.assign_first_marker("p1", "Bu01") player0.pick_marker("Rd02") player0.split_legion("Rd01", "Rd02", ["Titan", "Centaur", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Gargoyle"]) player0.done_with_splits() rd01 = player0.markerid_to_legion["Rd01"] player1.pick_marker("Bu02") player1.split_legion("Bu01", "Bu02", ["Titan", "Centaur", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Gargoyle"]) bu01 = player1.markerid_to_legion["Bu01"] bu02 = player1.markerid_to_legion["Bu02"] player0.done_with_splits() bu01.creatures.append(Creature.Creature("Ogre")) rd01.creatures.append(Creature.Creature("Colossus")) rd01.creatures.append(Creature.Creature("Colossus")) rd01.creatures.append(Creature.Creature("Colossus")) bu01.hexlabel = 41 bu02.hexlabel = 400 rd01.hexlabel = 100 # We ignore fear on turn 1, so set the turn to 2 to test. game.turn = 2 # staying in 41 gives us range 1 # moving to 42 gives us range 2 # moving to 1 gives us range 3 # moving to 2 gives us range 4 # moving to 3 gives us range 1 # moving to 4 gives us range 2 # moving to 5 gives us range 3 hexlabel_to_score = {} for hexlabel in [41, 42, 1, 2, 3, 4, 5]: hexlabel_to_score[hexlabel] = cleverbot._score_move( bu01, hexlabel, hexlabel != 41) print hexlabel_to_score assert hexlabel_to_score[42] > hexlabel_to_score[41] assert hexlabel_to_score[42] > hexlabel_to_score[3] assert hexlabel_to_score[1] > hexlabel_to_score[42] assert hexlabel_to_score[1] > hexlabel_to_score[4] assert hexlabel_to_score[2] > hexlabel_to_score[1] assert hexlabel_to_score[2] > hexlabel_to_score[5] assert hexlabel_to_score[4] > hexlabel_to_score[41] assert hexlabel_to_score[4] > hexlabel_to_score[3] assert hexlabel_to_score[5] > hexlabel_to_score[42] assert hexlabel_to_score[5] > hexlabel_to_score[4]
def test_score_legion_move_swamp(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) game.add_player("p1") player0 = game.players[0] player1 = game.players[1] player0.assign_starting_tower(200) player1.assign_starting_tower(100) game.sort_players() game.started = True game.assign_color("p1", "Blue") game.assign_color("p0", "Red") game.assign_first_marker("p0", "Rd01") game.assign_first_marker("p1", "Bu01") player0.pick_marker("Rd02") player0.split_legion("Rd01", "Rd02", ["Titan", "Ogre", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Centaur", "Gargoyle"]) rd01 = player0.markerid_to_legion["Rd01"] player1.pick_marker("Bu02") player1.split_legion("Bu01", "Bu02", ["Titan", "Centaur", "Gargoyle", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Ogre"]) bu01 = player1.markerid_to_legion["Bu01"] rd01.creatures.append(Creature.Creature("Troll")) rd01.creatures.append(Creature.Creature("Troll")) rd01.creatures.append(Creature.Creature("Troll")) bu01.creatures.remove(Creature.Creature("Centaur")) bu01.creatures.append(Creature.Creature("Warlock")) bu01.creatures.append(Creature.Creature("Warlock")) bu01.creatures.append(Creature.Creature("Cyclops")) bu01.creatures.append(Creature.Creature("Cyclops")) rd01.move(132, False, None, 1) bu01.move(132, False, None, 1) game._init_battle(bu01, rd01) defender = game.defender_legion attacker = game.attacker_legion d_titan = defender.creatures[0] d_ogre1 = defender.creatures[1] d_ogre2 = defender.creatures[2] d_gargoyle = defender.creatures[3] d_troll1 = defender.creatures[4] d_troll2 = defender.creatures[5] d_troll3 = defender.creatures[6] for creature in defender.creatures: creature.legion = defender for creature in attacker.creatures: creature.legion = attacker cleverbot_d = CleverBot.CleverBot("p0", 1) hexlabel = d_ogre1.hexlabel move_to_score = {} moves = game.find_battle_moves(d_ogre1) for move in moves: d_ogre1.move(move) score = cleverbot_d._score_legion_move(game, [d_ogre1]) move_to_score[move] = score d_ogre1.move(hexlabel) # Should prefer back rank to second rank for hexlabel1 in ["A1", "A1", "A3"]: for hexlabel2 in ["B1", "B2", "B3", "B4"]: assert move_to_score[hexlabel1] > move_to_score[hexlabel2] hexlabel = d_troll1.hexlabel move_to_score = {} moves = game.find_battle_moves(d_troll1) for move in moves: d_troll1.move(move) score = cleverbot_d._score_legion_move(game, [d_troll1]) move_to_score[move] = score d_troll1.move(hexlabel) # Should prefer back rank to second rank for hexlabel1 in ["A1", "A1", "A3"]: for hexlabel2 in ["B1", "B2", "B3", "B4"]: assert move_to_score[hexlabel1] > move_to_score[hexlabel2] hexlabel = d_gargoyle.hexlabel move_to_score = {} moves = game.find_battle_moves(d_gargoyle) for move in moves: d_gargoyle.move(move) score = cleverbot_d._score_legion_move(game, [d_gargoyle]) move_to_score[move] = score d_gargoyle.move(hexlabel) # Should prefer back rank to second rank to third rank for hexlabel1 in ["A1", "A1", "A3"]: for hexlabel2 in ["B1", "B3", "B4"]: for hexlabel3 in ["C1", "C3"]: assert (move_to_score[hexlabel1] > move_to_score[hexlabel2] > move_to_score[hexlabel3]) hexlabel = d_titan.hexlabel move_to_score = {} moves = game.find_battle_moves(d_titan) for move in moves: d_titan.move(move) score = cleverbot_d._score_legion_move(game, [d_titan]) move_to_score[move] = score d_titan.move(hexlabel) # Should prefer back rank to second rank to third rank to fourth rank for hexlabel1 in ["A1", "A1", "A3"]: for hexlabel2 in ["B1", "B3", "B4"]: for hexlabel3 in ["C1", "C3"]: for hexlabel4 in ["D2", "D4"]: assert (move_to_score[hexlabel1] > move_to_score[hexlabel2] > move_to_score[hexlabel3] > move_to_score[hexlabel4]) d_troll1.move("B2") d_troll2.move("B4") d_ogre1.move("B1") d_gargoyle.move("B3") d_titan.move("A3") d_troll3.move("A2") d_ogre2.move("A1") cleverbot_a = CleverBot.CleverBot("p1", 1) game.battle_active_legion = attacker game.battle_phase = Phase.STRIKE a_titan = attacker.creatures[0] a_gargoyle1 = attacker.creatures[1] a_gargoyle2 = attacker.creatures[2] a_warlock1 = attacker.creatures[3] a_warlock2 = attacker.creatures[4] a_cyclops1 = attacker.creatures[5] a_cyclops2 = attacker.creatures[6] hexlabel = a_titan.hexlabel move_to_score = {} moves = game.find_battle_moves(a_titan) for move in moves: a_titan.move(move) score = cleverbot_a._score_legion_move(game, [a_titan]) move_to_score[move] = score a_titan.move(hexlabel) # Should prefer back rank to second rank to third rank to fourth rank for hexlabel1 in ["F1", "F3", "F4"]: for hexlabel2 in ["E1", "E2", "E3", "E5"]: for hexlabel3 in ["D2", "D4", "D5", "D6"]: for hexlabel4 in ["C1", "C3"]: assert (move_to_score[hexlabel1] > move_to_score[hexlabel2] > move_to_score[hexlabel3] > move_to_score[hexlabel4]) hexlabel = a_gargoyle1.hexlabel move_to_score = {} moves = game.find_battle_moves(a_gargoyle1) for move in moves: a_gargoyle1.move(move) score = cleverbot_a._score_legion_move(game, [a_gargoyle1]) move_to_score[move] = score a_gargoyle1.move(hexlabel) # Should prefer third rank to second rank to back rank for hexlabel1 in ["F1", "F3", "F4"]: for hexlabel2 in ["E1", "E2", "E3", "E5"]: for hexlabel3 in ["D2", "D4", "D5", "D6"]: assert (move_to_score[hexlabel3] > move_to_score[hexlabel2] > move_to_score[hexlabel1]) hexlabel = a_cyclops1.hexlabel move_to_score = {} moves = game.find_battle_moves(a_cyclops1) for move in moves: a_cyclops1.move(move) score = cleverbot_a._score_legion_move(game, [a_cyclops1]) move_to_score[move] = score a_cyclops1.move(hexlabel) # Should prefer third rank to second rank to back rank for hexlabel1 in ["F1", "F3", "F4"]: for hexlabel2 in ["E1", "E2", "E3", "E5"]: assert move_to_score[hexlabel2] > move_to_score[hexlabel1] hexlabel = a_warlock1.hexlabel move_to_score = {} moves = game.find_battle_moves(a_warlock1) for move in moves: a_warlock1.move(move) score = cleverbot_a._score_legion_move(game, [a_warlock1]) move_to_score[move] = score a_warlock1.move(hexlabel) # Should prefer third rank to second rank to back rank for hexlabel1 in ["F1", "F3", "F4"]: for hexlabel2 in ["E1", "E2", "E3", "E5"]: assert move_to_score[hexlabel2] > move_to_score[hexlabel1] # Should prefer rangestrike to 1:2 melee assert move_to_score["D4"] > move_to_score["C3"] # Should prefer rangestrike to 1:1 melee assert move_to_score["D2"] > move_to_score["C1"] a_warlock1.move("C1") a_warlock2.move("C3") a_gargoyle1.move("D4") a_gargoyle2.move("D5") a_cyclops1.move("E5") a_cyclops2.move("E2") a_titan.move("F4")
def test_score_legion_move_plain(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) game.add_player("p1") player0 = game.players[0] player1 = game.players[1] player0.assign_starting_tower(200) player1.assign_starting_tower(100) game.sort_players() game.started = True game.assign_color("p1", "Blue") game.assign_color("p0", "Red") game.assign_first_marker("p0", "Rd01") game.assign_first_marker("p1", "Bu01") player0.pick_marker("Rd02") player0.split_legion("Rd01", "Rd02", ["Titan", "Centaur", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Gargoyle"]) rd01 = player0.markerid_to_legion["Rd01"] player1.pick_marker("Bu02") player1.split_legion("Bu01", "Bu02", ["Titan", "Centaur", "Ogre", "Gargoyle"], ["Angel", "Centaur", "Ogre", "Gargoyle"]) bu01 = player1.markerid_to_legion["Bu01"] rd01.creatures.append(Creature.Creature("Ranger")) rd01.creatures.append(Creature.Creature("Gorgon")) bu01.creatures.append(Creature.Creature("Ranger")) bu01.creatures.append(Creature.Creature("Gorgon")) rd01.move(101, False, None, 5) bu01.move(101, False, None, 5) game._init_battle(bu01, rd01) defender = game.defender_legion attacker = game.attacker_legion titan1 = defender.creatures[0] ogre1 = defender.creatures[1] centaur1 = defender.creatures[2] gargoyle1 = defender.creatures[3] ranger1 = defender.creatures[4] gorgon1 = defender.creatures[5] for creature in defender.creatures: creature.legion = defender for creature in attacker.creatures: creature.legion = attacker cleverbot_d = CleverBot.CleverBot("p0", 1) hexlabel = ogre1.hexlabel move_to_score = {} moves = game.find_battle_moves(ogre1) for move in moves: ogre1.move(move) score = cleverbot_d._score_legion_move(game, [ogre1]) move_to_score[move] = score ogre1.move(hexlabel) # Should prefer back rank to second rank assert move_to_score["E5"] > move_to_score["C5"] assert move_to_score["E5"] > move_to_score["E4"] hexlabel = gargoyle1.hexlabel move_to_score = {} moves = game.find_battle_moves(gargoyle1) print "ogre1 moves", moves for move in moves: gargoyle1.move(move) score = cleverbot_d._score_legion_move(game, [gargoyle1]) move_to_score[move] = score gargoyle1.move(hexlabel) # Should prefer back rank to second rank assert move_to_score["E5"] > move_to_score["C5"] assert move_to_score["F4"] > move_to_score["D5"] # Should prefer second rank to third rank assert move_to_score["E4"] > move_to_score["D4"] assert move_to_score["D5"] > move_to_score["C4"] ranger1.move("C5") gorgon1.move("D5") ogre1.move("E4") titan1.move("D6") centaur1.move("E5") gargoyle1.move("F4") cleverbot_a = CleverBot.CleverBot("p1", 1) game.battle_active_legion = attacker game.battle_phase = Phase.STRIKE titan2 = attacker.sorted_creatures[0] gorgon2 = attacker.sorted_creatures[1] ranger2 = attacker.sorted_creatures[2] gargoyle2 = attacker.sorted_creatures[3] centaur2 = attacker.sorted_creatures[4] ogre2 = attacker.sorted_creatures[5] hexlabel = titan2.hexlabel move_to_score = {} moves = game.find_battle_moves(titan2) for move in moves: titan2.move(move) score = cleverbot_a._score_legion_move(game, [titan2]) move_to_score[move] = score titan2.move(hexlabel) # Should prefer back rank to second rank assert move_to_score["A1"] > move_to_score["A2"] assert move_to_score["D1"] > move_to_score["D2"] # Should prefer second rank to third rank assert move_to_score["C2"] > move_to_score["D3"] # Should prefer third rank to fourth rank assert move_to_score["D3"] > move_to_score["B4"] hexlabel = ranger2.hexlabel move_to_score = {} moves = game.find_battle_moves(ranger2) for move in moves: ranger2.move(move) score = cleverbot_a._score_legion_move(game, [ranger2]) move_to_score[move] = score ranger2.move(hexlabel) # Should prefer second rank to back rank assert move_to_score["A2"] > move_to_score["A1"] assert move_to_score["D2"] > move_to_score["D1"] # Should prefer rangestrike to melee assert move_to_score["A3"] > move_to_score["B4"] assert move_to_score["B3"] > move_to_score["B4"] assert move_to_score["C3"] > move_to_score["B4"] assert move_to_score["D3"] > move_to_score["B4"] assert move_to_score["E2"] > move_to_score["B4"] # Should prefer 1-on-1 to 1-on-2 assert move_to_score["B4"] > move_to_score["C4"] assert move_to_score["E3"] > move_to_score["C4"] assert move_to_score["E3"] > move_to_score["D4"] # Should prefer 1-on-1 with advantage to even 1-on-1. assert move_to_score["E3"] > move_to_score["B4"] hexlabel = gorgon2.hexlabel move_to_score = {} moves = game.find_battle_moves(gorgon2) for move in moves: gorgon2.move(move) score = cleverbot_a._score_legion_move(game, [gorgon2]) move_to_score[move] = score gorgon2.move(hexlabel) # Should prefer second rank to back rank assert move_to_score["D2"] > move_to_score["D1"] # Should prefer third rank to second rank assert move_to_score["D3"] > move_to_score["C2"] # Should prefer rangestrike opportunity to none assert move_to_score["A3"] > move_to_score["F1"] assert move_to_score["B3"] > move_to_score["F1"] assert move_to_score["C3"] > move_to_score["F1"] assert move_to_score["D3"] > move_to_score["F1"] assert move_to_score["E2"] > move_to_score["F1"] gorgon2.move("A3") ranger2.move("B3") hexlabel = centaur2.hexlabel move_to_score = {} moves = game.find_battle_moves(centaur2) for move in moves: centaur2.move(move) score = cleverbot_a._score_legion_move(game, [centaur2]) move_to_score[move] = score centaur2.move(hexlabel) # Should prefer being next to allies assert move_to_score["C3"] > move_to_score["D3"] centaur2.move("C3") hexlabel = gargoyle2.hexlabel move_to_score = {} moves = game.find_battle_moves(gargoyle2) for move in moves: gargoyle2.move(move) score = cleverbot_a._score_legion_move(game, [gargoyle2]) move_to_score[move] = score gargoyle2.move("D3") hexlabel = ogre2.hexlabel move_to_score = {} moves = game.find_battle_moves(ogre2) for move in moves: ogre2.move(move) score = cleverbot_a._score_legion_move(game, [ogre2]) move_to_score[move] = score ogre2.move(hexlabel) # Should prefer being up next to allies assert move_to_score["A2"] == max(move_to_score.itervalues()) ogre2.move("A2") hexlabel = titan2.hexlabel titan2.moved = False move_to_score = {} moves = game.find_battle_moves(titan2) for move in moves: titan2.move(move) score = cleverbot_a._score_legion_move(game, [titan2]) move_to_score[move] = score titan2.move(hexlabel) # Should prefer hiding in back behind the ogre print move_to_score assert move_to_score["A1"] == max(move_to_score.itervalues()) titan2.move("A1")
def available_recruits_and_recruiters(self, mterrain, caretaker): """Return a list of tuples with creature names and recruiters that this legion could recruit in a masterhex with terrain type mterrain, if it moved there. Each tuple will contain the recruit as its first element, and the recruiters (if any) as its remaining elements. The list is sorted in the same order as within recruitdata. """ result_list = [] counts = bag(self.living_creature_names) recruits = recruitdata.data[mterrain] for sublist in self._gen_sublists(recruits): names = [tup[0] for tup in sublist] nums = [tup[1] for tup in sublist] for ii in xrange(len(sublist)): name = names[ii] num = nums[ii] if ii >= 1: prev = names[ii - 1] else: prev = None if prev == recruitdata.ANYTHING: # basic tower creature for jj in xrange(ii + 1): if nums[jj] and caretaker.counts.get(names[jj]): result_list.append((names[jj], )) else: if (prev == recruitdata.CREATURE and self._max_creatures_of_one_type() >= num): # guardian recruiters = [] for name2, num2 in counts.iteritems(): if (num2 >= num and Creature.Creature(name2).is_creature): recruiters.append(name2) for jj in xrange(ii + 1): if nums[jj] and caretaker.counts.get(names[jj]): for recruiter in recruiters: li = [names[jj]] for kk in xrange(num): li.append(recruiter) tup = tuple(li) result_list.append(tup) if counts[prev] >= num: # recruit up if num and caretaker.counts.get(name): li = [name] for kk in xrange(num): li.append(prev) tup = tuple(li) result_list.append(tup) if counts[name] and num: # recruit same or down for jj in xrange(ii + 1): if nums[jj] and caretaker.counts.get(names[jj]): result_list.append((names[jj], name)) def cmp_helper(tup1, tup2): ii = 0 while True: if len(tup1) < ii + 1: return -1 if len(tup2) < ii + 1: return 1 if tup1[ii] != tup2[ii]: c1 = Creature.Creature(tup1[ii]) c2 = Creature.Creature(tup2[ii]) diff = 100 * (c1.sort_value - c2.sort_value) if diff != 0: return int(diff) ii += 1 result_list.sort(cmp=cmp_helper) return result_list
def test_score(): creature = Creature.Creature("Ogre") assert creature.score == 12 creature = Creature.Creature("Colossus") assert creature.score == 40
def test_available_recruits_and_recruiters(): now = time.time() game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player("p0", game, 0) legion = Legion.Legion( player, "Rd01", Creature.n2c(["Titan", "Gargoyle", "Centaur", "Centaur"]), 1) caretaker = Caretaker.Caretaker() assert legion.available_recruits_and_recruiters("Marsh", caretaker) == [] assert legion.available_recruits_and_recruiters("Desert", caretaker) == [] assert legion.available_recruits_and_recruiters("Plains", caretaker) == [ ("Centaur", "Centaur"), ("Lion", "Centaur", "Centaur") ] assert legion.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Gargoyle") ] assert legion.available_recruits_and_recruiters("Tower", caretaker) == [ ("Ogre", ), ("Centaur", ), ("Gargoyle", ), ("Warlock", "Titan") ] caretaker.counts["Centaur"] = 0 assert legion.available_recruits_and_recruiters("Plains", caretaker) == [ ("Lion", "Centaur", "Centaur") ] legion2 = Legion.Legion( player, "Rd02", Creature.n2c(["Titan", "Gargoyle", "Gargoyle", "Gargoyle"]), 1) assert legion2.available_recruits_and_recruiters("Tower", caretaker) == [ ("Ogre", ), ("Gargoyle", ), ("Warlock", "Titan"), ("Guardian", "Gargoyle", "Gargoyle", "Gargoyle") ] assert legion2.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Gargoyle"), ("Cyclops", "Gargoyle", "Gargoyle") ] legion3 = Legion.Legion(player, "Rd03", Creature.n2c(["Colossus"]), 1) assert legion3.available_recruits_and_recruiters("Tundra", caretaker) == [ ("Troll", "Colossus"), ("Warbear", "Colossus"), ("Giant", "Colossus"), ("Colossus", "Colossus") ] assert legion3.available_recruits_and_recruiters( "Mountains", caretaker) == [("Lion", "Colossus"), ("Minotaur", "Colossus"), ("Dragon", "Colossus"), ("Colossus", "Colossus")] assert legion3.available_recruits_and_recruiters("Marsh", caretaker) == [] legion4 = Legion.Legion( player, "Rd04", Creature.n2c(["Behemoth", "Cyclops", "Cyclops", "Cyclops"]), 1) assert legion4.available_recruits_and_recruiters("Brush", caretaker) == [ ("Gargoyle", "Cyclops"), ("Cyclops", "Cyclops"), ("Gorgon", "Cyclops", "Cyclops") ] logging.info(legion4.available_recruits_and_recruiters( "Jungle", caretaker)) assert legion4.available_recruits_and_recruiters("Jungle", caretaker) == [ ("Gargoyle", "Cyclops"), ("Gargoyle", "Behemoth"), ("Cyclops", "Cyclops"), ("Cyclops", "Behemoth"), ("Behemoth", "Cyclops", "Cyclops", "Cyclops"), ("Behemoth", "Behemoth"), ]
chit.recruiter_names)) self.destroy() def cb_cancel(self, widget, response_id): """The cancel button was pressed, so exit""" self.deferred.callback((self.legion, None, None)) self.destroy() if __name__ == "__main__": import time from slugathon.game import Legion, Player, Game from slugathon.util import guiutils creature_names = ["Titan", "Dragon", "Dragon", "Minotaur", "Minotaur"] creatures = Creature.n2c(creature_names) def my_callback((legion, creature, recruiter_names)): logging.info("%s recruited %s %s", legion, creature, recruiter_names) guiutils.exit() now = time.time() playername = "p0" game = Game.Game("g1", "p0", now, now, 2, 6) player = Player.Player(playername, game, 0) player.color = "Red" legion = Legion.Legion(player, "Rd01", creatures, 1) legion.hexlabel = 1000 masterhex = game.board.hexes[legion.hexlabel] mterrain = masterhex.terrain pickrecruit, def1 = new(playername, legion, mterrain, game.caretaker, None)
if __name__ == "__main__": import time from slugathon.game import Creature, Legion, Player, Game now = time.time() attacker_playername = "Roar!" game = Game.Game("g1", attacker_playername, now, now, 2, 6) attacker_player = Player.Player(attacker_playername, game, 0) attacker_player.color = "Black" attacker_creature_names = [ "Titan", "Colossus", "Serpent", "Hydra", "Archangel", "Angel", "Unicorn" ] attacker_creatures = Creature.n2c(attacker_creature_names) attacker_legion = Legion.Legion(attacker_player, "Bk01", attacker_creatures, 1) defender_playername = "Eek!" defender_player = Player.Player(defender_playername, game, 0) defender_player.color = "Gold" defender_creature_names = ["Ogre", "Centaur", "Gargoyle"] defender_creatures = Creature.n2c(defender_creature_names) defender_legion = Legion.Legion(defender_player, "Rd01", defender_creatures, 1) def my_callback((attacker, defender, fled)): logging.info("fled is %s", fled) reactor.stop()
if __name__ == "__main__": import time from slugathon.game import Creature, Legion, Player, Game now = time.time() game_name = "Game1" attacker_playername = "Roar!" game = Game.Game("g1", attacker_playername, now, now, 2, 6) attacker_player = Player.Player(attacker_playername, game, 0) attacker_player.color = "Black" attacker_creature_names = ["Titan", "Colossus", "Serpent", "Hydra", "Archangel", "Angel", "Unicorn"] attacker_creatures = Creature.n2c(attacker_creature_names) attacker_legion = Legion.Legion(attacker_player, "Bk01", attacker_creatures, 1) defender_playername = "Eek!" defender_player = Player.Player(defender_playername, game, 0) defender_player.color = "Gold" defender_creature_names = ["Ogre", "Centaur", "Gargoyle"] defender_creatures = Creature.n2c(defender_creature_names) defender_legion = Legion.Legion(defender_player, "Rd01", defender_creatures, 1) def my_callback(*args): logging.info("callback %s", args) reactor.stop()