Exemple #1
0
    def __init__(self, x, y, bild, eltern_flaeche=None, position_geaendert=lambda: None):
        """
        Ein neues Bild, das gezeichnet wird.

        :param x: die x-Position
        :type x: float
        :param y: die y-Position
        :type y: float
        :param bild: Entweder der Schlüssel für den BilderSpeicher oder eine pygame Surface
        :type bild: str|pygame.Surface
        :param alpha: Wahr, falls das Bild einen Alpha-Kanal hat (Transparenz)
        :type alpha: bool
        """
        if isinstance(bild, str):
            self.__pygame_bild = BildSpeicher.gib_pygame_bild(bild)
        elif isinstance(bild, pygame.Surface):
            self.__pygame_bild = bild
        else:
            raise ValueError("Bitte Schlüssel des Bildes im Bildspeicher angeben.")

        self.__orginal_pygame_surface = self.__pygame_bild
        self.__quelle = bild

        SkalierbaresElement.__init__(self, self)
        ZeichenbaresElement.__init__(self, x, y, self.__pygame_bild.get_width(), self.__pygame_bild.get_height(), farbe=None,
                                     eltern_flaeche=eltern_flaeche,
                                     position_geaendert=position_geaendert)
Exemple #2
0
    def __init__(self, pygame_flaechen_und_zeiten, wiederhole=False, alpha=True):
        """
        Ein neues Animationsobjekt.

        :param pygame_flaechen_und_zeiten:
        :param wiederhole:
        :param alpha:
        :raise AttributeError:
        """
        self._wiederhole_animation = wiederhole
        """
        Gibt an ob die Animation wiederholt wird oder nicht
        """
        self._flaechen_zeiten = []
        """
        :type: list[(ZeichenFlaeche, int)]
        """
        self._zeige_letztes_bild = False

        self._bild_gewechselt = EreignisBearbeiter()
        self._animation_gestartet = EreignisBearbeiter()
        self._animation_geendet = EreignisBearbeiter()

        self._gesamt_zeit = 0
        self._aktuelle_flaeche = 0
        self._zustand = GESTOPPT
        self._vergangen = 0
        self._gesamt_zeit = 0

        # zur Ermittlung der Dimension
        breite = 0
        hoehe = 0

        # Für klone()
        self.__quelle = pygame_flaechen_und_zeiten.copy()
        self.__alpha = alpha

        for zf in pygame_flaechen_und_zeiten:

            animations_bild = zf[0]

            # Die Fläche kann entweder aus einer Datei/ dem Bildspeicher geladen werden
            if isinstance(animations_bild, str):
                # Falls im Speicher, nehmen wir dieses Bild
                if BildSpeicher.ist_bild_vorhanden(animations_bild):
                    animations_bild = BildSpeicher.gib_pygame_flaeche(animations_bild)
                else:
                    # Ansonsten laden wir es
                    animations_bild = BildSpeicher.lade_bild_aus_datei(animations_bild, alpha)

            # oder schon eine pygame surface sein
            elif not isinstance(animations_bild, pygame.Surface):
                raise AttributeError("Entweder Surface oder Strings übergeben.")

            # die größten werte ermitteln
            if animations_bild.get_width() > breite:
                breite = animations_bild.get_width()
            if animations_bild.get_height() > hoehe:
                hoehe = animations_bild.get_height()

            # Zur List hinzufügen und Zeit addieren
            self._flaechen_zeiten.append((animations_bild, zf[1]))
            self._gesamt_zeit += zf[1]

        self.__rotations_flaechen = None
        self._anzahl_flaechen = len(self._flaechen_zeiten)

        SkalierbaresElement.__init__(self, self)
        ZeichenbaresElement.__init__(self, 0, 0, breite, hoehe, None)