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 forget_creatures(self):
"""Make all creatures Unknown."""
self.creatures = Creature.n2c(len(self) * ["Unknown"])
for creature in self.creatures:
creature.legion = self
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()
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)
