def __init__(self):
        SceneBase.__init__(self)

        self.hardcoremode = ToggleBox((600, 225),
                                      self.HardcoreMode,
                                      size=(30, 30),
                                      bg=(0, 170, 28))
        self.hardcoretext = Text(225,
                                 500,
                                 "Hardcore Mode",
                                 bold=True,
                                 font="Arial",
                                 fontSize=18)

        self.backbutton = Button("Back", (50, 625),
                                 self.GoBack,
                                 size=(60, 30),
                                 bg=(109, 177, 255))

        self.text1 = Text(100,
                          600,
                          "Options Menu",
                          bold=True,
                          color=(255, 255, 255),
                          font="Arial",
                          fontSize=35)
Beispiel #2
0
    def __init__(self):
        SceneBase.__init__(self)
        self.startbutton = Button("New Game", (510, 325),
                                  self.StartGame,
                                  size=(120, 60),
                                  font_size=20,
                                  bg=(109, 177, 255))
        self.Instructionsbutton = Button("Instructions", (690, 325),
                                         self.Instructions,
                                         size=(120, 60),
                                         font_size=20,
                                         bg=(109, 177, 255))
        self.Lorebutton = Button("Read Lore", (510, 425),
                                 self.Lore,
                                 size=(120, 60),
                                 font_size=20,
                                 bg=(109, 177, 255))
        self.exitbutton = Button("Exit Game", (690, 425),
                                 self.ExitGame,
                                 size=(120, 60),
                                 font_size=20,
                                 bg=(109, 177, 255))
        self.optionsbutton = Button("Options", (1150, 625),
                                    self.Options,
                                    size=(90, 40),
                                    bg=(109, 177, 255))
        self.creditsbutton = Button("Credits", (600, 525),
                                    self.Credits,
                                    size=(120, 60),
                                    font_size=20,
                                    bg=(109, 177, 255))

        self.text = Text(
            228,
            600,
            "Mongolian Space Stick Wars XD Special Day One Edition",
            bold=True,
            color=(109, 177, 255),
            fontSize=45)

        self.text1 = Text(
            224,
            600,
            "Mongolian Space Stick Wars XD Special Day One Edition",
            bold=True,
            color=(255, 255, 255),
            font="Arial",
            fontSize=45)

        # Start music
        b = Boombox()

        b.PlayMusic("menumusic")
    def __init__(
        self, name, func, position, fontPath, fontSize, text, fontColor, fontBGColor, menu=None, neighbors=None
    ):

        MenuButton.__init__(self, position, 1, 1, name, menu, neighbors)
        Text.__init__(self, position, fontPath, fontSize, text, fontColor, fontBGColor)

        self._defaultColor = self._fontColor
        self._highlightColor = pygame.Color(255, 255, 255)
        self._selectColor = pygame.Color(255, 255, 0)

        self._function = func
    def add_ui_object_to_menu(self, item) -> None:

        # calc item position
        if any(self.__menu_ui_objects_list):
            # if list is not empty
            last_item = self.__menu_ui_objects_list[
                -1]  # get the last item in the list
            position = (last_item.get_position()[0],
                        last_item.get_position()[1] + last_item.get_size()[1] +
                        self.__pady)
        else:
            # if there are no items in the list (this is the new item added)
            position = (self.get_position()[0] + self.__padx,
                        self.get_position()[1] + self.__pady)

        if isinstance(item, Text) or isinstance(item, Button) or isinstance(
                item, TextButton):
            menu_item = item
            menu_item.set_position(position)
        else:
            menu_item = Text(item.get_menu_item_string(), position,
                             GameConstants.WHITE, None,
                             UIConstants.FONT_SIZE_SMALL)

        self.__menu_ui_objects_list.append(menu_item)
        self.__menu_objects_list.append(item)
 def __add_text(self, string):
     text = Text(string, (0, 0), GameConstants.WHITE, None, 28)
     text_size = text.get_size()
     position = (GameConstants.SCREEN_SIZE[0] / 2 - text_size[0] / 2, 5)
     text.set_position(position)
     self.__texts.append(text)
     game_engine = self.get_game_engine()
     game_engine.add_sprite_to_group(text, 0)
Beispiel #6
0
    def is_battle_over(self):

        models_manager = self.get_models_manager()
        ui_manager = self.get_ui_manager()
        game_engine = self.get_game_engine()

        player_models = models_manager.get_player_sorted_models_list()
        alive_player_models = [x for x in player_models if not x.is_killed()]

        computer_models = models_manager.get_computer_sorted_models_list()
        alive_computer_models = [
            x for x in computer_models if not x.is_killed()
        ]

        if not any(alive_player_models):
            # All Player models are dead, player lost!
            logger.info("All player models are killed, battle is lost!")
            text = Text("Battle is lost...", (0, 0), GameConstants.RED, None,
                        UIConstants.FONT_SIZE_XLARGE)

        elif not any(alive_computer_models):
            # all computer models are dead, player won!
            # TODO: also need to check that there are no more computer models in the level
            logger.info("All computer models are killed, battle is won!")
            text = Text("Battle is won!", (0, 0), GameConstants.WHITE, None,
                        UIConstants.FONT_SIZE_XLARGE)

        else:
            return

        self.__battle_is_over = True

        # update text position to replace UI MENUS
        position = (int(GameConstants.SCREEN_SIZE[0] / 2) -
                    int(text.get_size()[0] / 2),
                    GameConstants.BATTLE_AREA_BOTTOM + int(text.get_size()[1]))
        text.set_position(position)

        ui_manager.destroy()  # clear the UI
        ui_manager.add_game_over_controls(
            posy=text.get_position()[1] +
            text.get_size()[1])  # add continue button
        self.__texts.append(text)  # add battle over text to list
        game_engine.add_sprite_to_group(text)

        return
    def set_table_header(self):
        # add table header
        self.__table_header = Text(TITLE_STRING, (0, 0))
        padx = 15
        pady = 5

        position = (self.get_position()[0] + padx,
                    self.get_position()[1] + pady)

        self.__table_header.set_position(position)
    def __add_campaign_texts(self):
        act = self.__level_manager.get_act()
        act_number = act.get_act_number()
        level_number = act.get_level()

        position = (20, 20)
        act_text = Text("Act " + act_number, position, GameConstants.BLACK,
                        None, UIConstants.FONT_SIZE_MEDIUM)

        position = (position[0], position[1] + act_text.get_size()[1])
        level_text = Text("Level " + level_number, position,
                          GameConstants.BLACK, None,
                          UIConstants.FONT_SIZE_MEDIUM)

        self.__texts.append(act_text)
        self.__texts.append(level_text)

        game_engine = self.get_game_engine()
        for text in self.__texts:
            game_engine.add_sprite_to_group(text)
Beispiel #9
0
 def __init__(self):
     SceneBase.__init__(self)
     self.text = Text(228,
                      600,
                      "Special Thanks: Connor Daniel",
                      bold=True,
                      color=(109, 177, 255),
                      fontSize=45)
     self.returnbutton = Button("Return to Menu", (900, 425),
                                self.GoBack,
                                size=(300, 60),
                                font_size=20,
                                bg=(109, 177, 255))
Beispiel #10
0
    def __init__(
        self,
        name,
        targetMenuName,
        position,
        fontPath,
        fontSize,
        text,
        fontColor,
        fontBGColor,
        menu=None,
        neighbors=None,
    ):
        """
        Constructor
        """
        MenuButton.__init__(self, position, 1, 1, name, menu, neighbors)
        Text.__init__(self, position, fontPath, fontSize, text, fontColor, fontBGColor)

        self._defaultColor = self._fontColor
        self._highlightColor = pygame.Color(255, 255, 255)
        self._selectColor = pygame.Color(255, 255, 0)
        self._targetMenuName = targetMenuName
Beispiel #11
0
    def __init__(self):
        SceneBase.__init__(self)
        self.text = Text(228,
                         600,
                         "Level Select",
                         bold=True,
                         color=(109, 177, 255),
                         fontSize=45)
        self.marsbutton = Button("2. Mars", (690, 325),
                                 self.Mars,
                                 size=(120, 60),
                                 font_size=20,
                                 bg=(109, 177, 255))
        self.moonbutton = Button("1. Moon", (510, 325),
                                 self.Moon,
                                 size=(120, 60),
                                 font_size=20,
                                 bg=(109, 177, 255))
        self.saturnbutton = Button("3. Saturn", (510, 425),
                                   self.Saturn,
                                   size=(120, 60),
                                   font_size=20,
                                   bg=(109, 177, 255))
        self.mercurybutton = Button("4. Mercury", (690, 425),
                                    self.Mercury,
                                    size=(120, 60),
                                    font_size=20,
                                    bg=(109, 177, 255))

        self.uranusbutton = Button("5. Uranus", (510, 525),
                                   self.Uranus,
                                   size=(120, 60),
                                   font_size=20,
                                   bg=(109, 177, 255))
        self.neptunebutton = Button("6. Neptune", (690, 525),
                                    self.Neptune,
                                    size=(120, 60),
                                    font_size=20,
                                    bg=(109, 177, 255))

        self.continuebutton = Button("Back", (50, 625),
                                     self.Continue,
                                     size=(60, 30),
                                     bg=(109, 177, 255))
        # Start music
        b = Boombox()

        if not b.MusicStatus():
            b.PlayMusic("menumusic")
Beispiel #12
0
    def add_text_to_menu(self, string):

        # calc item position
        if any(self.__menu_items_list):
            # if list is not empty
            last_item = self.__menu_items_list[
                -1]  # get the last item in the list
            position = (last_item.get_position()[0],
                        last_item.get_position()[1] + last_item.get_size()[1] +
                        self.__pady)
        else:
            # if there are no items in the list (this is the new item added)
            position = (self.get_position()[0] + self.__padx,
                        self.get_position()[1] + self.__pady)

        menu_item = Text(string, position, GameConstants.WHITE, None, 48)

        self.__menu_items_list.append(menu_item)
Beispiel #13
0
    def __init__(self, remaining_dice):
        arrow_button_generator = ArrowButtonGenerator()

        self.__name = "Dice Controller"
        self.__remaining_dice = remaining_dice
        self.__current_dice = 1

        self.__left_arrow_button = arrow_button_generator.get_left_arrow_button(
        )
        self.__right_arrow_button = arrow_button_generator.get_right_arrow_button(
        )
        self.__dice_text = Text(self.get_string(), (0, 0),
                                text_color=GameConstants.WHITE,
                                font_size=UIConstants.FONT_SIZE_LARGE)

        # position the text
        text_size = self.__dice_text.get_size()
        x = int(GameConstants.SCREEN_SIZE[0] / 2) - int(text_size[0] / 2)
        y = int(GameConstants.SCREEN_SIZE[1] / 2) - int(text_size[1] / 2)
        self.__dice_text.set_position((x, y))  # position middle of screen

        padx = 0
        arrow_size = self.__right_arrow_button.get_size()

        # position the right arrow
        x = self.__dice_text.get_position()[0] + text_size[0] + padx
        y = int(GameConstants.SCREEN_SIZE[1] / 2) - int(arrow_size[1] / 2)
        self.__right_arrow_button.set_position((x, y))

        # position the left arrow
        x = self.__dice_text.get_position()[0] - arrow_size[0] - padx
        self.__left_arrow_button.set_position((x, y))

        # background
        self.__background = UIObject(image=pygame.image.load(
            UIConstants.SPRITE_BLUE_MENU),
                                     position=(0, 0))
        self.__background.set_size(self.get_size())
        self.__background.set_position(self.get_position())

        self.__focused = True
Beispiel #14
0
    def __init__(self):
        SceneBase.__init__(self)
        UnitLoader.__init__()

        self.counter = 0
        self.Economy = False
        self.MoneyCounter = 0
        self.AttackRate = 0
        self.EAttackRate = 0
        self.Health = 1000
        if UpgradeData.defense:
            self.EHealth = 1500
        elif not UpgradeData.defense:
            self.EHealth = 1000

        print(self.Health)

        self.offset = 0
        self.movecamera = 0
        self.scrollfactor = 25

        self.UnitMovement = UnitMovement()

        if Options.hardcoremode:
            self.AI = BaseAI(6)
        else:
            self.AI = BaseAI(3)

        self.defendbutton = Button("Defend", (60, 635),
                                   self.Attack,
                                   size=(120, 30),
                                   font_size=20,
                                   bg=(109, 177, 255))
        self.holdbutton = Button("Hold", (185, 635),
                                 self.HoldPosition,
                                 size=(120, 30),
                                 font_size=20,
                                 bg=(109, 177, 255))
        self.attackbutton = Button("Attack", (310, 635),
                                   self.DefendPosition,
                                   size=(120, 30),
                                   font_size=20,
                                   bg=(109, 177, 255))
        self.openmenu = Button("Build List", (1130, 600),
                               self.Menu,
                               size=(120, 30),
                               font_size=20,
                               bg=(109, 177, 255))

        self.resourcebar = Bar("Moon Crystals: 100", (1080, 15),
                               size=(240, 30),
                               font_size=20,
                               bg=(176, 185, 186))
        self.supplybar = Bar("Units: 0/40", (1080, 45),
                             size=(240, 30),
                             font_size=20,
                             bg=(176, 185, 186))

        self.buildmenu = ToggleMenu((1140, 350),
                                    size=(160, 400),
                                    bg=(176, 185, 186),
                                    shown=False)

        self.buildrifleblaster = Button("RifleBlaster 100", (1130, 275),
                                        self.BRB,
                                        size=(120, 60),
                                        font_size=15,
                                        bg=(109, 177, 255))
        self.buildhorserifleblaster = Button("HorseRifleBlaster 200",
                                             (1130, 435),
                                             self.BHRB,
                                             size=(120, 60),
                                             font_size=12,
                                             bg=(109, 177, 255))
        self.buildspaceraider = Button("SpaceRaider 50", (1130, 195),
                                       self.BSR,
                                       size=(120, 60),
                                       font_size=15,
                                       bg=(109, 177, 255))
        self.buildtank = Button("Tank 300", (1130, 355),
                                self.BTANK,
                                size=(120, 60),
                                font_size=15,
                                bg=(109, 177, 255))

        self.buildmenutoggle = False

        self.buildqueue = StatBar(" ", (1090, 635),
                                  size=(200, 20),
                                  bg=(176, 185, 186),
                                  fg=(109, 177, 255))

        self.basehealth = StatBar(" ", (80, 45),
                                  size=(150, 20),
                                  bg=(176, 185, 186),
                                  fg=(219, 40, 0))

        self.ebasehealth = StatBar(" ", (80, 15),
                                   size=(150, 20),
                                   bg=(176, 185, 186),
                                   fg=(109, 177, 255))

        self.text = Text(15, 80, "Base Health", bold=True, fontSize=18)

        self.etext = Text(45, 80, "Enemy Base Health", bold=True, fontSize=18)

        self.buildmenu.AddButton(self.buildhorserifleblaster)
        self.buildmenu.AddButton(self.buildrifleblaster)
        self.buildmenu.AddButton(self.buildspaceraider)
        self.buildmenu.AddButton(self.buildtank)

        b = Boombox()
        b.PlayMusic("level6playmusic")