Other changes...

Player.py

@@ -1,5 +1,58 @@
 import pygame
-
+import Utils
+import Animation
+ 
+# Die Player Klasse verwendet zwei Animationen, um eine steuerbare Spielfigur dazustellen.
 class Player(object):
-    def __init__(self) -> None:
+    def __init__(self):
-        pass
+        # Bild laden und erste Animation erstellen: 
+        self.anim_image_right = Utils.load_image("tileset.png", (255, 0, 255))
+        self.anim_right = Animation.Animation(self.anim_image_right, 32, 32, 2, 32, 64, 15)  
+ 
+        # Die Grafik spiegeln und in einer neuen Surface speichern,
+        # dann können wir die linke Animation erstellen.
+        self.anim_image_left = pygame.transform.flip(self.anim_image_right, True, False)
+        self.anim_left = Animation.Animation(self.anim_image_left, 32, 32, 2, 32, 64, 15)
+ 
+        # Start-Position des Players festlegen und
+        # merken in welche Richtung wir schauen und ob wir überhaupt laufen.
+        self.pos_x = 10*32
+        self.pos_y = 13*32        
+        self.dir = 0
+        self.walking = False
+ 
+ 
+    def render(self, screen):
+        # Die Blickrichtung ist links:
+        if self.dir == -1:
+            # Wenn der Spieler die linke oder rechte Pfeiltaste gedrückt hat sind wir am laufen,
+            if self.walking:                
+                # nur dann die Animation updaten.
+                self.anim_left.update()
+            # Blickrichtung links rendern.
+            self.anim_left.render(screen, (self.pos_x, self.pos_y))   
+        else:
+            # Und das gleiche nochmal für rechts:
+            if self.walking:
+                self.anim_right.update()
+            self.anim_right.render(screen, (self.pos_x, self.pos_y))
+ 
+        # De Laufen-Zustand zurücksetzen, im nächsten Frame bleiben wir stehen.
+        self.walking = False
+ 
+ 
+    def handle_input(self, key):
+        # Linke Pfeiltaste wird gedrückt:
+        if key == pygame.K_LEFT:
+            # x-Position der Spielfigur anpassen,
+            # die Blickrichtung festlegen
+            # und den Laufen-Zustand einschalten.
+            self.pos_x -= 1
+            self.dir = -1
+            self.walking = True
+ 
+        # Und nochmal für die rechte Pfeiltaste.
+        if key == pygame.K_RIGHT:
+            self.pos_x += 1
+            self.dir = 1
+            self.walking = True

Tilemap.py

@@ -1,61 +1,73 @@
 import pygame
-import random
 import Tileset
-
+import Player
+ 
+# Die Tilemap Klasse verwaltet die Tile-Daten, die das Aussehen der Karte beschreiben.
 class Tilemap(object):
-    def __init__(self) -> None:
+    def __init__(self):
-        self.tileset = Tileset.TileSet("tileset.png", (255,0,255), 32, 32)
+        # Wir erstellen ein neues Tileset.
+        # Hier im Tutorial fügen wir manuell vier Tile-Typen hinzu.
+        self.tileset = Tileset.TileSet("tileset.png", (255, 0, 255), 32, 32)
         self.tileset.add_tile("grass", 0, 0)
-        self.tileset.add_tile("mud", 32, 0)
+        self.tileset.add_tile("mud", 32, 0)        
-        self.tileset.add_tile("water", 64,0)
+        self.tileset.add_tile("grass-mud", 0, 64)
-        self.tileset.add_tile("block", 0, 32)
+        self.tileset.add_tile("empty", 0, 96)
-
+ 
+        # Festlegen der Startposition der Kamera. Hier (0, 0).
         self.camera_x = 0
         self.camera_y = 0
-
+ 
+        # Die Größe der Maps in Tiles.
         self.width = 30
         self.height = 25
-
+ 
+        # Erstellen einer leeren Liste für die Tile Daten.
         self.tiles = list()
-
+ 
+        # Sehr einfache Karte basteln:
         for i in range(0, self.height):
             self.tiles.append(list())
             for j in range(0, self.width):
-                if i == 15:
+                if i == 14:
-                    self.tiles[i].append("grass")
+                    self.tiles[i].append("grass") 
                 elif i == 15:
-                    self.tiles[i].append("water")
+                    self.tiles[i].append("grass-mud")
                 elif i > 15:
                     self.tiles[i].append("mud")
                 else:
                     self.tiles[i].append("empty")
-
+ 
+        # Player-Objekt erstellen.
+        self.player = Player.Player()
+ 
+ 
+    # Hier rendern wir den sichtbaren Teil der Karte.
     def render(self, screen):
-
+        # Zeilenweise durch die Tiles durchgehen.
         for y in range(0, int(screen.get_height() / self.tileset.tile_height) + 1):
+            # Die Kamera Position mit einbeziehen.
             ty = y + self.camera_y
             if ty >= self.height or ty < 0:
                 continue
-
+            # Die aktuelle Zeile zum einfacheren Zugriff speichern.
             line = self.tiles[ty]
-
+            # Und jetzt spaltenweise die Tiles rendern.
-            for x in range(0, int(screen.get_width() / self.tileset.tile_width)+ 1):
+            for x in range(0, int(screen.get_width() / self.tileset.tile_width) + 1):
+                # Auch hier müssen wir die Kamera beachten.
                 tx = x + self.camera_x
                 if tx >= self.width or tx < 0:
                     continue
+                # Wir versuchen, die Daten des Tiles zu bekommen.
                 tilename = line[tx]
                 tile = self.tileset.get_tile(tilename)
-
+                # Falls das nicht fehlschlägt können wir das Tile auf die screen-Surface blitten.
-                if tile is not None: 
+                if tile is not None:
                     screen.blit(self.tileset.image, (x * self.tileset.tile_width, y * self.tileset.tile_height), tile.rect)
-    
+ 
-    def handle_input(self, key):
+        # Und zuletzt den Player rendern.
-        if key == pygame.K_LEFT:
+        self.player.render(screen)
-            self.camera_x += 1
+ 
-        if key == pygame.K_RIGHT:
+ 
-            self.camera_x -= 1
+    # Tastendrücke an den Player weiterreichen:
-
+    def handle_input(self, key):        
-        if key == pygame.K_UP:
+        self.player.handle_input(key)
-            self.camera_y += 1
-        if key == pygame.K_DOWN:
-            self.camera_y -= 1

main.py

@@ -1,13 +1,13 @@
+# Pygame Modul importieren.
 import pygame
+ 
+# Unser Tilemap Modul
 import Tilemap
-import Animation
+ 
-
+# Überprüfen, ob die optionalen Text- und Sound-Module geladen werden konnten.
-pygame.init()
+if not pygame.font: print('Fehler pygame.font Modul konnte nicht geladen werden!')
-
+if not pygame.mixer: print('Fehler pygame.mixer Modul konnte nicht geladen werden!')
-WEISS = (255,255,255)
+ 
-SCHWARZ = (0,0,0)
-
-
 def main():
     # Initialisieren aller Pygame-Module und 
     # Fenster erstellen (wir bekommen eine Surface, die den Bildschirm repräsentiert).
@@ -15,11 +15,11 @@ def main():
     screen = pygame.display.set_mode((800, 600))
  
     # Titel des Fensters setzen, Mauszeiger nicht verstecken und Tastendrücke wiederholt senden.
-    pygame.display.set_caption("Pygame-Tutorial: Tilemap")
+    pygame.display.set_caption("Pygame-Tutorial: Animation")
     pygame.mouse.set_visible(1)
     pygame.key.set_repeat(1, 30)
  
-    # Clock Objekt erstellen, das wir benötigen, um die Framerate zu begrenzen.
+    # Clock-Objekt erstellen, das wir benötigen, um die Framerate zu begrenzen.
     clock = pygame.time.Clock()
  
     # Wir erstellen eine Tilemap.