Mathesis Wiki

• 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)) #circle gibts auch
    pygame.display.update()
  
x = 300
y = 300
geschw = 10
breite = 40
hoehe = 40

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

• 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
• Fertiges Spiel mit allen benötigten Dateien:
• 4d_labyrinth_spiel.zip

Es muss „Spiel“ ausgeführt werden

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