Exemple #1
0
    def __init__(self, playername, legion, def1, parent):
        gtk.Dialog.__init__(self, "SplitLegion - %s" % playername, parent)
        self.old_legion = legion
        player = legion.player
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label("Splitting legion %s (%s) in hex %s" % (
                                legion.markerid,
                                legion.picname,
                                legion.hexlabel))
        self.vbox.pack_start(legion_name)

        old_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(old_hbox)
        old_marker_hbox = gtk.HBox()
        old_hbox.pack_start(old_marker_hbox, expand=False)
        self.old_chits_hbox = gtk.HBox()
        old_hbox.pack_start(self.old_chits_hbox, expand=True)

        new_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(new_hbox)
        new_marker_hbox = gtk.HBox()
        new_hbox.pack_start(new_marker_hbox, expand=False)
        self.new_chits_hbox = gtk.HBox()
        new_hbox.pack_start(self.new_chits_hbox, expand=True)

        old_marker = Marker.Marker(legion, False, scale=20)
        old_marker_hbox.pack_start(old_marker.event_box, expand=False)

        self.new_legion1 = Legion.Legion(player, legion.markerid,
                                         legion.sorted_creatures,
                                         legion.hexlabel)
        self.new_legion2 = Legion.Legion(player, player.selected_markerid,
                                         [], legion.hexlabel)
        self.new_marker = Marker.Marker(self.new_legion2, False, scale=20)
        new_marker_hbox.pack_start(self.new_marker.event_box, expand=False)

        for creature in legion.sorted_creatures:
            chit = Chit.Chit(creature, player.color, scale=20)
            self.old_chits_hbox.pack_start(chit.event_box, expand=False,
                                           fill=False)
            chit.connect("button-press-event", self.cb_click)

        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)
        self.ok_button = self.add_button("gtk-ok", gtk.RESPONSE_OK)
        self.ok_button.set_sensitive(False)
        self.connect("response", self.cb_response)

        self.show_all()
    def __init__(self, playername, legion, def1, parent):
        gtk.Dialog.__init__(self, "PickTeleportingLord - %s" % playername,
                            parent)
        self.legion = legion
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        top_label = gtk.Label("Revealing a lord to tower teleport")
        self.vbox.pack_start(top_label)

        bottom_label = gtk.Label("Click on a lord (red outline) to reveal it.")
        self.vbox.pack_start(bottom_label)

        hbox = gtk.HBox(spacing=3)
        self.vbox.pack_start(hbox)
        marker = Marker.Marker(legion, False, scale=20)
        hbox.pack_start(marker.event_box, expand=False)
        player = self.legion.player
        for creature in legion.sorted_creatures:
            chit = Chit.Chit(creature,
                             player.color,
                             scale=20,
                             outlined=creature.is_lord)
            hbox.pack_start(chit.event_box, expand=False)
            if creature.is_lord:
                chit.connect("button-press-event", self.cb_click)

        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)
        self.connect("response", self.cb_cancel)

        self.show_all()
Exemple #3
0
 def __init__(self, attacker, defender, game, scale):
     gtk.DrawingArea.__init__(self)
     self.attacker = attacker
     self.defender = defender
     self.game = game
     self.scale = scale
     self.set_size_request(self.compute_width(), self.compute_height())
     marker_scale = int(round(0.5 * self.scale))
     self.attacker_marker = Marker.Marker(attacker,
                                          False,
                                          scale=marker_scale)
     self.defender_marker = Marker.Marker(defender,
                                          False,
                                          scale=marker_scale)
     self.battle_turn = 1
     self.active_marker = self.defender_marker
     self.connect("expose-event", self.cb_area_expose)
     self.show_all()
Exemple #4
0
    def __init__(self, playername, legion, num_archangels, num_angels,
                 caretaker, def1, parent):
        gtk.Dialog.__init__(self, "AcquireAngels - %s" % playername, parent)
        self.deferred = def1
        self.legion = legion
        player = legion.player

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label("Acquire angel for legion %s (%s) in hex %s" %
                                (legion.markerid, legion.picname,
                                 legion.hexlabel))
        self.vbox.pack_start(legion_name)

        legion_hbox = gtk.HBox(spacing=3)
        self.vbox.pack_start(legion_hbox)

        marker_hbox = gtk.HBox()
        legion_hbox.pack_start(marker_hbox, expand=False)

        marker = Marker.Marker(legion, True, scale=20)
        marker_hbox.pack_start(marker.event_box, expand=False)

        chits_hbox = gtk.HBox(spacing=3)
        legion_hbox.pack_start(chits_hbox, expand=True)

        for creature in legion.sorted_living_creatures:
            chit = Chit.Chit(creature, player.color, scale=20)
            chits_hbox.pack_start(chit.event_box, expand=False)

        angel_combos = find_angel_combos(num_archangels,
                                         num_angels,
                                         caretaker.num_left("Archangel"),
                                         caretaker.num_left("Angel"))
        max_len = max(len(combo) for combo in angel_combos)
        leading_spaces = (len(legion) + 2 - max_len) // 2
        for combo in angel_combos:
            hbox = gtk.HBox(spacing=3, homogeneous=False)
            self.vbox.pack_start(hbox)
            for unused in xrange(leading_spaces):
                chit = Chit.Chit(None, player.color, scale=20, name="Nothing")
                chit.combo = combo
                hbox.pack_start(chit.event_box, expand=False)
                chit.connect("button-press-event", self.cb_click)
            for angel in combo:
                chit = Chit.Chit(angel, player.color, scale=20)
                chit.combo = combo
                hbox.pack_start(chit.event_box, expand=False)
                chit.connect("button-press-event", self.cb_click)

        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)
        self.connect("response", self.cb_cancel)

        self.show_all()
Exemple #5
0
    def __init__(self, legion):
        gtk.EventBox.__init__(self)

        self.legion = legion

        hbox = gtk.HBox(spacing=3)
        self.add(hbox)

        self.marker_hbox = gtk.HBox(spacing=3)
        hbox.pack_start(self.marker_hbox, expand=False)
        self.marker = Marker.Marker(legion, True, scale=15)
        self.marker_hbox.pack_start(self.marker.event_box, expand=False)

        self.chits_hbox = gtk.HBox(spacing=3)
        hbox.pack_start(self.chits_hbox, expand=True)
        gtkcolor = gtk.gdk.color_parse("white")
        self.modify_bg(gtk.STATE_NORMAL, gtkcolor)

        self.show_all()
Exemple #6
0
    def show_legion(self, legion):
        self.legion_name.set_text(
            "Legion %s (%s) in hex %s (%d%s points)" %
            (legion.markerid, legion.picname, legion.hexlabel, legion.score,
             "+?" if legion.any_unknown else ""))

        for hbox in [self.marker_hbox, self.chits_hbox]:
            for child in hbox.get_children():
                hbox.remove(child)

        self.marker = Marker.Marker(legion, True, scale=15)
        self.marker_hbox.pack_start(self.marker.event_box, expand=False)

        playercolor = legion.player.color
        for creature in legion.sorted_living_creatures:
            chit = Chit.Chit(creature, playercolor, scale=15)
            self.chits_hbox.pack_start(chit.event_box, expand=False)

        self.show_all()
Exemple #7
0
    def __init__(self, playername, legion, hexlabel, def1, parent):
        gtk.Dialog.__init__(self, "PickMoveType - %s" % playername, parent)
        self.deferred = def1
        self.legion = legion
        player = legion.player

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label(
            "Pick move type for legion %s (%s) in hex %s moving to hex %s" %
            (legion.markerid, legion.picname, legion.hexlabel, hexlabel))
        self.vbox.pack_start(legion_name)

        legion_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(legion_hbox)

        marker_hbox = gtk.HBox()
        legion_hbox.pack_start(marker_hbox)

        marker = Marker.Marker(legion, True, scale=20)
        marker_hbox.pack_start(marker.event_box, expand=False)

        chits_hbox = gtk.HBox(spacing=3)
        legion_hbox.pack_start(chits_hbox)

        for creature in legion.sorted_living_creatures:
            chit = Chit.Chit(creature, player.color, scale=20)
            chits_hbox.pack_start(chit.event_box, expand=False)

        button_hbox = gtk.HBox(homogeneous=True)
        self.vbox.pack_start(button_hbox)

        self.add_button("Teleport", TELEPORT)
        self.add_button("Move normally", NORMAL_MOVE)
        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)

        self.connect("response", self.cb_response)

        self.show_all()
Exemple #8
0
    def __init__(self, playername, legion, def1, parent):
        gtk.Dialog.__init__(self, "SummonAngel - %s" % playername, parent)
        self.legion = legion
        player = legion.player
        self.deferred = def1
        self.donor = None
        self.summonable = None

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)

        top_label = gtk.Label(
            "Summoning an angel into legion %s (%s) in hex %s"
            % (legion.markerid, legion.picname, legion.hexlabel))
        self.vbox.set_spacing(9)
        self.vbox.pack_start(top_label)
        middle_label = gtk.Label("Summonable creatures have a red border")
        self.vbox.pack_start(middle_label)
        bottom_label = gtk.Label("Click one to summon it.")
        self.vbox.pack_start(bottom_label)

        for legion2 in player.legions:
            if (legion2.any_summonable and not legion2.engaged and
                    legion2 != legion):
                hbox = gtk.HBox(spacing=3)
                self.vbox.pack_start(hbox)
                marker = Marker.Marker(legion2, False, scale=20)
                hbox.pack_start(marker.event_box, expand=False, fill=False)
                for creature in legion2.sorted_creatures:
                    chit = Chit.Chit(creature, player.color, scale=20,
                                     outlined=creature.summonable)
                    hbox.pack_start(chit.event_box, expand=False, fill=False)
                    if creature.summonable:
                        chit.connect("button-press-event", self.cb_click)

        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)
        self.connect("response", self.cb_cancel)

        self.show_all()
Exemple #9
0
    def __init__(self, playername, legion, mterrain, caretaker, def1, parent):
        gtk.Dialog.__init__(self, "PickRecruit - %s" % playername, parent)
        self.legion = legion
        player = legion.player
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label(
            "Pick recruit for legion %s (%s) in hex %s" %
            (legion.markerid, legion.picname, legion.hexlabel))
        self.vbox.pack_start(legion_name)

        legion_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(legion_hbox)

        marker_hbox = gtk.HBox()
        legion_hbox.pack_start(marker_hbox, expand=False)

        chits_hbox = gtk.HBox(spacing=3)
        legion_hbox.pack_start(chits_hbox, expand=False)

        marker = Marker.Marker(legion, True, scale=20)
        marker_hbox.pack_start(marker.event_box, expand=False, fill=False)

        for creature in legion.sorted_living_creatures:
            chit = Chit.Chit(creature, player.color, scale=20)
            chits_hbox.pack_start(chit.event_box, expand=False)

        recruit_tups = legion.available_recruits_and_recruiters(
            mterrain, caretaker)
        max_len = max(len(tup) for tup in recruit_tups)
        for tup in recruit_tups:
            hbox = gtk.HBox()
            self.vbox.pack_start(hbox)
            recruit_name = tup[0]
            recruit = Creature.Creature(recruit_name)
            recruiter_names = tup[1:]
            li = list(tup)
            li.reverse()
            while len(li) < max_len:
                li.insert(-1, "Nothing")
            li.insert(-1, "RightArrow")
            for ii, name in enumerate(li):
                if name in ["RightArrow", "Nothing"]:
                    chit = Chit.Chit(None, player.color, scale=20, name=name)
                else:
                    creature = Creature.Creature(name)
                    chit = Chit.Chit(creature, player.color, scale=20)
                chit.recruit = recruit
                chit.recruiter_names = recruiter_names
                if ii < len(li) - 2:
                    hbox.pack_start(chit.event_box, expand=False)
                elif ii == len(li) - 2:
                    hbox.pack_start(chit.event_box, expand=True)
                else:
                    hbox.pack_end(chit.event_box, expand=False)
                chit.connect("button-press-event", self.cb_click)
            label = gtk.Label(caretaker.num_left(creature.name))
            hbox.pack_end(label, expand=False)

        self.add_button("gtk-cancel", gtk.RESPONSE_CANCEL)
        self.connect("response", self.cb_cancel)
        self.show_all()
Exemple #10
0
    def __init__(self, playername, attacker_legion, defender_legion, def1,
                 parent):
        gtk.Dialog.__init__(self, "Flee - %s" % (playername), parent)
        self.attacker_legion = attacker_legion
        self.defender_legion = defender_legion
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)

        self.vbox.set_spacing(9)

        hexlabel = defender_legion.hexlabel
        masterhex = defender_legion.player.game.board.hexes[hexlabel]
        self.legion_name = gtk.Label(
            "Flee with legion %s (%s) in %s hex %s?" %
            (defender_legion.markerid, defender_legion.picname,
             masterhex.terrain, hexlabel))
        self.vbox.pack_start(self.legion_name)

        self.attacker_hbox = gtk.HBox(False, 15)
        self.vbox.pack_start(self.attacker_hbox)

        self.attacker_marker = Marker.Marker(attacker_legion, True, scale=20)
        self.attacker_hbox.pack_start(self.attacker_marker.event_box,
                                      expand=False,
                                      fill=False)

        self.attacker_score_label = gtk.Label("%d\npoints" %
                                              attacker_legion.score)
        self.attacker_hbox.pack_start(self.attacker_score_label, expand=False)

        self.attacker_chits_hbox = gtk.HBox(False, 3)
        self.attacker_hbox.pack_start(self.attacker_chits_hbox,
                                      expand=True,
                                      fill=True)
        for creature in attacker_legion.sorted_creatures:
            chit = Chit.Chit(creature, attacker_legion.player.color, scale=20)
            chit.show()
            self.attacker_chits_hbox.pack_start(chit.event_box, expand=False)

        self.defender_hbox = gtk.HBox(False, 15)
        self.vbox.pack_start(self.defender_hbox)

        self.defender_marker = Marker.Marker(defender_legion, True, scale=20)
        self.defender_hbox.pack_start(self.defender_marker.event_box,
                                      expand=False,
                                      fill=False)

        self.defender_score_label = gtk.Label("%d\npoints" %
                                              defender_legion.score)
        self.defender_hbox.pack_start(self.defender_score_label, expand=False)

        self.defender_chits_hbox = gtk.HBox(False, 3)
        self.defender_hbox.pack_start(self.defender_chits_hbox,
                                      expand=True,
                                      fill=True)
        for creature in defender_legion.sorted_creatures:
            chit = Chit.Chit(creature, defender_legion.player.color, scale=20)
            chit.show()
            self.defender_chits_hbox.pack_start(chit.event_box, expand=False)

        self.add_button("Do Not Flee", DO_NOT_FLEE)
        self.add_button("Flee", FLEE)

        self.connect("response", self.cb_response)
        self.show_all()
Exemple #11
0
    def __init__(self, playername, attacker_legion, defender_legion,
                 def1, parent):
        gtk.Dialog.__init__(self, "Negotiate - %s" % playername, parent)
        self.attacker_legion = attacker_legion
        self.defender_legion = defender_legion
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label(
            "Legion %s (%s) negotiates with %s (%s) in hex %s?" % (
                attacker_legion.markerid, attacker_legion.picname,
                defender_legion.markerid, defender_legion.picname,
                defender_legion.hexlabel))
        self.vbox.pack_start(legion_name)

        attacker_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(attacker_hbox)
        attacker_marker_hbox = gtk.HBox()
        attacker_hbox.pack_start(attacker_marker_hbox, expand=False)
        attacker_score_label = gtk.Label("%d\n points" %
                                         attacker_legion.score)
        attacker_hbox.pack_start(attacker_score_label, expand=False)
        attacker_chits_hbox = gtk.HBox(spacing=3)
        attacker_hbox.pack_start(attacker_chits_hbox)

        defender_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(defender_hbox)
        defender_marker_hbox = gtk.HBox()
        defender_hbox.pack_start(defender_marker_hbox, expand=False)
        defender_chits_hbox = gtk.HBox(spacing=3)
        defender_score_label = gtk.Label("%d\n points" %
                                         defender_legion.score)
        defender_hbox.pack_start(defender_score_label, expand=False)
        defender_hbox.pack_start(defender_chits_hbox)

        self.attacker_marker = Marker.Marker(attacker_legion, True, scale=20)
        attacker_marker_hbox.pack_start(self.attacker_marker.event_box,
                                        expand=False)
        self.attacker_marker.connect("button-press-event", self.cb_click)

        self.defender_marker = Marker.Marker(defender_legion, True, scale=20)
        defender_marker_hbox.pack_start(self.defender_marker.event_box,
                                        expand=False)
        self.defender_marker.connect("button-press-event", self.cb_click)

        self.attacker_chits = []

        for creature in attacker_legion.sorted_creatures:
            chit = Chit.Chit(creature, attacker_legion.player.color, scale=20)
            attacker_chits_hbox.pack_start(chit.event_box, expand=False)
            chit.connect("button-press-event", self.cb_click)
            self.attacker_chits.append(chit)

        self.defender_chits = []

        for creature in defender_legion.sorted_creatures:
            chit = Chit.Chit(creature, defender_legion.player.color, scale=20)
            defender_chits_hbox.pack_start(chit.event_box, expand=False)
            chit.connect("button-press-event", self.cb_click)
            self.defender_chits.append(chit)

        self.add_button("Concede", CONCEDE)
        self.proposal_button = self.add_button("Make proposal", MAKE_PROPOSAL)
        self.add_button("No more proposals", DONE_PROPOSING)
        self.add_button("Fight", FIGHT)
        self.connect("response", self.cb_response)

        self.proposal_button.set_sensitive(False)

        self.show_all()
Exemple #12
0
    def __init__(self,
                 battlemap,
                 game=None,
                 user=None,
                 playername=None,
                 scale=None,
                 parent_window=None):
        gtk.EventBox.__init__(self)

        self.battlemap = battlemap
        self.game = game
        self.user = user
        self.playername = playername
        self.parent_window = parent_window

        self.chits = []
        self.selected_chit = None

        self.vbox = gtk.VBox(spacing=1)
        self.add(self.vbox)

        if scale is None:
            self.scale = self.compute_scale()
        else:
            self.scale = scale
        self.area = gtk.DrawingArea()
        self.area.set_size_request(self.compute_width(), self.compute_height())

        gtkcolor = gtk.gdk.color_parse("white")
        self.modify_bg(gtk.STATE_NORMAL, gtkcolor)

        if game:
            self.turn_track = TurnTrack.TurnTrack(game.attacker_legion,
                                                  game.defender_legion, game,
                                                  self.scale)
            game.add_observer(self.turn_track)
            self.battle_dice = BattleDice.BattleDice(self.scale)
            game.add_observer(self.battle_dice)
            event_log = EventLog.EventLog(game, self.playername)
            game.add_observer(event_log)
            self.attacker_graveyard = Graveyard.Graveyard(game.attacker_legion)
            self.defender_graveyard = Graveyard.Graveyard(game.defender_legion)
        else:
            self.turn_track = None
            self.battle_dice = None
            self.attacker_graveyard = None
            self.defender_graveyard = None

        self.create_ui()
        self.vbox.pack_start(self.ui.get_widget("/Menubar"), expand=False)
        self.vbox.pack_start(self.ui.get_widget("/Toolbar"), expand=False)
        self.hbox1 = gtk.HBox()
        self.hbox2 = gtk.HBox()
        self.hbox3 = gtk.HBox()
        self.hbox4 = gtk.HBox()
        self.hbox5 = gtk.HBox(homogeneous=True)
        self.vbox.pack_start(self.hbox1, expand=False)
        self.vbox.pack_start(self.hbox2, fill=True)
        self.vbox.pack_start(self.hbox3, expand=False)
        self.vbox.pack_start(self.hbox4, expand=False)
        self.vbox.pack_start(self.hbox5, expand=False)
        if game:
            self.vbox.pack_start(event_log)
            gtkcolor = gtk.gdk.color_parse("white")
            attacker_marker = Marker.Marker(game.attacker_legion, True,
                                            self.scale / 2)
            attacker_marker.event_box.modify_bg(gtk.STATE_NORMAL, gtkcolor)
            defender_marker = Marker.Marker(game.defender_legion, True,
                                            self.scale / 2)
            defender_marker.event_box.modify_bg(gtk.STATE_NORMAL, gtkcolor)
            board = game.board
            hexlabel = game.defender_legion.hexlabel
            masterhex = board.hexes[hexlabel]
            own_hex_label = self.masterhex_label(masterhex, "xx-large")
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(own_hex_label)
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(self.spacer())
            self.hbox1.pack_start(self.spacer())
            self.hbox3.pack_start(self.turn_track, expand=False)
            self.hbox3.pack_start(self.battle_dice, fill=True)
            self.hbox2.pack_start(attacker_marker.event_box)
        self.hbox2.pack_start(self.area)
        if game:
            self.hbox2.pack_start(defender_marker.event_box)
            self.hbox5.pack_start(self.attacker_graveyard)
            self.hbox5.pack_start(self.defender_graveyard)

        self.guihexes = {}
        for hex1 in self.battlemap.hexes.itervalues():
            self.guihexes[hex1.label] = GUIBattleHex.GUIBattleHex(hex1, self)
        self.repaint_hexlabels = set()

        self.area.connect("expose-event", self.cb_area_expose)
        self.area.add_events(gtk.gdk.BUTTON_PRESS_MASK)
        self.area.connect("button-press-event", self.cb_click)
        self.show_all()
        if (self.game and self.game.battle_active_player
                and self.game.battle_active_player.name == self.playername):
            self.highlight_mobile_chits()
        self.pickcarry = None
Exemple #13
0
    def __init__(self, playername, attacker_legion, attacker_creature_names,
                 defender_legion, defender_creature_names, def1, parent):
        gtk.Dialog.__init__(self, "Proposal - %s" % playername, parent)
        self.attacker_legion = attacker_legion
        self.attacker_creature_names = attacker_creature_names
        self.defender_legion = defender_legion
        self.defender_creature_names = defender_creature_names
        self.deferred = def1

        self.set_icon(icon.pixbuf)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(True)
        self.vbox.set_spacing(9)

        legion_name = gtk.Label(
            "Legion %s (%s) negotiates with %s (%s) in hex %s" % (
                attacker_legion.markerid, attacker_legion.picname,
                defender_legion.markerid, defender_legion.picname,
                defender_legion.hexlabel))
        self.vbox.pack_start(legion_name)

        attacker_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(attacker_hbox)
        attacker_marker_hbox = gtk.HBox()
        attacker_hbox.pack_start(attacker_marker_hbox, expand=False)
        attacker_chits_hbox = gtk.HBox(spacing=3)
        attacker_hbox.pack_start(attacker_chits_hbox)

        attacker_marker = Marker.Marker(attacker_legion, True, scale=20)
        attacker_marker_hbox.pack_start(attacker_marker.event_box,
                                        expand=False)

        defender_hbox = gtk.HBox(spacing=15)
        self.vbox.pack_start(defender_hbox)
        defender_marker_hbox = gtk.HBox()
        defender_hbox.pack_start(defender_marker_hbox, expand=False)
        defender_chits_hbox = gtk.HBox(spacing=3)
        defender_hbox.pack_start(defender_chits_hbox)

        defender_marker = Marker.Marker(defender_legion, True, scale=20)
        defender_marker_hbox.pack_start(defender_marker.event_box,
                                        expand=False)

        attacker_chits = []

        surviving_attackers = bag(attacker_creature_names)
        surviving_defenders = bag(defender_creature_names)

        for creature in attacker_legion.sorted_creatures:
            name = creature.name
            if name in surviving_attackers:
                surviving_attackers.remove(name)
                dead = False
            else:
                dead = True
            chit = Chit.Chit(creature, attacker_legion.player.color, scale=20,
                             dead=dead)
            attacker_chits_hbox.pack_start(chit.event_box, expand=False)
            attacker_chits.append(chit)

        defender_chits = []

        for creature in defender_legion.sorted_creatures:
            name = creature.name
            if name in surviving_defenders:
                surviving_defenders.remove(name)
                dead = False
            else:
                dead = True
            chit = Chit.Chit(creature, defender_legion.player.color, scale=20,
                             dead=dead)
            defender_chits_hbox.pack_start(chit.event_box, expand=False)
            defender_chits.append(chit)

        self.add_button("Accept", ACCEPT)
        self.add_button("Reject", REJECT)
        self.add_button("Fight", FIGHT)
        self.connect("response", self.cb_response)

        self.show_all()