Exemple #1
0
 def _build_state_display(self, position):
     state_field = LabelFrame(self,
                              text=s.language.cards,
                              relief=RAISED,
                              width=self.master.width - 31)
     state_slots_per_row = int((self.master.width - 31) / 32)
     state_slot_height = 24 + (
         (int(len(self._current_player.states) / state_slots_per_row) + 1) *
         32)
     if self._current_player.states:
         for index, state in enumerate(self._current_player.states):
             if state not in self._main_window.engine.nemKartyaStatusz:
                 if state in self._main_window.engine.eventszotar.keys():
                     origin = self._main_window.engine.eventszotar
                     prefix = "event"
                 else:
                     origin = self._main_window.engine.kincsszotar
                     prefix = "treasure"
                 icon = f"{prefix}_{self._main_window.engine.eventszotar[state].kep}_i"
                 icon = icon[(icon.find('_') + 1):]
                 button = Button(
                     state_field,
                     image=Gallery.get(icon),
                     command=lambda s=state: origin[s].megjelenik(1))
                 button.grid(row=int(index / state_slots_per_row),
                             column=index % state_slots_per_row)
         state_field.config(height=state_slot_height)
         if state_field.winfo_children():
             state_field.grid(row=position, column=0)
         state_field.grid_propagate(False)
Exemple #2
0
class GameTab(Frame):
    def __init__(self, master):
        Frame.__init__(self, master)
        self._main_window = self.master.master
        self._land_land_roll = False
        self._heading = Frame(self)
        self._inventory_display = Frame(self)
        self._die_field = Frame(self)
        self._score_field = LabelFrame(self)
        self._turn_order = Frame(self)
        self.die = None
        if self._main_window.is_game_in_progress.get():
            self._load_content()

    @property
    def _current_player(self):
        return self._main_window.engine.aktivjatekos

    def reset_content(self):
        self._heading.destroy()
        self._heading = Frame(self)
        self._inventory_display.destroy()
        self._inventory_display = Frame(self)
        self._die_field.destroy()
        self._die_field = Frame(self)
        self._score_field.destroy()
        self._score_field = LabelFrame(self)
        self._turn_order.destroy()
        self._turn_order = Frame(self)
        if self.die:
            self.die.destroy()
        self.die = None
        self._load_content()

    def _load_content(self):
        self.master.tab(
            1, state=NORMAL)  # TODO fix it when window is being resized.
        self._build_heading(0)
        self._build_inventory_display(1)
        self._build_score_field(2)
        self._build_state_display(3)
        self._horizontal_line(4)
        self._build_die_field(5)
        self._horizontal_line(6)
        self._build_turn_order(7)

    def _build_heading(self, position):
        flag = Gallery.get(
            f"flag_{self._current_player.empire.adjective.lower()}")
        Label(self._heading, text=self._current_player.name).grid(row=0,
                                                                  column=0)
        Label(self._heading, image=flag).grid(row=1, column=0)
        self._heading.grid(row=position, column=0, pady=5)

    def _build_inventory_display(self, position):
        gold_frame = LabelFrame(self._inventory_display,
                                text=s.language.treasure)
        Label(gold_frame, image=Gallery.get("penz-d2")).grid(row=0, column=0)
        Label(gold_frame,
              textvariable=self._current_player.gold).grid(row=0, column=1)
        gold_frame.grid(row=0, column=0, sticky=N + E + W + S, padx=5)
        crew_frame = LabelFrame(self._inventory_display, text=s.language.crew)
        Label(crew_frame, image=Gallery.get("crew")).grid(row=0, column=0)
        Label(crew_frame,
              textvariable=self._current_player.crew).grid(row=0, column=1)
        crew_frame.grid(row=0, column=1, sticky=N + E + W + S, padx=5)
        self._inventory_display.grid(row=position, column=0)
        self._inventory_display.columnconfigure(
            ALL, minsize=(self.master.width - 20) / 2)

    def _horizontal_line(self, position):
        Separator(self, orient=HORIZONTAL).grid(row=position,
                                                column=0,
                                                sticky=E + W,
                                                padx=5,
                                                pady=5)

    def _build_score_field(self, position):
        self._score_field.config(text=s.language.scores)
        score_fields = {}
        target_empires = [empire.value for empire in Empires]
        target_empires.remove(self._current_player.empire)
        for index, empire in enumerate(target_empires):
            score_fields[empire.adjective] = Frame(self._score_field)
            flag = Gallery.get(f"flag_{empire.adjective.lower()}")
            Label(score_fields[empire.adjective], image=flag).grid(row=0,
                                                                   column=0)
            Label(score_fields[empire.adjective], text=':').grid(row=0,
                                                                 column=1)
            Label(score_fields[empire.adjective],
                  textvariable=self._current_player.scores[
                      empire.adjective]).grid(row=0, column=2)
            score_fields[empire.adjective].grid(row=int((index / 2) % 2),
                                                column=index % 2,
                                                sticky=E + W)
        self._score_field.grid(row=position, column=0)
        self._score_field.columnconfigure(ALL,
                                          minsize=(self.master.width - 34) / 2)

    def _build_die_field(self, position):
        self._die_field.columnconfigure(0, weight=1)
        self._die_field.rowconfigure(0, weight=1)
        self._die_field.grid(row=position, column=0, ipady=5, ipadx=5)
        should_miss_turn = self._current_player.turns_to_miss.get()
        if should_miss_turn > 0:
            self._build_miss_turn_button(should_miss_turn)
        else:
            self._build_die()

    def _build_miss_turn_button(self, should_miss_turn):
        if should_miss_turn > 1:
            message = s.language.miss_turn % should_miss_turn
        else:
            message = s.language.miss_turn_last_time
        Button(self._die_field,
               text=message,
               command=self._main_window.engine.kimaradas).pack()
        if "leviathan" in self._current_player.states:
            command = self._main_window.engine.leviathan_kijatszasa
            Button(self._die_field,
                   text=s.language.play_leviathan,
                   command=command).pack()

    def _build_die(self):
        self._die_field.config(relief=RAISED, bd=2)
        self.die = Die(self._die_field, self.master.width / 4,
                       self._current_player.color,
                       self._current_player.secondary_color,
                       self._current_player.last_roll)
        castaway_tiles = self._main_window.game_board.locations["castaways"]
        player_is_on_castaway_island = self._current_player.coordinates in castaway_tiles
        player_has_no_crew = not self._current_player.crew.get()
        if player_is_on_castaway_island and player_has_no_crew:
            self.die.bind('<Button-1>', self._main_window.engine.szamuzottek)
        else:
            self.die.bind('<Button-1>', self._roll_die)
        self.die.grid(row=0, column=0)

    def _build_turn_order(self, position):
        players = []
        turn_order_label = Label(self._turn_order, text=s.language.turn_order)
        turn_order_label.grid(row=0, column=0, sticky=W)
        for index, player_name in enumerate(self._main_window.player_order):
            player = self._main_window.players[player_name]
            players.append(
                Label(self._turn_order,
                      text=str(index + 1) + '. ' + player.name,
                      bg=player.color,
                      fg=player.secondary_color))
            players[-1].grid(row=index + 1, column=0, sticky=W, padx=10)
        self._turn_order.grid(row=position, column=0, sticky=W, padx=5)

    def _build_state_display(self, position):
        state_field = LabelFrame(self,
                                 text=s.language.cards,
                                 relief=RAISED,
                                 width=self.master.width - 31)
        state_slots_per_row = int((self.master.width - 31) / 32)
        state_slot_height = 24 + (
            (int(len(self._current_player.states) / state_slots_per_row) + 1) *
            32)
        if self._current_player.states:
            for index, state in enumerate(self._current_player.states):
                if state not in self._main_window.engine.nemKartyaStatusz:
                    if state in self._main_window.engine.eventszotar.keys():
                        origin = self._main_window.engine.eventszotar
                        prefix = "event"
                    else:
                        origin = self._main_window.engine.kincsszotar
                        prefix = "treasure"
                    icon = f"{prefix}_{self._main_window.engine.eventszotar[state].kep}_i"
                    icon = icon[(icon.find('_') + 1):]
                    button = Button(
                        state_field,
                        image=Gallery.get(icon),
                        command=lambda s=state: origin[s].megjelenik(1))
                    button.grid(row=int(index / state_slots_per_row),
                                column=index % state_slots_per_row)
            state_field.config(height=state_slot_height)
            if state_field.winfo_children():
                state_field.grid(row=position, column=0)
            state_field.grid_propagate(False)

    def _roll_die(self, event):
        if self._land_land_roll:
            self._main_window.game_board.turn_off_blinker()
            self._main_window.engine.dobasMegtortent.set(False)
        if not self._main_window.engine.dobasMegtortent.get():
            dobas = self.die.roll()
            if "landland" in self._current_player.states:
                debug("New roll is possible because of Land, land! bonus.")
                self._main_window.status_bar.log(s.language.land_log)
                self._current_player.remove_state("landland")
                self._land_land_roll = True
            else:
                self._main_window.status_bar.log('')
                self._die_field.config(relief=SUNKEN)
            self._main_window.engine.set_dobasMegtortent()
            self._main_window.is_turn_in_progress.set(1)
            self._main_window.engine.aktivjatekos.last_roll = dobas
            self._main_window.engine.mozgas(dobas, 1)

    def disable_additional_roll(self):
        if self._land_land_roll is False:
            self._main_window.status_bar.log('')
            self._die_field.config(relief=SUNKEN)
            self._land_land_roll = False
Exemple #3
0
class SettingsTab(Frame):
    def __init__(self, master):
        Frame.__init__(self, master=master)
        self._main_window = self.master.master
        self._resolution_field = LabelFrame(self, text='')
        self._language_field = LabelFrame(self, text='')
        self._is_full_screen = IntVar()
        self._is_full_screen.set(self._main_window.is_full_screen.get())
        self._position_fields()
        self._resolutions = sorted(self._main_window.resolution_list)
        self._resolution_scale = Scale(self._resolution_field,
                                       from_=0,
                                       to=len(self._resolutions) - 1,
                                       orient=HORIZONTAL,
                                       resolution=1,
                                       takefocus=0,
                                       showvalue=0,
                                       length=self._main_window.width,
                                       command=self._update_resolution_button)
        self._resolution_scale.set(self._compose_scale())
        self._resolution_display = Label(self._resolution_field,
                                         text=(self._main_window.width, '×',
                                               self._main_window.height))
        self._resolution_changer = Button(
            self._resolution_field,
            textvariable=self._main_window.ui_text_variables['apply'],
            command=self._change_resolution,
            state=DISABLED)
        self._full_screen_label = Label(
            self._resolution_field,
            textvariable=self._main_window.ui_text_variables['full_screen'])
        self._full_screen_checkbox = Checkbutton(
            self._resolution_field,
            takefocus=0,
            variable=self._is_full_screen,
            command=lambda: self._resolution_changer.config(state=NORMAL))
        self._languages = self._main_window.data_reader.load_language_list()
        self._languages = [language.value.name for language in Languages]
        self._language_picker = Combobox(self._language_field,
                                         value=sorted(self._languages),
                                         takefocus=0)
        self._language_picker.set(self._main_window.language.name)
        self._language_picker.bind("<<ComboboxSelected>>", self._pick_language)
        self._position_elements()
        self.load_ui_texts()

    def _position_fields(self):
        for index, field in enumerate(
            (self._resolution_field, self._language_field)):
            field.columnconfigure(0, weight=1)
            field.grid(row=index, column=0, sticky=E + W, padx=5, pady=5)

    @property
    def _languages_reversed(self):
        return dict(zip(self._languages.values(), self._languages.keys()))

    def _update_resolution_button(self, ertek):
        self._resolution_display.config(
            text=(str(self._resolutions[int(ertek)][0]), '×',
                  str(self._resolutions[int(ertek)][1])))
        if (self._main_window.width, self._main_window.height) == (
                self._resolutions[int(ertek)][0],
                self._resolutions[int(ertek)][1]):
            self._resolution_changer.config(state=DISABLED)
        else:
            self._resolution_changer.config(state=NORMAL)

    def _compose_scale(self):
        resolution_code = self._main_window.resolution_code
        return self._resolutions.index([
            item for item in self._resolutions if item[2] == resolution_code
        ][0])

    def _change_resolution(self):
        self._main_window.resize(
            self._resolutions[self._resolution_scale.get()],
            self._is_full_screen.get())

    def _pick_language(self, event):
        new_language = Languages.get_language_by_name(
            self._language_picker.get())
        self._main_window.set_new_language(new_language)

    def _position_elements(self):
        self._resolution_scale.grid(row=0,
                                    column=0,
                                    columnspan=2,
                                    sticky=E + W)
        self._resolution_display.grid(row=1,
                                      column=0,
                                      padx=5,
                                      pady=5,
                                      sticky=W)
        self._resolution_changer.grid(row=1,
                                      column=1,
                                      padx=5,
                                      pady=5,
                                      sticky=E)
        self._full_screen_label.grid(row=2, column=0, padx=5, pady=5, sticky=W)
        self._full_screen_checkbox.grid(row=2,
                                        column=1,
                                        padx=5,
                                        pady=5,
                                        sticky=E)
        self._language_picker.grid(row=0, column=0, padx=5, pady=5)

    def load_ui_texts(self):
        self._resolution_field.config(text=s.language.resolution)
        self._language_field.config(text=s.language.language)