コード例 #1
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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)
コード例 #2
0
    def speedEnemies(self, map_size: Vect2d) -> tuple:
        dist_target = float("inf")
        dist_hunter = float("inf")

        speed_target = None
        speed_hunter = None

        can_split = False

        score_target = None

        for enemy_pos, enemy_radius, enemy_score in self.creatures_info:
            dist = Vect2d.dist(self.pos,
                               enemy_pos) - self.radius - enemy_radius

            if Creature.canEat(enemy_score, self.score):
                if dist < dist_hunter:
                    speed_hunter = enemy_pos - self.pos
                    dist_hunter = dist

            elif Creature.canEat(self.score, enemy_score):
                if dist < dist_target:
                    speed_target = enemy_pos - self.pos
                    dist_target = dist
                    score_target = enemy_score

        if score_target is not None:
            if score_target < self.score // 2:
                if dist_target > self.radius and dist_target < self.radius * 2:
                    can_split = True

        if speed_hunter is None:
            speed_hunter = Vect2d(0, 0)

        if speed_target is None:
            speed_target = Vect2d(0, 0)

        coeff_target = 1 - dist_target / map_size.length()
        coeff_target = abs(coeff_target**3)

        if coeff_target == float("inf"):
            coeff_target = 0
        elif coeff_target >= 1:
            coeff_target = 1

        coeff_target = coeff_target if coeff_target != float("inf") else 0

        coeff_hunter = 1 - dist_hunter / map_size.length()
        coeff_hunter = abs(coeff_hunter**3)

        if coeff_hunter == float("inf"):
            coeff_hunter = 0
        elif coeff_hunter >= 1:
            coeff_hunter = 1

        return speed_target, coeff_target, speed_hunter, coeff_hunter, can_split
コード例 #3
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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())
コード例 #4
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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)
コード例 #5
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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)
コード例 #6
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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)
コード例 #7
0
ファイル: display.py プロジェクト: Rominos111/CruCru.io
    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())