Esempio n. 1
0
def finish(score: int, total: int, screen: pg.Surface, font: pg.font.Font,
           background: pg.Surface):
    screen.fill('black')
    screen.blit(background, (0, 0))
    screen.blit(background, (0, 300))
    first_text = font.render('Вы набрали %d очков из %d' % (score, total),
                             True, pg.Color('red'))
    second_text = font.render('Чтобы начать заново,', True, pg.Color('red'))
    third_text = font.render('нажмите пробел', True, pg.Color('red'))
    width, height = screen.get_size()
    screen.blit(first_text,
                (width // 2 - first_text.get_width() // 2, height // 2 -
                 first_text.get_height() // 2 - second_text.get_height()))
    screen.blit(second_text,
                (width // 2 - second_text.get_width() // 2, height // 2 -
                 second_text.get_height() // 2 + second_text.get_height()))
    screen.blit(third_text,
                (width // 2 - third_text.get_width() // 2, height // 2 -
                 second_text.get_height() // 2 + second_text.get_height() * 2))
    pg.display.flip()
    while True:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                return False
            elif event.type == pg.KEYDOWN and event.key == pg.K_SPACE:
                return True
Esempio n. 2
0
	def __init__(self, title: str, pos: Tuple[int, int], title_font: pygame.font.Font):
		self.title = title_font.render(title, True, (244, 221, 183))
		self.shadow = title_font.render(title, True, (61, 49, 42))

		self.title_pos = self.title.get_rect(center=pos)
		self.shadow_pos = self.shadow.get_rect(center=(pos[0] + 10, pos[1] + 2))

		self.menu: List[MenuButton] = []
def update_screen(f: pygame.font.Font) -> None:
    gl.SCREEN.fill(gl.PALEBLUE)
    pygame.draw.line(gl.SCREEN, gl.WHITE, [0, 30], [gl.WIDTH, 30], 2)
    text = f.render("Score: " + str(score), 1, gl.WHITE)
    gl.SCREEN.blit(text, (20, 10))
    text = f.render("Lives: " + str(lives), 1, gl.WHITE)
    gl.SCREEN.blit(text, (gl.WIDTH - 150, 10))
    gl.SPRITES.draw(gl.SCREEN)

    pygame.display.flip()
    gl.CLOCK.tick(60)
Esempio n. 4
0
    def draw(self, screen: pygame.Surface, font: pygame.font.Font):
        pygame.draw.rect(screen, self.color,
                         [self.x, self.y, Sett.gridSize, Sett.gridSize])
        displayValue = self.value if self.value != math.inf else 'inf'
        textsurface = font.render(str(displayValue), False, Sett.WHITE)
        screen.blit(
            textsurface,
            (self.x + Sett.gridSize / 2 - 10, self.y + Sett.gridSize / 2 - 10))

        textsurface = font.render(self.name, False, Sett.DARK_VIOLET)
        screen.blit(textsurface, (self.x - 20, self.y - 20))
Esempio n. 5
0
def score_display(game_font: pygame.font.Font, score: int, high_score: int,
                  game_active: bool, screen) -> None:
    score_surface = game_font.render(f"Score: {int(score)}", True,
                                     (255, 255, 255))
    score_rect = score_surface.get_rect(center=(288, 100))
    screen.blit(score_surface, score_rect)
    if not game_active:
        high_score_surface = game_font.render(f"High Score: {int(high_score)}",
                                              True, (255, 255, 255))
        high_score_rect = high_score_surface.get_rect(center=(288, 850))
        screen.blit(high_score_surface, high_score_rect)
Esempio n. 6
0
 def __init__(self, text: str, font: pygame.font.Font,
              action_handler: ClickHandler) -> None:
     super().__init__()
     self.text = text
     self.text_surface = font.render(text, True, BLACK)
     self.text_surface_active = font.render(text, True, WHITE)
     self.text_rect = self.text_surface.get_rect()
     self.rect = self.text_surface.get_rect().copy()
     self.rect.width += 10
     self.rect.height += 10
     self.action_handler = action_handler
     self.focused = False
     self.hovering = False
Esempio n. 7
0
 def __init__(self, font: pygame.font.Font, message: str):
     self.font = font
     self.message = message
     self.image = pygame.Surface(300, 100)
     self.rect = self.image.get_rect().move(200, 100)
     message_rendered = font.render(message, False, cfg.WHITE)
     self.image.blit(message_rendered, (0, 0))
Esempio n. 8
0
 def __init__(self, teamID, x, y, font:pygame.font.Font):
     super().__init__(teamID, x, y, font)
     self.name = font.render("Cloning", True, (200, 200, 180))
     self.sprID = 4
     self.sprite = SPR_CLONE
     self.buildOptions.append(Button(SPR_CLONE[0], self.font, "Upgrade", cost={'$':80, 'ß':30, '¶':0}, rate=1))
     self.buildOptions.append(Button(SPR_MAKEBODY[0], self.font, "Clone Bodies", additionalText="Gain ¶1/2 sec", rate=2.125))
Esempio n. 9
0
 def add_text(self, text, font: pygame.font.Font, colour=(0, 0, 0), *args, **kwargs):
     """
         Adds text as content.
     """
     blit = font.render(text, True, colour)
     self._content.append(self.PanelContent(self._content_offset, self.next_y(), text, blit))
     self._redraw()
Esempio n. 10
0
    def __init__(self, text: str, font: pygame.font.Font,
                position: tuple, dims: tuple, func, arg: list = None, keybinding=None,
                text_aa=True, text_colour: tuple = (255, 255, 255),
                background_colour: tuple = (40, 40, 40), border_colour: tuple = (0, 0, 0), border_width: int = 1,
                expand: bool = True, padx: int = 0, pady: int = 0, centered: bool = True, *args, **kwargs):
        self._text = text
        self._func = func
        self._args = arg
        # Create the text blit of the button
        txt_blit = font.render(text, text_aa, text_colour)
        txt_dims = (txt_blit.get_width(), txt_blit.get_height())

        # IF we want to expand, check if the text is bigger than the given dimensions
        if not expand:
            self._dims = dims
        else:
            self._dims = (max(txt_dims[0], dims[0]) + padx, max(txt_dims[1], dims[1]) + pady)

        # Create the final surface and apply the background colour and border
        blit = pygame.Surface(self._dims, pygame.SRCALPHA, 32).convert_alpha()
        blit.fill(background_colour)
        if border_width > 0:
            pygame.draw.rect(blit, border_colour, pygame.Rect(0, 0, self._dims[0], self._dims[1]), border_width)

        # Blit the text to it
        blit.blit(txt_blit, (self._dims[0] / 2 - txt_dims[0] / 2, self._dims[1] / 2 - txt_dims[1] / 2))

        self._blit = blit
        if centered:
            self._position = (position[0] - blit.get_width() / 2, position[1] - blit.get_height() / 2)
        else:
            self._position = position
        self._hidden = False

        self._keybinding = keybinding
Esempio n. 11
0
def _print_to_image(text: str, x: int, y: int, font: pygame.font.Font,
                    image: pygame.Surface,
                    colour: Tuple[int, int, int] = TEXT_COLOUR) -> None:
    """Use <font> to print <text> to (<x>, <y>) on <image> with <colour>.
    """
    text_surface = font.render(text, 1, colour)
    image.blit(text_surface, (x, y))
Esempio n. 12
0
File: main.py Progetto: vitiasr/labF
def draw_text(surface: pg.Surface, font: pg.font.Font, text: str, color,
              rect: pg.Rect):
    """
    Draws outlined text to the given surface
    """
    render = font.render(text, False, color)
    outline = font.render(text, False, TEXT_OUTLINE_COLOR)
    surface.blit(outline,
                 [rect.x - TEXT_OUTLINE_THICKNESS, rect.y, *rect.size])
    surface.blit(outline,
                 [rect.x + TEXT_OUTLINE_THICKNESS, rect.y, *rect.size])
    surface.blit(outline,
                 [rect.x, rect.y - TEXT_OUTLINE_THICKNESS, *rect.size])
    surface.blit(outline,
                 [rect.x, rect.y + TEXT_OUTLINE_THICKNESS, *rect.size])
    surface.blit(render, rect)
Esempio n. 13
0
    def __init__(self, x: int, y: int, width: int, height: int,
                 surface: pygame.Surface, surface_hover: pygame.Surface,
                 surface_click: pygame.Surface, text: str,
                 text_color: (int, int, int), font: pygame.font.Font,
                 on_click: Callable[[], None]):
        super().__init__()

        # Scale the images to the desired size (doesn't modify the originals).
        self.surface = pygame.transform.scale(surface, (width, height))
        self.surface_hover = pygame.transform.scale(surface_hover,
                                                    (width, height))
        self.surface_click = pygame.transform.scale(surface_click,
                                                    (width, height))

        self.image = self.surface

        self.rect = self.surface.get_rect(topleft=(x, y))

        image_center = self.surface.get_rect().center
        text_surface = font.render(text, True, text_color)
        text_rect = text_surface.get_rect(center=image_center)

        # Blit the text onto the images.
        for image in (self.surface, self.surface_hover, self.surface_click):
            image.blit(text_surface, text_rect)

        self.on_click = on_click
        self.is_clicked = False
Esempio n. 14
0
    def blit(self, dims, text_font: pygame.font.Font):
        """
            Returns the blit of the map.
        """
        surface = pygame.Surface(dims, pygame.SRCALPHA, 32).convert_alpha()
        for place in self._places:
            pairs = place.connection_points()
            for a, b in pairs:
                self._draw_bezier(surface, a, b)
        for place in self._places:
            blit = place.blit()
            if blit:
                if place == self._selected_place:
                    blit.fill((0, 120, 240, 20),
                              special_flags=pygame.BLEND_RGB_MULT)
                txt_blit = text_font.render(place.name, True, (0, 0, 0))

                x, y = blit.get_size()
                x = x / 2 - txt_blit.get_width() / 2
                y = y / 2 - txt_blit.get_height() / 2

                blit.blit(txt_blit, (x, y))
                surface.blit(blit, place.position)

        return surface
Esempio n. 15
0
 def draw_middle_text(self, string, font: pygame.font.Font, space):
     text = font.render(string, False, (255, 255, 255))
     text_rect = text.get_rect()
     coordinates = (self.width / 2 - text_rect.width / 2,
                    self.height / 2 - text_rect.height / 2)
     self.screen.blit(text, (coordinates[0], coordinates[1] + space))
     return space + font.get_linesize() - 4 * self.pixel_scale
def render_white_text_alpha_black_bg(font: pygame.font.Font,
                                     text: str) -> pygame.surface.Surface:
    """
    Render text with a zero alpha background with 0 in the other colour channels. Appropriate for
    use with BLEND_PREMULTIPLIED and for colour/gradient multiplication.
    """
    if USE_PREMULTIPLIED_ALPHA:
        text_render = font.render(text, True, pygame.Color('#FFFFFFFF'))
        final_surface = pygame.surface.Surface(text_render.get_size(),
                                               flags=pygame.SRCALPHA,
                                               depth=32)
        # Can't be exactly transparent black or we trigger SDL1 'bug'
        final_surface.fill(pygame.Color('#00000001'))
        final_surface.blit(text_render, (0, 0))
        return final_surface
    else:
        return font.render(text, True, pygame.Color('#FFFFFFFF'))
Esempio n. 17
0
    def drawText(self,
                 text,
                 color,
                 shadow_color,
                 rect,
                 font: pygame.font.Font,
                 scale=False):
        rect = pygame.Rect(rect)
        y = rect.top
        lineSpacing = -2

        fontHeight = font.size("Tg")[1]

        while text:
            i = 1

            if y + fontHeight > rect.bottom:
                break

            while font.size(text[:i])[0] < rect.width and i < len(text):
                i += 1

            if i < len(text):
                i = text.rfind(" ", 0, i) + 1

            image = font.render(text[:i], False, color).convert_alpha()
            shadow = font.render(text[:i], False, shadow_color).convert_alpha()

            if scale:
                image = pygame.transform.smoothscale(image, (int(
                    image.get_rect().size[0] * 0.9), image.get_rect().size[1]))
                shadow = pygame.transform.smoothscale(
                    shadow, (int(shadow.get_rect().size[0] * 0.9),
                             shadow.get_rect().size[1]))

            self.screen.blit(shadow,
                             (rect.left + (self.window_size[0] / 240) *
                              (fontHeight / 36), y +
                              (self.window_size[1] / 160) * (fontHeight / 36)))
            self.screen.blit(image, (rect.left, y))
            y += fontHeight + lineSpacing

            text = text[i:]

        return text
Esempio n. 18
0
def _get_instruction_surfaces(instructions, font: pygame.font.Font, color,
                              padding: int):
    instruction_surfaces = []
    for el in instructions:
        keys, instruction_text = el["keys"], el["text"]
        text_surface = font.render(instruction_text, True, color)
        instruction_surface = InstructionSurface(keys, text_surface, padding)
        instruction_surfaces.append(instruction_surface)
    return instruction_surfaces
Esempio n. 19
0
def objets_texte(texte: str, police: pygame.font.Font) -> (list, list):
    """Une fonction qui retourne un texte comme surface, et le rectangle couvert par le texte

    :param texte: (str) qui est le texte destiné à être transformé en objet Surface
    :param police: la police du texte
    :return: le texte comme objet surface et le rectangle couvert par le texte
    """
    surface_texte = police.render(texte, True, (0, 0, 0))
    return surface_texte, surface_texte.get_rect()
Esempio n. 20
0
 def draw_score(self, window: pygame.Surface, font: pygame.font.Font):
     transparent_rect = pygame.Surface((95, 25), pygame.SRCALPHA)
     transparent_rect.fill((50, 50, 50, 80))
     message = f"Score: {self.score} "
     w, h = font.size(message)
     window.blit(pygame.transform.scale(transparent_rect, (w, h)),
                 (8, Application.WINDOW_HEIGHT - 30))
     window.blit(font.render(message, True, (255, 255, 255)),
                 (10, Application.WINDOW_HEIGHT - 30))
Esempio n. 21
0
 def __init__(self, teamID, x, y, font:pygame.font.Font):
     super().__init__(teamID, x, y, font)
     self.name = font.render("Empty Space", True, (200, 200, 180))
     self.sprID = 0
     self.buildOptions.append(Button(SPR_FORGE[0], self.font, "Build Forge", cost={'$':50, 'ß':0, '¶':0}, rate=1))
     self.buildOptions.append(Button(SPR_ARMOR[0], self.font, "Build Armory", cost={'$':50, 'ß':0, '¶':0}, rate=1))
     self.buildOptions.append(Button(SPR_CLONE[0], self.font, "Build Cloning", cost={'$':30, 'ß':0, '¶':0}, rate=1))
     self.buildOptions.append(Button(SPR_MINES[0], self.font, "Build Mines", cost={'$':30, 'ß':0, '¶':0}, rate=1))
     self.sprite = SPR_EMPTY
Esempio n. 22
0
def createTextObj(text: str, font_object: pygame.font.Font):
    """
    Creates a text object with a string and a font
    :type font_object: pygame.font.Font(font_name, 75)
    :param text: string to display
    :param font_object: font in which to display text
    :return: a surface with the text and its rect
    """
    textSurface = font_object.render(text, True, colors["white"])
    return textSurface, textSurface.get_rect()
Esempio n. 23
0
 def create_text_obj(self,
                     text: str,
                     font: pg.font.Font = None,
                     color=(255, 0, 0),
                     **kwargs_rect) -> Tuple[pg.Surface, pg.Rect]:
     if font is None:
         font = self.default_font
     surface = font.render(text, 1, color)
     rect = surface.get_rect(**kwargs_rect)
     return surface, rect
Esempio n. 24
0
 def __init__(self, teamID, x, y, font:pygame.font.Font):
     super().__init__(teamID, x, y, font)
     self.name = font.render("Armory", True, (200, 200, 180))
     self.sprID = 2
     self.sprite = SPR_ARMOR
     self.buildOptions.append(Button(SPR_ARMOR[0], self.font, "Upgrade", cost={'$':80, 'ß':30, '¶':0}, rate=1))
     if teamID == 0:
         self.buildOptions.append(Button(Units.SPR_B2IR[0], self.font, "Produce Sword", cost={'$':10, 'ß':0, '¶':1}, rate = 3))
     if teamID == 1:
         self.buildOptions.append(Button(Units.SPR_R2IL[0], self.font, "Produce Sword", cost={'$':10, 'ß':0, '¶':1}, rate = 3))
     self.buildOptions.append(Button(SPR_CLONE[0], self.font, "Weapons Research", additionalText="Generates: ß1/sec", rate=4.25))
Esempio n. 25
0
 def __init__(self, teamID, x, y, font:pygame.font.Font):
     super().__init__(teamID, x, y, font)
     self.name = font.render("Mine", True, (200, 200, 180))
     self.sprID = 3
     self.sprite = SPR_MINES
     self.buildOptions.append(Button(SPR_MINES[0], self.font, "Upgrade", cost={'$':80, 'ß':30, '¶':0}, rate=1))
     self.buildOptions.append(Button(SPR_DOLLAR[0], self.font, "Mine Resources", additionalText="Generates: $1/sec", rate=4.25))
     if teamID == 0:
         self.buildOptions.append(Button(Units.SPR_BIR[0], self.font, "Call Militia", cost={'$':5, 'ß':0, '¶':1}, rate = 3))
     if teamID == 1:
         self.buildOptions.append(Button(Units.SPR_RIL[0], self.font, "Call Militia", cost={'$':5, 'ß':0, '¶':1}, rate = 3))
Esempio n. 26
0
 def __init__(self,
              text: str,
              font: pygame.font.Font,
              color: pygame.Color,
              margin: typing.Optional[typing.Tuple[int, int, int,
                                                   int]] = (0, 0, 0, 0)):
     super().__init__(margin)
     self.__text = text
     self.__font = font
     self.__color = color
     self.__surface = font.render(text, False, color)
Esempio n. 27
0
 def draw(self, window: pygame.Surface, font: pygame.font.Font, camera):
     view = camera.get_view()
     pygame.draw.circle(window, BLUE,
                        (self.vec2.x + view.x, self.vec2.y + view.y),
                        self.size * camera.zoom)
     text = font.render(self.name, True, WHITE)
     text_rect = text.get_rect(center=(self.vec2.x + view.x,
                                       self.vec2.y + view.y))
     window.blit(text, text_rect)
     # Draw score
     self.draw_score(window, font)
Esempio n. 28
0
 def __init__(self,
         x             : int,
         y             : int,
         text          : Union[str,"pygame.image"],
         callback      : Callable,
         font          : pygame.font.Font = FONT_MENU_ITEM,
         fontAntialias : bool = True,
         fontColor     : Union[Tuple[int,int,int], pygame.Color] = (0, 0, 0),
         background    : Optional[Union[Tuple[int,int,int], pygame.Color]] = None,
         **kwargs
     ) -> None:
     # use kwargs["padding"] to initially define padding
     self.padding = kwargs.get("padding", 0)
     if isinstance(self.padding, int):
         self.padding = dict((side, self.padding) for side in Side)
     for side in Side:
         # update ``padding[side]`` individually
         self.padding[side] = kwargs.get("padding_{}".format(side), self.padding[side])
     self.font = font
     if isinstance(text, str):
         self.text_surface = font.render(text, fontAntialias, fontColor)
     else:
         # assuume it is a surface
         self.text_surface = text  # great names.. best names.. big hands.. fake news
     self.text_pos = kwargs.get("text_pos", (0, 0))
     w, h = (sum(t)
             for t in zip(
                 self.text_surface.get_size(),
                 self.text_pos,
                 (self.padding[Side.left], self.padding[Side.top]),
                 (self.padding[Side.right], self.padding[Side.bottom])))
     super().__init__(x, y, w, h, **kwargs)
     self.rect = pygame.Rect(
         (x, y),
         tuple(sum(t) for t in zip(
             self.text_surface.get_size(),
             self.text_pos,
             (self.padding[Side.left], self.padding[Side.top]),
             (self.padding[Side.right], self.padding[Side.bottom]),
         ))
     )
     if isinstance(text, str):
         if self.background is None:
             self.surface.fill((1, 1, 1))
             self.surface.set_colorkey((1, 1, 1))
         else:
             self.surface.fill(background)
         self.surface.blit(self.text_surface, self.text_pos)
     else:
         # assume it's a surface
         self.surface = text  # great names.. best names.. big hands.. fake news
     self.text_pos = tuple(sum(t) for t in zip(self.text_pos, (self.padding[Side.left], self.padding[Side.top])))
     self.callback = callback
Esempio n. 29
0
 def __init__(self,
              lbl_msg: str,
              pos: tuple,
              font: pygame.font.Font = main_font(2),
              color: tuple = (0, 0, 0),
              has_rect: bool = False,
              rect_color: tuple = (255, 255, 255)):
     self.lbl_obj = font.render(lbl_msg, 0, color)
     self.lbl_box = self.lbl_obj.get_rect()
     self.lbl_box.topleft = pos
     self.has_rect = has_rect
     self.rect_color = rect_color
Esempio n. 30
0
def update_screen(bf: pygame.font.Font, nf: pygame.font.Font, curr_score: int,
                  scores: List):
    gl.SPRITES.update()
    gl.SCREEN.fill(gl.PALEBLUE)
    gl.SPRITES.draw(gl.SCREEN)
    text = bf.render("Congratulation!", 1, gl.WHITE)
    gl.SCREEN.blit(text, (int(gl.WIDTH / 2 - text.get_width() / 2), 100))
    text = nf.render("Your score: " + str(curr_score), 1, gl.WHITE)
    gl.SCREEN.blit(text, (int(gl.WIDTH / 2 - text.get_width() / 2), 175))

    text = nf.render("High scores:", 1, gl.WHITE)
    gl.SCREEN.blit(text, (int(gl.WIDTH / 2 - text.get_width() / 2),
                          300 - text.get_height() - 10))
    for i in range(len(scores)):
        text = nf.render(f'{i+1}.   {scores[i]}', 1, gl.WHITE)
        gl.SCREEN.blit(text,
                       (int(gl.WIDTH / 2 - text.get_width() / 2), 300 + i *
                        (text.get_height() + 10)))

    pygame.display.flip()
    gl.CLOCK.tick(60)
Esempio n. 31
0
def game_loop(screen: pygame.Surface, font: pygame.font.Font) -> None:
    clock = pygame.time.Clock()
    snake = Snake()
    fruit = Fruit()

    # sound = pygame.mixer.Sound("/tmp/peep.ogg")

    while True:
        events = pygame.event.get()
        handle_quit(events)

        # paint the entire screen
        screen.fill(pygame.color.Color("black"))

        if snake.pos_x == fruit.pos_x and snake.pos_y == fruit.pos_y:
            # sound.play()
            snake.increase()
            fruit.regenerate()

        if snake.tail_collision():
            snake.reset()

        # paint the snake
        snake.update(events)
        snake.draw(screen)

        # paint the fruit
        fruit.update()
        fruit.draw(screen)

        score = font.render(
            "score: %s" % snake.tail, 1, pygame.color.Color("white"))
        screen.blit(score, (0, 0))

        # update the screen
        pygame.display.update()

        # deal with frames per second
        clock.tick(FPS)