• Besprechung in großer Gruppe und Aufteilung der Aufgabenbereiche

• Einarbeitung in pygame

• Bewegtes Viereck in pygame erstellen

• Äußere Wände erstellt, damit Viereck nicht den screen verlässt*

  import pygame
  import sys
  import os
 
  pygame.init()
  screen = pygame.display.set_mode([600,600])
  clock = pygame.time.Clock() #legt fps fest
 
  def zeichnen():
      screen.fill((0,0,0)) #damit Hintergrund schwarz bleibt und nicht angemalt wird
      pygame.draw.rect(screen, (255,255,0), (x,y,breite,hoehe)) #der Spieler
      pygame.display.update()
 
  x = 300
  y = 300
  geschw = 10
  breite = 40
  hoehe = 40
 
  #Die Wände um den Screen
  linkeWand = pygame.draw.rect(screen, (0,0,0), (0,0,1,600), 0) #(x-Koordinate,y-Koordinate(linke 
  Ecke),Breite,Länge)
  rechteWand = pygame.draw.rect(screen, (0,0,0), (599,0,1,600), 0)
  untereWand = pygame.draw.rect(screen, (0,0,0), (0,599,600,1), 0)
  obereWand = pygame.draw.rect(screen, (0,0,0), (0,0,600,1), 0)
 
 
  go = True
  while go:
      for event in pygame.event.get():
          if event.type == pygame.QUIT: sys.exit() #damit das spiel besser beendet werden kann
 
      spielerRechteck = pygame.Rect(x,y,breite,hoehe)
      gedrueckt = pygame.key.get_pressed()
      if gedrueckt[pygame.K_UP] and not spielerRechteck.colliderect(obereWand):
          y -= geschw
      if gedrueckt[pygame.K_RIGHT] and not spielerRechteck.colliderect(rechteWand):
          x += geschw
      if gedrueckt[pygame.K_DOWN] and not spielerRechteck.colliderect(untereWand):
          y += geschw
      if gedrueckt[pygame.K_LEFT] and not spielerRechteck.colliderect(linkeWand):
          x -= geschw
 
      zeichnen()
      clock.tick(60)
 

• Innenwände vom Labyrinth in pygame erstellt und „undurchdringbar“ für den Spieler gemacht
• Klasse für den Spieler erstellt

  import os #Modul mit Funktionen fürs Betriebssystem
  import sys #liefert Funktionen und Variablen
  import random
  import pygame
 
  #Klasse für den spieler
  class Spieler(object):
 
      def init(self):
          self.rect = pygame.Rect(32, 32, 16, 16)    #SpielerRechteck wird erzeugt
 
      def move(self, dx, dy):
 
          if dx != 0:
              self.move_single_axis(dx, 0) #Spielerrechteck wird in dx Richtung bewegt
          if dy != 0:
              self.move_single_axis(0, dy)
 
      def move_single_axis(self, dx, dy):
 
          self.rect.x += dx
          self.rect.y += dy
 
          #Wandkollisionen abchecken
          for wall in walls:
              if self.rect.colliderect(wall.rect):
                  if dx > 0: #Bewegung nach rechts, linke Seite der Wand
                      self.rect.right = wall.rect.left
                  if dx < 0: #Bewegung nach links, linke Seite der Wand
                      self.rect.left = wall.rect.right
                  if dy > 0: #Bewegung nach untem, obere Seite der Wand
                      self.rect.bottom = wall.rect.top
                  if dy < 0: #Bewegung nach oben, untere Seite der Wand
                      self.rect.top = wall.rect.bottom
 

 
#Klasse für Wände
class Wall(object):
    def __init__(self, pos):
        walls.append(self)
        self.rect = pygame.Rect(pos[0], pos[1], 16, 16)
 
#Spiel wird initialisiert
os.environ["SDL_VIDEO_CENTERED"] = "1" #Fenster wird in der Mitte des Bildschirms platziert
pygame.init()
 
#Display-Einstellungen
pygame.display.set_caption("Finde den Ausgang des Labyrinths!")
screen = pygame.display.set_mode((320,240))
 
clock = pygame.time.Clock()
walls = [] #auf die Liste wird in der Klasse zugegriffen
spieler = Spieler()
 
#Levellayout als string
level = [
    "WWWWWWWWWWWWWWWWWWWW",
    "W                  W",
    "W   WWW WWW WWWWWWWW",
    "W   W W W W W      W",
    "WW WW W W W   WWWW W",
    "W  W  W     W W  W W",
    "W WW WWWWWWWW W WW W",
    "W W           W W  W",
    "W WWWWWWWWWWWWW W WW",
    "W     W W       W  W",
    "W WWW W   W WW WWW W",
    "W   WWWWW WWW      W",
    "W WWW   W   W WWWWWW",
    "W     W W W W      W",
    "WWWWWWWWWWWEWWWWWWWW",
]
 
#W als Wand definieren und E als Ausgang
x = y = 0
for row in level:
    for col in row: #einzelnen Einträge in der Reihe werden nach und nach überprüft
        if col == "W":
            Wall((x, y)) #es wird auf Wall Klasse zugegriffen
        if col == "E":
            end_rect = pygame.Rect(x, y, 16, 16)
        x += 16 #immer 16, da ein Buchstabe 16 Pixel entspricht
    y += 16
    x = 0
 
running = True
while running:
 
    clock.tick(60) #Zeit wird festgelegt
 
    for e in pygame.event.get(): #alles was der Nutzer macht
        if e.type == pygame.QUIT:
            running = False
        if e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE: #spiel beenden mit esc
            running = False
 
    #Spieler bewegen
    key = pygame.key.get_pressed()
    if key[pygame.K_LEFT]:
        spieler.move(-2, 0)
    if key[pygame.K_RIGHT]:
        spieler.move(2, 0)
    if key[pygame.K_UP]:
        spieler.move(0, -2)
    if key[pygame.K_DOWN]:
        spieler.move(0, 2)
 
    #Spiel beenden durch berühren des roten Rechtecks
    if spieler.rect.colliderect(end_rect):
        pygame.quit()
        sys.exit()
 
    #Farben und so
    screen.fill((0, 0, 0))
    for wall in walls:
        pygame.draw.rect(screen, (255, 255, 255),wall.rect)
    pygame.draw.rect(screen, (0, 0, 0), end_rect)
    pygame.draw.rect(screen, (255, 200, 0), spieler.rect)
    pygame.display.flip() #nur Teil des screens wird geupdatet
    clock.tick(360)
 
pygame.quit()

• Start und Endbildschirm für pygame und Besprechung mit Gruppe 1

  import os #Modul mit Funktionen fürs Betriebssystem
  import sys #liefert Funktionen und Variablen
  import random
  import pygame
 
  #Klasse für den spieler
  class Spieler(object):
 
      def init(self):
          self.rect = pygame.Rect(32, 32, 16, 16)    #SpielerRechteck wird erzeugt
 
      def move(self, dx, dy):
 
          if dx != 0:
              self.move_single_axis(dx, 0) #Spielerrechteck wird in dx Richtung bewegt
          if dy != 0:
              self.move_single_axis(0, dy)
 
      def move_single_axis(self, dx, dy):
 
          self.rect.x += dx
          self.rect.y += dy
 
          #Wandkollisionen abchecken
          for wall in walls:
              if self.rect.colliderect(wall.rect):
                  if dx > 0: #Bewegung nach rechts, linke Seite der Wand
                      self.rect.right = wall.rect.left
                  if dx < 0: #Bewegung nach links, linke Seite der Wand
                      self.rect.left = wall.rect.right
                  if dy > 0: #Bewegung nach untem, obere Seite der Wand
                      self.rect.bottom = wall.rect.top
                  if dy < 0: #Bewegung nach oben, untere Seite der Wand
                      self.rect.top = wall.rect.bottom
 
  #Klasse für Wände
  class Wall(object):
      def init(self, pos):
          walls.append(self)
          self.rect = pygame.Rect(pos[0], pos[1], 16, 16)
          self.screen = pygame.display.set_mode((320,240))
 
 
      def draw_text(self, words, screen, pos, size, colour, font_name, centered = False):
          screen = pygame.display.set_mode((320,240))
          font = pygame.font.SysFont(font_name, size)
          text = font.render(words, False, colour)
          text_size = text.get_size()
          if centered:
              pos[0] = pos[0]-text_size[0]//2
              pos[1] = pos[1]-text_size[1]//2
          screen.blit(text, pos)
 
 
      def start_draw(self):
          screen = pygame.display.set_mode((320,240))
          self.screen.fill((0,0,0))
          self.draw_text('You win', self.screen, [
                         160, 120-50], 16, (170, 132, 58), 'arial black', centered=True)
          for e in pygame.event.get(): #alles was der Nutzer macht
              if e.type == pygame.QUIT:
                  pygame.quit()
          pygame.display.update()
 
 
 
 
  #Spiel wird initialisiert
  os.environ["SDL_VIDEO_CENTERED"] = "1" #Fenster wird in der Mitte des Bildschirms platziert
  pygame.init()
 
  #Display-Einstellungen
  pygame.display.set_caption("Finde den Ausgang des Labyrinths!")
  screen = pygame.display.set_mode((320,240))
 
  clock = pygame.time.Clock()
  walls = [] #auf die Liste wird in der Klasse zugegriffen
  spieler = Spieler()
 
  #Levellayout als string
  level = [
      "WWWWWWWWWWWWWWWWWWWW",
      "W                  W",
      "W   WWW WWW WWWWWWWW",
      "W   W W W W W      W",
      "WW WW W W W   WWWW W",
      "W  W  W     W W  W W",
      "W WW WWWWWWWW W WW W",
      "W W           W W  W",
      "W WWWWWWWWWWWWW W WW",
      "W     W W       W  W",
      "W WWW W   W WW WWW W",
      "W   WWWWW WWW      W",
      "W WWW   W   W WWWWWW",
      "W     W W W W      W",
      "WWWWWWWWWEWWWWWWWWWW",
  ]
 
  #W als Wand definieren und E als Ausgang
  x = y = 0
  for row in level:
      for col in row: #einzelnen Einträge in der Reihe werden nach und nach überprüft
          if col == "W":
              Wall((x, y)) #es wird auf Wall Klasse zugegriffen
          if col == "E":
              end_rect = pygame.Rect(x, y, 16, 16)
          x += 16 #immer 16, da ein Buchstabe 16 Pixel entspricht
      y += 16
      x = 0
 
  black=(0,0,0)
  end_it=False
  while (end_it==False):
      screen.fill(black)
      myfont=pygame.font.SysFont("Britannic Bold", 40)
      nlabel=myfont.render("2D-Labyrinth-SpAß", 1, (255, 0, 0))
      alabel=myfont.render("click to start :)", 1, (255,255,0))
      for event in pygame.event.get():
          if event.type==pygame.MOUSEBUTTONDOWN:
              end_it=True
      screen.blit(nlabel,(25,100))
      screen.blit(alabel,(50,130))
      pygame.display.flip()
 
  running = True
  state = True
 
  while running:
      while state:
          clock.tick(60) #Zeit wird festgelegt
 
          for e in pygame.event.get(): #alles was der Nutzer macht
              if e.type == pygame.QUIT:
                  running = False
              if e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE: #spiel beenden mit esc
                  running = False
 
          #Spieler bewegen
          key = pygame.key.get_pressed()
          if key[pygame.K_LEFT]:
              spieler.move(-2, 0)
          if key[pygame.K_RIGHT]:
              spieler.move(2, 0)
          if key[pygame.K_UP]:
              spieler.move(0, -2)
          if key[pygame.K_DOWN]:
              spieler.move(0, 2)
 
          #Farben und so
          screen.fill((0, 0, 0))
          for wall in walls:
              pygame.draw.rect(screen, (255, 255, 255),wall.rect)
          pygame.draw.rect(screen, (0, 0, 0), end_rect)
          pygame.draw.rect(screen, (255, 200, 0), spieler.rect)
          pygame.display.flip() #nur Teil des screens wird geupdatet
          clock.tick(360)
 
 
          #Spiel beenden durch berühren des roten Rechtecks
          if spieler.rect.colliderect(end_rect):
              state = False
 
      while not state:
          wall.start_draw()
          running = False
          for e in pygame.event.get(): #alles was der Nutzer macht
              if e.type == pygame.QUIT:
                  running = False
 
 
 
  pygame.quit()

• „Randomizen“ des Labyrinths durch Material von Gruppe 1
• Präsentation machen und üben

• Es muss „Spiel“ ausgeführt werden

4d_labyrinth_spiel.zip

https://pythonprogramming.altervista.org/simple-labytinth-in-pygame/?doing_wp_cron=1625750416.7036309242248535156250