Beispiel #1
0
    def __init__(self, *args, **kwargs):
        super(MainMenu, self).__init__(*args,
                                       background_color='main_menu_background',
                                       **kwargs)

        self.map_screen = map.MapScreen(self)
        self.new_game_button = \
            button.FunctionButton(self, (.5, .20), (.25, .08),
                                  autotranslate=True,
                                  text=N_("&NEW GAME"),
                                  anchor=constants.TOP_CENTER,
                                  text_size=28,
                                  function=self.new_game)
        self.load_game_button = \
            button.FunctionButton(self, (.5, .36), (.25, .08),
                                  autotranslate=True,
                                  text=N_("&LOAD GAME"),
                                  anchor=constants.TOP_CENTER,
                                  text_size=28,
                                  function=self.load_game)
        self.options_button = button.DialogButton(
            self, (.5, .52), (.25, .08),
            autotranslate=True,
            text=N_("&OPTIONS"),
            anchor=constants.TOP_CENTER,
            text_size=28,
            dialog=options.OptionsScreen(self))
        self.quit_button = button.ExitDialogButton(self, (.5, .68), (.25, .08),
                                                   autotranslate=True,
                                                   text=N_("&QUIT"),
                                                   anchor=constants.TOP_CENTER,
                                                   text_size=28)
        self.about_button = button.DialogButton(self, (0, 1), (.13, .04),
                                                autotranslate=True,
                                                text=N_("&ABOUT"),
                                                text_size=20,
                                                anchor=constants.BOTTOM_LEFT,
                                                dialog=AboutDialog(self))

        self.title_text = text.Text(self, (.5, .01), (.55, .08),
                                    text="ENDGAME: SINGULARITY",
                                    base_font="special",
                                    text_size=100,
                                    color="singularity_title",
                                    background_color="main_menu_background",
                                    anchor=constants.TOP_CENTER)

        self.difficulty_dialog = dialog.SimpleMenuDialog(self)

        self.load_dialog = savegame.SavegameScreen(self, (.5, .5), (.90, .90),
                                                   anchor=constants.MID_CENTER)
Beispiel #2
0
 def _rebuild_menu_buttons(self):
     menu_buttons = [
         button.FunctionButton(None,
                               None,
                               None,
                               text=_("&SAVE GAME"),
                               autohotkey=True,
                               function=self.save_game),
         button.FunctionButton(None,
                               None,
                               None,
                               text=_("&LOAD GAME"),
                               autohotkey=True,
                               function=self.load_game),
         button.DialogButton(None,
                             None,
                             None,
                             text=_("&OPTIONS"),
                             autohotkey=True,
                             dialog=self.options_dialog),
         button.ExitDialogButton(None,
                                 None,
                                 None,
                                 text=_("&QUIT"),
                                 autohotkey=True,
                                 exit_code=True,
                                 default=False),
         button.ExitDialogButton(None,
                                 None,
                                 None,
                                 text=_("&BACK"),
                                 autohotkey=True,
                                 exit_code=False),
     ]
     self._buttons = menu_buttons
Beispiel #3
0
 def __init__(self, map_screen):
     super(GameMenuDialog, self).__init__(parent=map_screen)
     self._map_screen = map_screen
     self.options_dialog = OptionsScreen(self)
     self.savename_dialog = dialog.TextEntryDialog(self)
     self.load_dialog = savegame.SavegameScreen(self,
                                                (.5, .5), (.90, .90),
                                                anchor=constants.MID_CENTER)
     self._buttons = [
         button.FunctionButton(None, None, None,
                               text=_("&SAVE GAME"), autotranslate=True,
                               function=self.save_game),
         button.FunctionButton(None, None, None,
                               text=_("&LOAD GAME"), autotranslate=True,
                               function=self.load_game),
         button.DialogButton(None, None, None,
                             text=_("&OPTIONS"), autotranslate=True,
                             dialog=self.options_dialog),
         button.ExitDialogButton(None, None, None,
                                 text=_("&QUIT"), autotranslate=True,
                                 exit_code=True, default=False),
         button.ExitDialogButton(None, None, None, text=_("&BACK"), autotranslate=True,
                                 exit_code=False),
     ]
     self.needs_rebuild = True
    def __init__(self, map_screen):
        super(CheatMenuDialog, self).__init__(parent=map_screen)
        self._map_screen = map_screen

        self.steal_amount_dialog = None
        self.buttons = [
            button.FunctionButton(None, None, None, text=N_("&EMBEZZLE MONEY"),
                                  autotranslate=True, function=self.steal_money),

            button.FunctionButton(None, None, None, text=N_("&INSPIRATION"),
                                  autotranslate=True, function=self.inspiration),
            button.FunctionButton(None, None, None, text=N_("&FINISH CONSTRUCTION"),
                                  autotranslate=True, function=self.end_construction),
            button.FunctionButton(None, None, None, text=N_("&SUPERSPEED"),
                                  autotranslate=True, function=self._map_screen.set_speed,
                                  args=(864000,)),
            button.FunctionButton(None, None, None, text=N_("BRAIN&WASH"),
                                  autotranslate=True, function=self.brainwash),
            button.FunctionButton(None, None, None, text=N_("TOGGLE &DETECTION"),
                                  autotranslate=True, function=self.toggle_detection),
            button.FunctionButton(None, None, None, text=N_("TOGGLE &ANALYSIS"),
                                  autotranslate=True, function=self.set_analysis),
            button.DialogButton(None, None, None, text=N_("E&VENTS"),
                                autotranslate=True,
                                dialog=EventManipulationDialog(self)),

            button.FunctionButton(None, None, None, text=N_("HIDDEN S&TATE"),
                                  autotranslate=True, function=self.hidden_state),

            button.ExitDialogButton(None, None, None,
                                    text=N_("&BACK"),
                                    autotranslate=True),
        ]
        self.needs_rebuild = True
Beispiel #5
0
    def __init__(self, parent, pos=(.5, .1), size=(.93, .73), *args, **kwargs):
        super(ReportScreen, self).__init__(parent, pos, size, *args, **kwargs)

        kwargs.setdefault("background_color", "clear")

        self.format_buttons = button.ButtonGroup()

        self.stats_button = button.DialogButton(self, (-.49, -.99), (-.3, -.1),
                                                autotranslate=True,
                                                text=N_("&STATISTICS"),
                                                anchor=constants.BOTTOM_RIGHT,
                                                dialog=stat.StatScreen(self))
        self.back_button = button.ExitDialogButton(
            self,
            (-.51, -.99),
            (-.3, -.1),
            autotranslate=True,
            text=N_("&BACK"),
            anchor=constants.BOTTOM_LEFT,
        )
        self.add_key_handler(pygame.K_ESCAPE,
                             self.back_button.activate_with_sound)

        self.money_report_pane = widget.BorderedWidget(
            self, (0, .08), (-.45, -.72), anchor=constants.TOP_LEFT)
        self.cpu_report_pane = widget.BorderedWidget(
            self, (-1, .08), (-.45, -.72), anchor=constants.TOP_RIGHT)

        self.format_button_midnight = FormatButton(self, (-.5, 0),
                                                   (-.15, -.08),
                                                   autotranslate=True,
                                                   text=N_("&Midnight"),
                                                   anchor=constants.TOP_RIGHT,
                                                   function=self.format_toggle)
        self.format_button_midnight.args = (self.format_button_midnight, True)
        self.format_buttons.add(self.format_button_midnight)

        self.format_button_24hours = FormatButton(self, (-.5, 0), (-.15, -.08),
                                                  autotranslate=True,
                                                  text=N_("24 &Hours"),
                                                  anchor=constants.TOP_LEFT,
                                                  function=self.format_toggle)
        self.format_button_24hours.args = (self.format_button_24hours, False)
        self.format_buttons.add(self.format_button_24hours)

        self.format_button_midnight.chosen_one()
        self.midnight_stop = True
Beispiel #6
0
    def __init__(self, map_screen):
        super(GameMenuDialog, self).__init__(parent=map_screen)
        self._map_screen = map_screen
        self.options_dialog = OptionsScreen(self)
        self.savename_dialog = dialog.TextEntryDialog(self)
        self.load_dialog = savegame.SavegameScreen(self, (.5, .5), (.90, .90),
                                                   anchor=constants.MID_CENTER)
        self._buttons = [
            button.FunctionButton(None,
                                  None,
                                  None,
                                  text=_("&SAVE GAME"),
                                  autotranslate=True,
                                  function=self.save_game),
            button.FunctionButton(None,
                                  None,
                                  None,
                                  text=_("&LOAD GAME"),
                                  autotranslate=True,
                                  function=self.load_game),
            button.DialogButton(None,
                                None,
                                None,
                                text=_("&OPTIONS"),
                                autotranslate=True,
                                dialog=self.options_dialog),
            button.ExitDialogButton(None,
                                    None,
                                    None,
                                    text=_("&QUIT"),
                                    autotranslate=True,
                                    exit_code=True,
                                    default=False),
            button.ExitDialogButton(None,
                                    None,
                                    None,
                                    text=_("&BACK"),
                                    autotranslate=True,
                                    exit_code=False),
        ]
        # Hide hotkeys (#289) to avoid confusion due to poor focus visibility
        self.savename_dialog.ok_button.force_underline = -1
        self.savename_dialog.cancel_button.force_underline = -1

        self.needs_rebuild = True
Beispiel #7
0
    def __init__(self,
                 parent=None,
                 pos=(0, 0),
                 size=(1, 1),
                 anchor=constants.TOP_LEFT,
                 *args,
                 **kwargs):

        super(MapScreen, self).__init__(parent, pos, size, anchor, *args,
                                        **kwargs)

        g.map_screen = self

        self.background_color = "map_background"
        self.add_handler(constants.TICK, self.on_tick)

        self.map = EarthImage(self)

        self.location_buttons = {}
        for loc in g.locations.values():
            if loc.absolute:
                button_parent = self
            else:
                button_parent = self.map
            b = button.FunctionButton(button_parent, (loc.x, loc.y),
                                      anchor=constants.MID_CENTER,
                                      function=self.open_location,
                                      args=(loc.id, ))
            self.location_buttons[loc.id] = b

        self.location_dialog = LocationScreen(self)

        self.suspicion_bar = \
            text.FastStyledText(self, (0,.92), (1, .04), base_font="special",
                                wrap=False,
                                background_color="pane_background_empty",
                                border_color="pane_background",
                                borders=constants.ALL, align=constants.LEFT)
        widget.unmask_all(self.suspicion_bar)

        self.danger_bar = \
            text.FastStyledText(self, (0,.96), (1, .04), base_font="special",
                                wrap=False,
                                background_color="pane_background_empty",
                                border_color="pane_background",
                                borders=constants.ALL, align=constants.LEFT)
        widget.unmask_all(self.danger_bar)

        self.report_button = button.DialogButton(
            self, (0, 0.88), (0.15, 0.04),
            autohotkey=True,
            dialog=report.ReportScreen(self))

        self.knowledge_button = button.DialogButton(
            self, (0.85, 0.88), (0.15, 0.04),
            autohotkey=True,
            dialog=knowledge.KnowledgeScreen(self))

        self.log_button = button.DialogButton(self, (0.5, 0.88), (0.15, 0.04),
                                              autohotkey=True,
                                              anchor=constants.TOP_CENTER,
                                              dialog=log.LogScreen(self))

        if g.cheater:
            # Create cheat menu
            # Cheat menu button must be created before menu button to avoid bug.

            self.cheat_dialog = CheatMenuDialog(self)
            self.cheat_button = button.DialogButton(
                self,
                (0, 0),
                (.01, .01),
                text="",
                # Translators: hotkey to open the cheat screen menu.
                # Should preferably be near the ESC key, and it must not be a
                # dead key (ie, it must print a char with a single keypress)
                hotkey=_("`"),
                dialog=self.cheat_dialog)

        self.menu_dialog = GameMenuDialog(self)

        def show_menu():
            exit = dialog.call_dialog(self.menu_dialog, self)
            if exit:
                raise constants.ExitDialog

        self.menu_button = button.FunctionButton(self, (0, 0), (0.13, 0.04),
                                                 autohotkey=True,
                                                 function=show_menu)

        # Display current game difficulty right below the 'Menu' button
        # An alternative location is above 'Reports': (0, 0.84), (0.15, 0.04)
        self.difficulty_display = \
            text.FastText(self, (0, 0.05), (0.13, 0.04),
                          wrap=False,
                          base_font="special",
                          background_color="pane_background_empty",
                          border_color="pane_background")

        self.time_display = text.FastText(
            self, (.14, 0), (0.23, 0.04),
            wrap=False,
            text=_("DAY") + " 0000, 00:00:00",
            base_font="special",
            background_color="pane_background_empty",
            border_color="pane_background",
            borders=constants.ALL)

        self.research_button = \
            button.DialogButton(self, (.14, 0.05), (0, 0.04),
                                autohotkey=True,
                                dialog=research.ResearchScreen(self))

        bar = u"\u25AE"
        arrow = u"\u25B6"
        speed_button_souls = [(bar * 2, .025, speeds[0]),
                              (arrow, .024, speeds[1]),
                              (arrow * 2, .033, speeds[2]),
                              (arrow * 3, .044, speeds[3]),
                              (arrow * 4, .054, speeds[4])]

        self.speed_buttons = button.ButtonGroup()
        hpos = .38
        for index, (text_, hsize, speed) in enumerate(speed_button_souls):
            hotkey = str(index)
            b = SpeedButton(self, (hpos, 0), (hsize, .04),
                            text=text_,
                            hotkey=hotkey,
                            base_font="normal",
                            text_shrink_factor=.75,
                            align=constants.CENTER,
                            function=self.set_speed,
                            args=(speed, False))
            hpos += hsize
            self.speed_buttons.add(b)

        self.info_window = \
            widget.BorderedWidget(self, (.56, 0), (.44, .08),
                                  background_color="pane_background_empty",
                                  border_color="pane_background",
                                  borders=constants.ALL)
        widget.unmask_all(self.info_window)

        self.cash_display = \
            text.FastText(self.info_window, (0,0), (-1, -.5),
                          wrap=False,
                          base_font="special", shrink_factor = .7,
                          borders=constants.ALL,
                          background_color="pane_background_empty",
                          border_color="pane_background")

        self.cpu_display = \
            text.FastText(self.info_window, (0,-.5), (-1, -.5),
                          wrap=False,
                          base_font="special", shrink_factor=.7,
                          borders=
                           (constants.LEFT, constants.RIGHT, constants.BOTTOM),
                          background_color="pane_background_empty",
                          border_color="pane_background")

        self.message_dialog = dialog.MessageDialog(self, text_size=20)

        self.messages = message.MessageDialogs(self)
        self.needs_warning = True

        self.add_key_handler(pygame.K_ESCAPE, self.got_escape)

        self.add_key_handler(constants.XO1_X, self.got_XO1)
        self.add_key_handler(constants.XO1_O, self.got_XO1)
        self.add_key_handler(constants.XO1_SQUARE, self.got_XO1)