Esempio n. 1
0
    def drawLine(cls,
                 pos1: Vect2d,
                 pos2: Vect2d,
                 color: Color,
                 base_pos: Vect2d = Vect2d(0, 0),
                 width: int = 1) -> None:
        """Procédure pour dessiner une ligne à l'écran

        Args:
            pos1 (Vect2d): position de départ
            pos2 (Vect2d): position d'arrivée
            color (Color): couleur de la ligne
            base_pos (Vect2d): position de référence de la fenêtre
            width (int): largeur de la ligne
        """

        pos1 = pos1.copy()
        pos2 = pos2.copy()

        if base_pos.length() != 0:
            pos1 = (pos1 - base_pos) * cls.zoom_factor
            pos2 = (pos2 - base_pos) * cls.zoom_factor

        pos1 = pos1.toIntValues()
        pos2 = pos2.toIntValues()

        if width == 1:
            pygame.gfxdraw.line(cls.window, pos1.x, pos1.y, pos2.x, pos2.y,
                                color)
        else:
            pygame.draw.line(cls.window, color, pos1.toTuple(), pos2.toTuple(),
                             width)
Esempio n. 2
0
    def drawRect(cls,
                 pos: Vect2d,
                 size: Vect2d,
                 color: Color,
                 base_pos: Vect2d = Vect2d(0, 0),
                 fill: bool = True) -> None:
        """Procédure pour dessiner un rectangle à l'écran

        Args:
            pos (Vect2d): position du coin en haut à gauche rectangle
            size (Vect2d): taille du rectangle
            color (Color): couleur RGBA
            base_pos (Vect2d): position de référence de la fenêtre
            fill (bool): rectangle rempli ou non
        """

        size = size.copy()
        pos = pos.copy()

        if base_pos.length() != 0:
            pos = (pos - base_pos) * cls.zoom_factor

        pos = pos.toIntValues()

        if base_pos.length() != 0:
            size *= cls.zoom_factor

        size = size.toIntValues()

        rect = pygame.Rect(pos.toTuple(), size.toTuple())

        if fill:
            pygame.gfxdraw.box(cls.window, rect, color)
        else:
            pygame.gfxdraw.rectangle(cls.window, rect, color)
Esempio n. 3
0
    def __init__(self, pos: Vect2d, name: str, color: Color, creature_id: int) -> None:
        """Constructeur

        Args:
            pos (Vect2d): position de la créature
            name (str): nom de la créature
            color (Color): couleur de la créature
            creature_id (int): id de la famille de la créature
        """

        self.family = [self]
        self.invincibility_family_time = time.time()
        self.creature_id = creature_id
        self.killer_id = None

        self.pos = pos.copy()
        self.speed = Vect2d(0, 0)
        self.direction = Vect2d(0, 0)
        self.split_speed = 0
        self.inertia = 0

        self.radius = self.BASE_RADIUS
        self.color = color
        self.opposite_color = Color.oppositeColor(color)
        self.name = name
        self.img = Skins.getRandomSkin()

        self.score = Creature.BASE_SCORE
        self.is_alive = True
Esempio n. 4
0
    def drawImg(cls,
                img: pygame.Surface,
                pos: Vect2d,
                base_pos: Vect2d = Vect2d(0, 0),
                radius: int = None) -> None:
        """Procédure pour dessiner une image circulaire à l'écran

        Args:
            img (pygame.Surface): image à dessiner
            pos (Vect2d): position de l'image
            base_pos (Vect2d): position de référence de la fenêtre
            radius (int): rayon désiré de l'image
        """

        pos = pos.copy()

        if base_pos.length() != 0:
            pos = (pos - base_pos) * cls.zoom_factor

        pos = pos.toIntValues()

        radius = int(radius * cls.zoom_factor)

        if radius is not None:
            pos -= Vect2d(radius, radius)
            img = pygame.transform.smoothscale(img, (radius * 2, radius * 2))
            # On agrandit (ou réduit) la taille de l'image

        cls.window.blit(img, pos.toTuple())
Esempio n. 5
0
    def drawCircle(cls,
                   pos: Vect2d,
                   color: Color,
                   radius: int,
                   base_pos: Vect2d = Vect2d(0, 0),
                   fill: bool = True) -> None:
        """Procédure pour dessiner un cercle à l'écran

        Args:
            pos (Vect2d): position du centre du cercle
            color (Color): couleur RGBA
            radius (int): rayon du cercle
            base_pos (Vect2d): position de référence de la fenêtre
            fill (bool): cercle rempli ou non
        """

        pos = pos.copy()

        if base_pos.length() != 0:
            pos = (pos - base_pos) * cls.zoom_factor

        pos = pos.toIntValues()

        radius = int(radius * cls.zoom_factor)

        if pos.x in range(-radius, cls.size.x + radius) and pos.y in range(
                -radius, cls.size.y + radius):
            if fill:
                pygame.gfxdraw.filled_circle(cls.window, pos.x, pos.y, radius,
                                             color)
                # Dessine un cercle plein

            pygame.gfxdraw.aacircle(cls.window, pos.x, pos.y, radius, color)
Esempio n. 6
0
    def drawTriangle(cls,
                     pos: Vect2d,
                     color: Color,
                     radius: int,
                     angle: float,
                     base_pos: Vect2d = Vect2d(0, 0),
                     fill: bool = True) -> None:
        """Procédure pour dessiner un triangle à l'écran

        Args:
            pos (Vect2d): position du centre du rectangle
            color (Color): couleur RGBA
            radius (int): distance du centre aux sommets
            base_pos (Vect2d): position de référence de la fenêtre
            fill (bool): triangle rempli ou non
        """

        pos = pos.copy()

        if base_pos.length() != 0:
            pos = (pos - base_pos) * cls.zoom_factor

        pos = pos.toIntValues()

        nodes = []
        # Sommets du triangle

        for i in range(3):
            local_angle = 2 * i * math.pi / 3 + angle

            nodes.append(
                int(pos.x + math.cos(local_angle) * radius * cls.zoom_factor))
            nodes.append(
                int(pos.y + math.sin(local_angle) * radius * cls.zoom_factor))

        if fill:
            pygame.gfxdraw.filled_trigon(cls.window, *nodes, color)
            # Triangle plein

        pygame.gfxdraw.aatrigon(cls.window, *nodes, color)
Esempio n. 7
0
    def drawText(
        cls,
        text: str,
        pos: Vect2d,
        size: int = 16,
        color: Color = Color.WHITE,
        base_pos: Vect2d = Vect2d(0, 0)) -> None:
        """Procédure pour afficher du texte à l'écran
        On essaie de garder en mémoire les polices chargées pour éviter de recharger la police à
        chaque frame

        Args:
            text (str): texte à afficher
            pos (Vect2d): position du texte
            size (int): taille de la police utilisée
            color (Color): couleur du texte, blanc par défaut
            base_pos (Vect2d): position de référence de la fenêtre
        """

        pos = pos.copy()

        if base_pos.length() != 0:
            pos = (pos - base_pos) * cls.zoom_factor

        pos = pos.toIntValues()

        if base_pos.length() != 0:
            size *= cls.zoom_factor

        font_size = round(size)

        if not (pos.x in range(-font_size * len(text),
                               cls.size.x + font_size * len(text))
                and pos.y in range(-font_size, cls.size.y + font_size)):
            return

        font_family = "comicsansms"

        if cls.all_font.get(font_family, None) is None:
            # Si la police n'existe pas encore

            cls.all_font[font_family] = {}

        if cls.all_font[font_family].get(size, None) is None:
            # Si la taille de la police n'existe pas encore

            cls.all_font[font_family][font_size] = pygame.font.SysFont(
                font_family, font_size)
            # On charge la police

        font = cls.all_font[font_family][font_size]
        # On utilise la police

        text = str(text)

        color = [
            int(color[i]) if color[i] <= 255 else 255
            for i in range(len(color))
        ]
        # On veut une couleur avec des nombres entiers

        text_surface = font.render(text, True, color)

        if len(color) == 4 and color[3] != 255:
            # Si la couleur a de la transparence

            alpha_img = pygame.Surface(text_surface.get_size(),
                                       pygame.SRCALPHA)
            alpha_img.fill((255, 255, 255, color[3]))
            text_surface.blit(alpha_img, (0, 0),
                              special_flags=pygame.BLEND_RGBA_MULT)

        size = Vect2d(text_surface.get_width(), text_surface.get_height())
        pos -= size // 2

        cls.window.blit(text_surface, pos.toTuple())