Spielewelten mit Raycasting: Frei beweglich

Wir haben uns im letzten Kapitel darauf beschränkt, dass die Spielfigur immer in der Mitte eines Feldes steht. Jetzt erweitern wir die Möglichkeiten dahingehend, dass ein freies Bewegen auch innerhalb der Felder möglich ist. Darüberhinaus werden wir am Ende dieses Kapitels die Wände mit Textur darstellen können.

Freies Gehen auf dem SpielfeldBearbeiten

In diesem Abschnitt üben wir das freie Gehen auf dem Spielfeld. Die schon bekannten Funktionen werden dabei modifiziert.

Spielfeld.weglaenge ist dabei der Weg, den die Spielfigur auf einmal gehen kann. Im folgenden Code sind dafür 10 Pixel vorgesehen. In der Methode Spielfeld.geheVor() wird daher die Richtung der Spielfigur mit der Weglänge multipliziert. Anschließend wird geschaut, ob wir auf eine Wand treffen würden und dann gegangen.

Die Methoden rund um Spielfeld.findeWand() haben wir ebenfalls auf den neusten Stand gebracht. Ein gefundenes Wandelement hat nun eine Position auf der Spielfeldkarte wie auch eine Schnittpunktposition mit genau dieser gefundenen Wand. zeichneSpielfeld() stellt nun nicht nur die gefundene Wand dar, sondern auch den ermittelten Schnittpunkt.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import math
import pygame
import sys
 
 
class Spielfeld(object):
 
    def __init__(self, dateiname, feldgroesse, weglaenge):
        """ Initialisiert das Spielfeld
          dateiname - Dateiname der Spielfeld-Datei
          feldgroesse - die Pixelgrösse eines quadratischen Feldes
          weglaenge - dieses Stück Pixelweg legt der Spieler bei einem Tastendruck zurück"""
        self.felder = []
        self.feldgroesse = feldgroesse
        self.feldgroesseD2 = feldgroesse // 2
        self.weglaenge = weglaenge
        self.blickrichtung = 160
        datei = open(dateiname, 'r')
        for zeile in datei:
            self.felder.append(zeile[:-1])
        datei.close()
        self.breite = len(self.felder[0])
        self.hoehe = len(self.felder)
        for num, zeile in enumerate(self.felder):
            idx = zeile.find('#')
            if idx >= 0:
                # Pixel-Position!!!
                self.position = (idx * self.feldgroesse + self.feldgroesseD2, num * self.feldgroesse + self.feldgroesseD2)
                self.felder[num] = self.felder[num].replace('#', '.')
                break
        self.WEITWEG = self.breite * self.hoehe * self.feldgroesse

 
    def zeichen(self, x, y):
        """Liefert das Zeichen an der Position x, y """
        assert(0 <= x < self.breite)
        assert(0 <= y < self.hoehe)
        return self.felder[y][x]
 
 
    def istWand(self, zeichen):
        """True, wenn das Zeichen ein Wandzeichen ist """
        return zeichen in ('N', 'W', 'S', 'O')
 
 
    def geheVor(self):
        """gehe in Richtung der Blickrichtung """
        px, py = self.position
        qx = int(round(px + self.weglaenge * math.cos(math.radians(self.blickrichtung))))
        qy = int(round(py - self.weglaenge * math.sin(math.radians(self.blickrichtung))))
        zeichen = self.zeichen(qx // self.feldgroesse, qy // self.feldgroesse)
        if not self.istWand(zeichen): 
            self.position = (qx, qy)  
 
 
    def geheZurueck(self):
        """gehe entgegen der Blickrichtung """
        self.blickrichtung += 180
        self.geheVor()
        self.blickrichtung -= 180
 
 
    def dreheLinks(self):
        self.blickrichtung = (self.blickrichtung + 5) % 360
 
 
    def dreheRechts(self):
        self.blickrichtung = (self.blickrichtung - 5) % 360


    def findeWandHV(self, winkel, px, py, fx, fy):
        """findet Wände in ausschließlich horizontaler/vertikaler Richtung"""
        rDict = {0 : (1, 0), 90 : (0, -1), 180 : (-1, 0), 270 : (0, 1)}
        rx, ry = rDict[winkel]
        feldX = fx + rx
        feldY = fy + ry
        feldZeichen = self.zeichen(feldX, feldY)
        while not self.istWand(feldZeichen):
            feldX = feldX + rx
            feldY = feldY + ry
            feldZeichen = self.zeichen(feldX, feldY)
        if winkel == 0:
            sx = feldX * self.feldgroesse 
            sy = py
            entfernung = sx - px
        elif winkel == 90:
            sx = px
            sy = (feldY + 1) * self.feldgroesse
            entfernung = py - sy
        elif winkel == 180:
            sx = (feldX + 1) * self.feldgroesse 
            sy = py
            entfernung = px - sx
        else: # winkel == 270
            sx = px
            sy = feldY * self.feldgroesse
            entfernung = sy - py
        return (feldX, feldY, feldZeichen, sx, sy, entfernung)


    def findeWandDiagonal(self, px, py, dx1, dy1, dx2, dy2, (kx, ky)):
        # Findet Wände in diagonaler Richtung
        sx = px + dx1
        sy = py + dy1
        feldX = int(sx / self.feldgroesse) + kx
        feldY = int(sy / self.feldgroesse) + ky
        if (0 <= feldX < self.breite) and (0 <= feldY < self.hoehe):
            feldZeichen = self.zeichen(feldX, feldY)
        else:
            return (0, 0, '0', 0, 0, self.WEITWEG)
        while not self.istWand(feldZeichen):
            sx = sx + dx2
            sy = sy + dy2
            feldX = int(sx / self.feldgroesse) + kx
            feldY = int(sy / self.feldgroesse) + ky
            if (0 <= feldX < self.breite) and (0 <= feldY < self.hoehe):
                feldZeichen = self.zeichen(feldX, feldY)
            else:
                return (0, 0, '0', 0, 0, self.WEITWEG)
        # wir haben die Wand gefunden
        ex = sx - px
        ey = sy - py
        entfernung = math.sqrt(ex * ex + ey * ey)
        return (feldX, feldY, feldZeichen, sx, sy, entfernung)


    def findeWand(self, winkel):
        winkel = winkel % 360
        px, py = self.position
        fx = px // self.feldgroesse
        fy = py // self.feldgroesse 
        # Spezialfall wegen Tangens
        if winkel % 90 == 0:
            return self.findeWandHV(winkel, px, py, fx, fy)
        else: # alle anderen Winkel
            rdict = {0 : ((0, -1), (0, 0)), 
                     1 : ((0, -1), (-1, 0)), 
                     2 : ((0, 0), (-1, 0)), 
                     3 : ((0, 0), (0, 0))}
            quadrant = int(winkel) // 90
            tangens = math.tan(math.radians(winkel))
            korr1, korr2 = rdict[quadrant]

            if quadrant == 0:
                # - Schnittpunkte mit horiz. Linien
                dy1 = py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = self.feldgroesse - px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 1:
                # - Schnittpunkte mit horiz. Linien
                dy1 = py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 2:
                # - Schnittpunkte mit horiz. Linien
                dy1 = self.feldgroesse - py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 3:
                # - Schnittpunkte mit horiz. Linien
                dy1 = self.feldgroesse - py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = self.feldgroesse - px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            if wand1[5] < wand2[5]:
                return wand1
            else:
                return wand2
        



def init(breite, hoehe):
    screen = pygame.display.set_mode((breite, hoehe))
    screen.fill((200, 200, 200))
    pygame.display.update()
    return screen
 
 
def zeichneSpielfeld(screen, breite, hoehe, spielfeld, wandpos):
    feldbreite = breite // spielfeld.breite
    feldhoehe = hoehe // spielfeld.hoehe
    # Spielfeld zeichnen
    for y in xrange(spielfeld.hoehe):
        for x in xrange(spielfeld.breite):
            zeichen = spielfeld.zeichen(x, y)
            rechteck = (x * feldbreite, y * feldhoehe, feldbreite, feldhoehe)
            if zeichen == '.':
                pygame.draw.rect(screen, (0, 0, 0), rechteck)
            elif zeichen == 'N':
                pygame.draw.rect(screen, (128, 0, 0), rechteck)
            elif zeichen == 'W':
                pygame.draw.rect(screen, (160, 43, 43), rechteck)
            elif zeichen == 'S':
                pygame.draw.rect(screen, (128, 128, 0), rechteck)
            elif zeichen == 'O':
                pygame.draw.rect(screen, (213, 85, 0), rechteck)
    # Spielfigur zeichnen
    pos = (int (1.0 * spielfeld.position[0] / spielfeld.feldgroesse * feldbreite), int(1.0 * spielfeld.position[1] / spielfeld.feldgroesse * feldhoehe))
    pygame.draw.circle(screen, (255, 255, 255), pos, 10)
    # grid zeichnen
    for x in xrange(1, spielfeld.breite):
        start = (x * feldbreite, 0)
        ende = (start[0], hoehe - 1)
        pygame.draw.line(screen, (128, 128, 128), start, ende)
    for y in xrange(1, spielfeld.hoehe):
        start = (0, y * feldhoehe)
        ende = (breite - 1, start[1])
        pygame.draw.line(screen, (128, 128, 128), start, ende)
    # Blickrichtung zeichnen
    qx = int(pos[0] + 2 * feldbreite * math.cos(math.radians(spielfeld.blickrichtung)))
    qy = int(pos[1] - 2 * feldhoehe * math.sin(math.radians(spielfeld.blickrichtung)))
    pygame.draw.line(screen, (0, 255, 0), pos, (qx, qy))
    # gefundene Wand zeichnen
    wx, wy, zeichen, sx, sy, entfernung = wandpos
    wx = wx * feldbreite + feldbreite // 2
    wy = wy * feldhoehe + feldhoehe // 2
    spos = (int (1.0 * sx / spielfeld.feldgroesse * feldbreite), int(1.0 * sy / spielfeld.feldgroesse * feldhoehe))
    pygame.draw.line(screen, (0, 0, 255), pos, spos)
    pygame.draw.circle(screen, (0, 0, 255), spos, 5)
    pygame.draw.circle(screen, (0, 0, 255), (wx, wy), min(feldhoehe, feldbreite) // 5)
    pygame.display.update()
 
 
def hauptschleife(spielfeld, screen, breite, hoehe):
    wand = spielfeld.findeWand(spielfeld.blickrichtung)
    zeichneSpielfeld(screen, breite, hoehe, spielfeld, wand)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_UP:
                    spielfeld.geheVor()
                elif event.key == pygame.K_DOWN:
                    spielfeld.geheZurueck()
                elif event.key == pygame.K_LEFT:
                    spielfeld.dreheLinks()
                elif event.key == pygame.K_RIGHT:
                    spielfeld.dreheRechts()
                wand = spielfeld.findeWand(spielfeld.blickrichtung)
                zeichneSpielfeld(screen, breite, hoehe, spielfeld, wand)
 
 
if __name__ == '__main__':
    spielfeld = Spielfeld('spielfeld.txt', 64, 10)
    screen = init(500, 500)
    hauptschleife(spielfeld, screen, 500, 500)


WandsucheBearbeiten

Die auffälligste Neuerung an diesem Code ist Spielfeld.findeWand(). Wir bedienen uns hier kleinen Tricks, um die Wandsuche im Vergleich zum letzten Kapitel qualitativ zu verbessern.

Wandsuche horizontal/vertikalBearbeiten

 
Suche nach der Wand bei 0°
 
Suche nach der Wand bei 180°

Für die Spezialfälle, in denen der aktuell zu untersuchende Winkel ein vielfaches von 90° ist, wird Spielfeld.findeWandHV() aufgerufen. Die Parameter sind die tatsächliche Pixelposition und die aktuelle Feldposition, auf der sich die Spielfigur befindet. In Abhängigkeit vom Winkel wird im Dictionary rDict eine Richtung vorgegeben, in der die zu suchende Wand liegt. Bei einem Winkel von 0° beispielsweise wird in X-Richtung gesucht und die Y-Richtung beibehalten. Die Notation ist dann (1, 0). Für 180° müssen wir allerdings nach links blicken und deswegen jeweils -1 in X-Richtung suchen, die Y-Richtung bleibt erhalten, also (-1, 0). So kommen die Einträge innerhalb dieses Dictionaries zustande. In der Schleife schauen wir uns also immer das nächste Feld an und testen darauf, ob es ein Wandzeichen ist. Ist es so, dann haben wir die Wand gefunden.
Im Fall von 0° ist die X-Position, an der das Wandelement gefunden wurde, einfach feldX * feldgroesse. Im Fall von 180° jedoch finden wir beispielsweise die Wand an der X-Position 0. Der Abstand zu dieser Wand ist dann allerdings zu korrigieren, da wir die Wand ja nicht an der linken, sondern an der rechten Seite schneiden. Finden wir also eine Wand in der Spalte 0, so müssen wir feldgroesse hinzuzählen. Allgemein also (feldX + 1) * self.feldgroesse.

Wandsuche DiagonalBearbeiten

Alle anderen Fälle werden von Spielfeld.findeWandDiagonal(), verarbeitet, die ihrerseits sehr viel Vorbereitung bedarf. Wir übergeben der Methode Spielfeld.findeWandDiagonal() die augenblickliche Pixel-Position, den Abstand, wo diese Methode zuerst suchen soll, also die erste Schrittweite (dx1, dy1), den Abstand, wo danach gesucht werden soll (dx2, dy2) und einen Korrekturwert, auf den wir gleich noch zu sprechen kommen.

Innerhalb von Spielfeld.findeWandDiagonal() wird zuerst die erste Schrittweite (dx1, dy1) gegangen, dann wird geschaut, ob dort eine Wand liegt. Korrekturwerte werden jeweils hinzugezählt. Falls an dieser Stelle die zu untersuchende Wand außerhalb des Spielfeldes liegt, wird einfach angenommen, die Wand ist sehr weit entfernt und ein entsprechender Wert (Spielfeld.WEITWEG) zurückgeliefert. Dann wird unter berücksichtigung der Korrekturwerte das zweite Paar Schrittweiten ((dx1, dy1)) genommen, um Felder zu untersuchen.

Die Vorbereitung von Spielfeld.findeWandDiagonal() innerhalb von Spielfeld.findeWand() nimmt sehr viel Raum ein. Wir rufen Spielfeld.findeWandDiagonal() auch zweimal auf, einmal für die Schnittpunkte mit horizontalen und einmal für die Schnittpunkte mit vertikalen Linien. Dies kennen sie schon aus dem letzten Kapitel. Neu ist, dass wir mit quadrant das Spielfeld von der Spielfigur aus in vier Teile teilen. Der Quadrant 0 enthält alle Winkel, die größer als 0° und kleiner als 90° sind.

Die erste Schrittweite ist bestimmt durch den Abstand zum nächsten Feld. Es wird also der erste mögliche Schittpunkt mit einer waagerechten und senkrechten Feldbegrenzung (im Anwendungsbild eine Gitterline) gesucht. Die nächsten Schrittweiten werden bestimmt durch die Feldgröße, da Feldbegrenzungen immer Feldgrößen voneinander entfernt sind. dy1 = py % self.feldgroesse hat hier die Bedeutung, die wir im mathematischen Kapitel erläutert haben, nämlich den Abstand der Spielfigur vom oberen Rand zu bestimmen.

Der Tangens ist im Quadrant 0 positiv, die Y-Richtung soll aber negativ sein - wir erinnern uns, dass der Wert (0 ; 0) in der oberen linken Ecke liegt, man also nach oben in den negativen Bereich schaut. Folglich müssen wir alle gefundenen Werte für dy1 und dy2 mit -1.0 multiplizieren. Dafür dient die etwas längliche aber immer gleiche Rechnung, die rx und ry enthält.

Die Korrekturwerte im rdict kommen daher zustande, dass man manchmal das falsche Feld untersucht. Sucht man beispielsweise im Quadrant 0 einen Schnittpunkt mit horizontalen Linien, so rechnet man immer ein Feld zu tief. Die Korrektur von (0, -1) für diesen Fall berichtigt das. Da meistens alles gut läuft, man also nur wenige solcher quadrantabhängigen Korrekturen braucht, ist rdict zumeist mit Nullen besetzt. Übrigens könnte man auch die oben genannte rx- und ry-Werte dort mit eintragen.

Spielfeld zeichnenBearbeiten

Das Spielfeld wird mit der Funktion zeichneSpielfeld() neu gezeichnet. Diese Funktion wird mit der echten Fenstergröße und einigen weiteren Parametern aufgerufen. Da diese echte Fenstergröße nicht unbedingt genau so groß sein muss, wie das Spielfeld, benutzen wir die aus dem mathematischen Kapitel bekannte Methode, um das Spielfeld maßstabsgetreu zu verkleinern. Wenn also die echte Spielfeldbreite in Feldern gemessen spielfeld.breite ist und die echte Feldbreite in Pixeln gemessen spielfeld.feldgroesse ist, dann ist das gesamte echte Spielfeld in Pixeln gemessen gerade spielfeld.breite * spielfeld.feldgroesse breit. Diese Breite muss aber nun in das Programmfenster mit der Breite breite gequetscht werden. Hierbei hilft uns die Variable feldbreite, die die Größe eines einzelnen Feldes auf dem Programmfenster berechnet.

Hat man dann eine Pixel-Position auf dem Spielfeld, kann man mit spielfeld.position[0] / spielfeld.feldgroesse * feldbreite die X-Position im Programmfenster bestimmen. Der Quotient feldbreite / spielfeld.feldgroesse, der in all diesen Berechnungen steckt, ist dann genau das Maß, um das wir alle X-Positionsangaben verkleinern müssen, um eine maßstabsgetreue Positionierung auf dem Fenster zu bekommen.

Freies Gehen im RaumBearbeiten

Das nun folgende Beispiel benutzt die jetzt bekannte Spielfeldklasse, um eine dreidimensionale Raumdarstellung zu erzeugen.

Anmerkung:

Die Klasse Spielfeld ist hierbei die gleiche wie oben schon beschrieben, wir haben sie weggelassen, um den Quelltext nicht unnötig lang werden zu lassen. Probieren Sie dieses Beispiel aus, dann kopieren Sie sich bitte die oben angeführte Klasse einfach in den Quelltext.

Im Vergleich zu obigem Programm fällt auf, dass wir lediglich die Raumklasse hinzugefügt haben und die Funktion zeichneSpielfeld() deutlich kleiner ausfällt:

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import math
import pygame
import sys
 
 
class Spielfeld(object):
    # Aus Gründen der Übersichtlichkeit weggelassen, Wie oben
    pass

class Raum(object):

    def __init__(self, blickfeldwinkel, pBreite, pHoehe, wandhoehe):
        """Initialisiert den Raum
          blickfeldwinkel - gesamter Winkelbereich, den Spielfigur sehen kann
          pBreite, pHoehe - Ausmaße des Fensters, auf das projiziert werden soll"""
        self.blickfeldWinkel = blickfeldwinkel
        self.blickfeldWinkelD2 = blickfeldwinkel / 2.0
        self.pHoehe = pHoehe
        self.mittelLinie = self.pHoehe // 2
        self.spaltenZahl = pBreite
        self.projektionsAbstand = (self.spaltenZahl / 2.0) /  math.tan(math.radians(self.blickfeldWinkelD2))
        self.spaltenWinkel = 1.0 * blickfeldwinkel / self.spaltenZahl
        self.wandHoeheEcht = 1.0 * wandhoehe


    def berechneHoehe(self, entfernung):
        """berechnet aus der Entfernung die scheinbare Wandhöhe.
          Da Entfernung auch 0 sein kann, erfolgt hier Anpassung"""
        if entfernung > 0.0:
            h = self.wandHoeheEcht * self.projektionsAbstand / entfernung
        else:
            h = self.pHoehe
        return int(h)


    def raycasting(self, spielfeld):
        anfangsWinkel = spielfeld.blickrichtung + self.blickfeldWinkelD2
        hoehenListe = []
        for spalte in xrange(self.spaltenZahl):
            winkel = anfangsWinkel - spalte * self.spaltenWinkel
            winkel = winkel % 360
            feldXpos, feldYpos, feldZeichen, schnittpunktX, schnittpunktY, entfernung = spielfeld.findeWand(winkel)
            hoehe = self.berechneHoehe(entfernung)
            hoehenListe.append((spalte, feldZeichen, hoehe))
        return hoehenListe


 
def init(breite, hoehe):
    screen = pygame.display.set_mode((breite, hoehe))
    screen.fill((200, 200, 200))
    pygame.display.update()
    return screen


def zeichneSpielfeld(screen, mittellinie, hoehen):
    screen.fill((200, 200, 200))
    for spalte, zeichen, hoehe in hoehen:
        x0, x1 = spalte, spalte
        # Zeichne in der Mitte 
        y0 = mittellinie - hoehe // 2
        y1 = y0 + hoehe
        if zeichen == 'N':
            farbe = (128, 0, 0)
        elif zeichen == 'S':
            farbe = (128, 128, 0)
        elif zeichen == 'O':
            farbe = (213, 85, 0)
        elif zeichen == 'W':
            farbe = (160, 43, 43)
        pygame.draw.line(screen, farbe, (x0, y0), (x1, y1), 1)
    pygame.display.update()



def hauptschleife(raum, spielfeld, screen, breite, hoehe):
    mussZeichnen = False
    hoehen = raum.raycasting(spielfeld)
    zeichneSpielfeld(screen, raum.mittelLinie, hoehen)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                mussZeichnen = True
                if event.key == pygame.K_UP:
                    spielfeld.geheVor()
                elif event.key == pygame.K_DOWN:
                    spielfeld.geheZurueck()
                elif event.key == pygame.K_LEFT:
                    spielfeld.dreheLinks()
                elif event.key == pygame.K_RIGHT:
                    spielfeld.dreheRechts()
            if mussZeichnen:
                hoehen = raum.raycasting(spielfeld)
                zeichneSpielfeld(screen, raum.mittelLinie, hoehen)
                mussZeichnen = False


if __name__ == '__main__':
    spielfeld = Spielfeld('spielfeld.txt', 64, 10)
    screen = init(500, 500)
    raum = Raum(60, 500, 500, 64)
    hauptschleife(raum, spielfeld, screen, 500, 500)


Die Methode berechneHoehe() berechnet wieder die Höhe mit Hilfe des Strahlensatzes, allerdings haben wir es hier mit Pixel-Entferungen zu tun, und müssen deswegen wandHoeheEcht miteinbeziehen. Den Fall, dass der Abstand 0 wird, berücksichtigen wir in der Methode ebenfalls.

Die Modulo-Operation beim Winkel haben wir statt in spielfeld.findeWand() nun direkt in der Methode raycasting() vorgenommen. In den späteren Beispielen werden wir sie dort gebrauchen.

Ansonsten ist die Ausgabe wie im Beispielprogramm im Kapitel "Darstellung des Raumes", allerdings kommen Sie den Wänden wesentlich näher.

Wand mit TexturBearbeiten

 
Die erste Wand bekommt eine Tapete

Nachdem wir uns nun frei auf dem Spielfeld bewegen können, werden wir uns dem Thema Texturen widmen. Auf der nebenstehenden Abbildung sehen Sie schon, worum es geht: Die Nordwand wird mit einer Textur versehen. Hierzu benötigen wir eine Grafikdatei mit dem Namen wand2N.png, diese sollte so groß sein wie die Feldgröße, also 64 Pixel in diesen Beispielprogrammen.

Das Beispielprogramm enthält einige neue Funktionen, nämlich ladeBild() und bildspalteZoom(). Den Kern dieser Funktionen haben wir Ihnen im Kapitel Grundlagen der Programmierung vorgestellt.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import math
import pygame
import sys
 
 
class Spielfeld(object):
    # Wie im ersten Beispielprogramm
    pass


class Raum(object):

    def __init__(self, blickfeldwinkel, pBreite, pHoehe, wandhoehe):
        """Initialisiert den Raum
          blickfeldwinkel - gesamter Winkelbereich, den Spielfigur sehen kann
          pBreite, pHoehe - Ausmaße des Fensters, auf das projiziert werden soll"""
        self.blickfeldWinkel = blickfeldwinkel
        self.blickfeldWinkelD2 = blickfeldwinkel / 2.0
        self.pHoehe = pHoehe
        self.mittelLinie = self.pHoehe // 2
        self.spaltenZahl = pBreite
        self.projektionsAbstand = (self.spaltenZahl / 2.0) /  math.tan(math.radians(self.blickfeldWinkelD2))
        self.spaltenWinkel = 1.0 * blickfeldwinkel / self.spaltenZahl
        self.wandHoeheEcht = 1.0 * wandhoehe


    def berechneHoehe(self, entfernung):
        """berechnet aus der Entfernung die scheinbare Wandhöhe.
          Da Entfernung auch 0 sein kann, erfolgt hier Anpassung"""
        if entfernung > 0.0:
            h = self.wandHoeheEcht * self.projektionsAbstand / entfernung
        else:
            h = self.pHoehe
        return int(h)


    def raycasting(self, spielfeld):
        anfangsWinkel = spielfeld.blickrichtung + self.blickfeldWinkelD2
        hoehenListe = []
        for spalte in xrange(self.spaltenZahl):
            winkel = anfangsWinkel - spalte * self.spaltenWinkel
            winkel = winkel % 360
            feldXpos, feldYpos, feldZeichen, schnittpunktX, schnittpunktY, entfernung = spielfeld.findeWand(winkel)
            # Abstand, an dem der momentane Winkel eine Wand trifft vom linken Rand der Wand
            wandort = int( (schnittpunktX +  schnittpunktY) % spielfeld.feldgroesse )
            hoehe = self.berechneHoehe(entfernung)
            hoehenListe.append((spalte, feldZeichen, hoehe, wandort))
        return hoehenListe


def init(breite, hoehe):
    screen = pygame.display.set_mode((breite, hoehe))
    screen.fill((200, 200, 200))
    pygame.display.update()
    return screen


def ladeBild(dateiname):
    tmp = pygame.image.load(dateiname)
    surface = tmp.convert()
    return surface    


def bildspalteZoom(spalte, bild, ziel, (x, y), neueHoehe):
    assert(spalte >= 0 and spalte < bild.get_width() and neueHoehe > 0)
    height = bild.get_height()
    einspaltig = pygame.Surface((1, height), 0, bild)
    einspaltig.blit(bild, (0, 0), (spalte, 0, 1, height))
    gestretcht = pygame.transform.scale(einspaltig, (1, neueHoehe))
    ziel.blit(gestretcht, (x, y), (0, 0, 1, neueHoehe))
    

def zeichneSpielfeld(screen, mittellinie, hoehen, bild):
    screen.fill((200, 200, 200))
    for spalte, zeichen, hoehe, abstand in hoehen:
        x0, x1 = spalte, spalte
        # Zeichne in der Mitte 
        y0 = mittellinie - hoehe // 2
        y1 = y0 + hoehe
        if zeichen == 'N':
            bildspalteZoom(abstand, bild, screen, (x0, y0), hoehe)
        elif zeichen == 'S':
            farbe = (128, 128, 0)
            pygame.draw.line(screen, farbe, (x0, y0), (x1, y1), 1)
        elif zeichen == 'O':
            farbe = (213, 85, 0)
            pygame.draw.line(screen, farbe, (x0, y0), (x1, y1), 1)
        elif zeichen == 'W':
            farbe = (160, 43, 43)
            pygame.draw.line(screen, farbe, (x0, y0), (x1, y1), 1)
    pygame.display.update()



def hauptschleife(raum, spielfeld, screen, breite, hoehe):
    mussZeichnen = False
    wandbild = ladeBild('wand2N.png')
    hoehen = raum.raycasting(spielfeld)
    zeichneSpielfeld(screen, raum.mittelLinie, hoehen, wandbild)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                mussZeichnen = True
                if event.key == pygame.K_UP:
                    spielfeld.geheVor()
                elif event.key == pygame.K_DOWN:
                    spielfeld.geheZurueck()
                elif event.key == pygame.K_LEFT:
                    spielfeld.dreheLinks()
                elif event.key == pygame.K_RIGHT:
                    spielfeld.dreheRechts()
            if mussZeichnen:
                hoehen = raum.raycasting(spielfeld)
                zeichneSpielfeld(screen, raum.mittelLinie, hoehen, wandbild)
                mussZeichnen = False


if __name__ == '__main__':
    spielfeld = Spielfeld('spielfeld.txt', 64, 10)
    screen = init(500, 500)
    raum = Raum(60, 500, 500, 64)
    hauptschleife(raum, spielfeld, screen, 500, 500)

Korrekte SpalteBearbeiten

Hat man in der Methode raycasting() den Schnittpunkt eines Strahles mit einer Wand bestimmt (schnittpunktX, schnittpunktY), dann ist ein Teil dieses Schnittpunktes genau auf einer Linie zwischen zwei Feldern. An dieser Stelle ist dann entweder schnittpunktX oder schnittpunktY ein Vielfaches von der Feldbreite. Da man gar nicht so genau wissen möchte, an welcher Seite einer Mauer man schneidet, sondern nur, wie groß der Abstand zur Wand ist, reicht (schnittpunktX + schnittpunktY) % spielfeld.feldgroesse aus, um diesen Abstand zu bestimmen. Man weiss dann also den Abstand des Schnittpunktes zu einer Seite der Mauer. Diesen Abstand nennen wir wandort, er ist gleich der Spalte in unserer Textur.

Innerhalb von zeichneSpielfeld() benutzen wir diesen Wandort, um bei Nordwänden mit bildspalteZoom() die passende Spalte aus der Textur auszuwählen und auf die richtige Größe zu zoomen.

ProblemeBearbeiten

Leider ist das beschriebene Verfahren, um den Wandort zu bestimmen, nicht gut genug, was man an folgenden Bildern sieht. Hier wird eine Situation auf dem Spielfeld wie auch im Raum gezeigt, bei der die falschen Spalten aus der Textur ausgewählt werden.

Ansicht Spielfeld Ansicht 3D
 
Spieler blickt nach rechts-unten...
 
...und sieht die Textur falsch

Blickt man nämlich nach unten auf eine Textur, wird der falsche Wandort bestimmt. Wir müssen die Texturspalte beim Blick nach unten von rechts auswählen, die oben beschriebene Modulo-Operation sorgt allerdings dafür, dass die Texturspalten von links ausgewählt werden. Wenn Sie einmal mit dem Programm durch den Raum wandern, werden Sie weitere Stellen sehen können, bei denen das nicht passt.

Um dieses Problem kümmern wir uns im nächsten Abschnitt und zeigen darüberhinaus, wie man alle Wände mit Textur belegt.

Alle Wände mit TexturBearbeiten

 
Alle Texturen werden richtig dargestellt

Das folgende Beispielprogramm ist eine löst das oben beschriebene Problem innerhalb von Raum.raycasting(), in dem alle Fälle, bei denen die Wand falsch gezeichnet würde abfängt und die Spalten korrekt von der anderen Seite aus bestimmt:

wandort = int( (schnittpunktX +  schnittpunktY) % spielfeld.feldgroesse )
if (270 > winkel > 90 and schnittpunktX % spielfeld.feldgroesse == 0) or \
 (360 > winkel > 180 and schnittpunktY % spielfeld.feldgroesse == 0):
    wandort = spielfeld.feldgroesse - wandort - 1

Es wird also bei Winkeln zwischen 90° und 270° geschaut, ob man einen Schnittpunkt mit vertikalen Feldbegrenzungen hat und bei Winkeln zwischen 180° und 360°, ob man hier einen Schnittpunkt mit horizontalen Feldbegrenzungen vorfindet. In diesen Fällen muss von der anderen Seite der Wand die Texturspalte bestimmt werden.

Ebenfalls zeigen wir eine Möglichkeit, wie man mit mehreren Texturen umgeht. Hierzu benötigen wir Texturdateien wand2N.png, wand2S.png, wand2O.png und wand2W.png, die wir in der Hauptschleife laden. Diese Bilddateien müssen wieder so groß sein wie die Feldgröße, in unseren Beispielen 64 Pixel.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import math
import pygame
import sys
 
 
class Spielfeld(object):
 
    def __init__(self, dateiname, feldgroesse, weglaenge):
        """ Initialisiert das Spielfeld
          dateiname - Dateiname der Spielfeld-Datei
          feldgroesse - die Pixelgrösse eines quadratischen Feldes
          weglaenge - dieses Stück Pixelweg legt der Spieler bei einem Tastendruck zurück"""
        self.felder = []
        self.feldgroesse = feldgroesse
        self.feldgroesseD2 = feldgroesse // 2
        self.weglaenge = weglaenge
        self.blickrichtung = 160
        datei = open(dateiname, 'r')
        for zeile in datei:
            self.felder.append(zeile[:-1])
        datei.close()
        self.breite = len(self.felder[0])
        self.hoehe = len(self.felder)
        for num, zeile in enumerate(self.felder):
            idx = zeile.find('#')
            if idx >= 0:
                # Pixel-Position!!!
                self.position = (idx * self.feldgroesse + self.feldgroesseD2, num * self.feldgroesse + self.feldgroesseD2)
                self.felder[num] = self.felder[num].replace('#', '.')
                break
        self.WEITWEG = self.breite * self.hoehe * self.feldgroesse

 
    def zeichen(self, x, y):
        """Liefert das Zeichen an der Position x, y """
        assert(0 <= x < self.breite)
        assert(0 <= y < self.hoehe)
        return self.felder[y][x]
 
 
    def istWand(self, zeichen):
        """True, wenn das Zeichen ein Wandzeichen ist """
        return zeichen in ('N', 'W', 'S', 'O')
 
 
    def geheVor(self):
        """gehe in Richtung der Blickrichtung """
        px, py = self.position
        qx = int(round(px + self.weglaenge * math.cos(math.radians(self.blickrichtung))))
        qy = int(round(py - self.weglaenge * math.sin(math.radians(self.blickrichtung))))
        zeichen = self.zeichen(qx // self.feldgroesse, qy // self.feldgroesse)
        if not self.istWand(zeichen): 
            self.position = (qx, qy)  
 
 
    def geheZurueck(self):
        """gehe entgegen der Blickrichtung """
        self.blickrichtung += 180
        self.geheVor()
        self.blickrichtung -= 180
 
 
    def dreheLinks(self):
        self.blickrichtung = (self.blickrichtung + 5) % 360
 
 
    def dreheRechts(self):
        self.blickrichtung = (self.blickrichtung - 5) % 360


    def findeWandHV(self, winkel, px, py, fx, fy):
        """findet Wände in ausschließlich horizontaler/vertikaler Richtung"""
        rDict = {0 : (1, 0), 90 : (0, -1), 180 : (-1, 0), 270 : (0, 1)}
        rx, ry = rDict[winkel]
        feldX = fx + rx
        feldY = fy + ry
        feldZeichen = self.zeichen(feldX, feldY)
        while not self.istWand(feldZeichen):
            feldX = feldX + rx
            feldY = feldY + ry
            feldZeichen = self.zeichen(feldX, feldY)
        if winkel == 0:
            sx = feldX * self.feldgroesse 
            sy = py
            entfernung = sx - px
        elif winkel == 90:
            sx = px
            sy = (feldY + 1) * self.feldgroesse
            entfernung = py - sy
        elif winkel == 180:
            sx = (feldX + 1) * self.feldgroesse 
            sy = py
            entfernung = px - sx
        else: # winkel == 270
            sx = px
            sy = feldY * self.feldgroesse
            entfernung = sy - py
        return (feldX, feldY, feldZeichen, sx, sy, entfernung)


    def findeWandDiagonal(self, px, py, dx1, dy1, dx2, dy2, (kx, ky)):
        # Findet Wände in diagonaler Richtung
        sx = px + dx1
        sy = py + dy1
        feldX = int(sx / self.feldgroesse) + kx
        feldY = int(sy / self.feldgroesse) + ky
        if (0 <= feldX < self.breite) and (0 <= feldY < self.hoehe):
            feldZeichen = self.zeichen(feldX, feldY)
        else:
            return (0, 0, '0', 0, 0, self.WEITWEG)
        while not self.istWand(feldZeichen):
            sx = sx + dx2
            sy = sy + dy2
            feldX = int(sx / self.feldgroesse) + kx
            feldY = int(sy / self.feldgroesse) + ky
            if (0 <= feldX < self.breite) and (0 <= feldY < self.hoehe):
                feldZeichen = self.zeichen(feldX, feldY)
            else:
                return (0, 0, '0', 0, 0, self.WEITWEG)
        # wir haben die Wand gefunden
        ex = sx - px
        ey = sy - py
        entfernung = math.sqrt(ex * ex + ey * ey)
        return (feldX, feldY, feldZeichen, sx, sy, entfernung)


    def findeWand(self, winkel):
        px, py = self.position
        fx = px // self.feldgroesse
        fy = py // self.feldgroesse 
        # Spezialfall wegen Tangens
        if winkel % 90 == 0:
            return self.findeWandHV(winkel, px, py, fx, fy)
        else: # alle anderen Winkel
            rdict = {0 : ((0, -1), (0, 0)), 
                     1 : ((0, -1), (-1, 0)), 
                     2 : ((0, 0), (-1, 0)), 
                     3 : ((0, 0), (0, 0))}
            quadrant = int(winkel) // 90
            tangens = math.tan(math.radians(winkel))
            korr1, korr2 = rdict[quadrant]

            if quadrant == 0:
                # - Schnittpunkte mit horiz. Linien
                dy1 = py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = self.feldgroesse - px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 1:
                # - Schnittpunkte mit horiz. Linien
                dy1 = py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 2:
                # - Schnittpunkte mit horiz. Linien
                dy1 = self.feldgroesse - py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            elif quadrant == 3:
                # - Schnittpunkte mit horiz. Linien
                dy1 = self.feldgroesse - py % self.feldgroesse
                dx1 = dy1 / tangens
                dy2 = self.feldgroesse
                dx2 = dy2 / tangens
                rx = -1.0
                ry = 1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand1 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr1)

                # - Schnittpunkte mit vert. Linien
                dx1 = self.feldgroesse - px % self.feldgroesse
                dy1 = tangens * dx1
                dx2 = self.feldgroesse
                dy2 = tangens * dx2
                rx = 1.0
                ry = -1.0
                dx1 = rx * dx1
                dy1 = ry * dy1
                dx2 = rx * dx2
                dy2 = ry * dy2
                wand2 = self.findeWandDiagonal(px, py, dx1, dy1, dx2, dy2, korr2)
            if wand1[5] < wand2[5]:
                return wand1
            else:
                return wand2
        


class Raum(object):

    def __init__(self, blickfeldwinkel, pBreite, pHoehe, wandhoehe):
        """Initialisiert den Raum
          blickfeldwinkel - gesamter Winkelbereich, den Spielfigur sehen kann
          pBreite, pHoehe - Ausmaße des Fensters, auf das projiziert werden soll"""
        self.blickfeldWinkel = blickfeldwinkel
        self.blickfeldWinkelD2 = blickfeldwinkel / 2.0
        self.pHoehe = pHoehe
        self.mittelLinie = self.pHoehe // 2
        self.spaltenZahl = pBreite
        self.projektionsAbstand = (self.spaltenZahl / 2.0) /  math.tan(math.radians(self.blickfeldWinkelD2))
        self.spaltenWinkel = 1.0 * blickfeldwinkel / self.spaltenZahl
        self.wandHoeheEcht = 1.0 * wandhoehe


    def berechneHoehe(self, entfernung):
        """berechnet aus der Entfernung die scheinbare Wandhöhe.
          Da Entfernung auch 0 sein kann, erfolgt hier Anpassung"""
        if entfernung > 0.0:
            h = self.wandHoeheEcht * self.projektionsAbstand / entfernung
        else:
            h = self.pHoehe
        return int(h)


    def raycasting(self, spielfeld):
        anfangsWinkel = spielfeld.blickrichtung + self.blickfeldWinkelD2
        hoehenListe = []
        for spalte in xrange(self.spaltenZahl):
            winkel = anfangsWinkel - spalte * self.spaltenWinkel
            winkel = winkel % 360
            feldXpos, feldYpos, feldZeichen, schnittpunktX, schnittpunktY, entfernung = spielfeld.findeWand(winkel)
            # Abstand, an dem der momentane Winkel eine Wand trifft vom linken Rand der Wand
            wandort = int( (schnittpunktX +  schnittpunktY) % spielfeld.feldgroesse )
            if (270 > winkel > 90 and schnittpunktX % spielfeld.feldgroesse == 0) or \
             (360 > winkel > 180 and schnittpunktY % spielfeld.feldgroesse == 0):
                wandort = spielfeld.feldgroesse - wandort - 1
            hoehe = self.berechneHoehe(entfernung)
            hoehenListe.append((spalte, feldZeichen, hoehe, wandort))
        return hoehenListe


def init(breite, hoehe):
    screen = pygame.display.set_mode((breite, hoehe))
    screen.fill((200, 200, 200))
    pygame.display.update()
    return screen


def ladeBild(dateiname):
    tmp = pygame.image.load(dateiname)
    surface = tmp.convert()
    return surface    


def bildspalteZoom(spalte, bild, ziel, (x, y), neueHoehe):
    assert(spalte >= 0 and spalte < bild.get_width() and neueHoehe > 0)
    height = bild.get_height()
    einspaltig = pygame.Surface((1, height), 0, bild)
    einspaltig.blit(bild, (0, 0), (spalte, 0, 1, height))
    gestretcht = pygame.transform.scale(einspaltig, (1, neueHoehe))
    ziel.blit(gestretcht, (x, y), (0, 0, 1, neueHoehe))
    

def zeichneSpielfeld(screen, mittellinie, hoehen, bildN, bildS, bildO, bildW):
    screen.fill((200, 200, 200))
    for spalte, zeichen, hoehe, abstand in hoehen:
        x0, x1 = spalte, spalte
        # Zeichne in der Mitte 
        y0 = mittellinie - hoehe // 2
        y1 = y0 + hoehe
        if zeichen == 'N':
            bildspalteZoom(abstand, bildN, screen, (x0, y0), hoehe)
        elif zeichen == 'S':
            bildspalteZoom(abstand, bildS, screen, (x0, y0), hoehe)
        elif zeichen == 'O':
            bildspalteZoom(abstand, bildO, screen, (x0, y0), hoehe)
        elif zeichen == 'W':
            bildspalteZoom(abstand, bildW, screen, (x0, y0), hoehe)
    pygame.display.update()



def hauptschleife(raum, spielfeld, screen, breite, hoehe):
    mussZeichnen = False
    wandbildN = ladeBild('wand2N.png')
    wandbildS = ladeBild('wand2S.png')
    wandbildO = ladeBild('wand2O.png')
    wandbildW = ladeBild('wand2W.png')
    hoehen = raum.raycasting(spielfeld)
    zeichneSpielfeld(screen, raum.mittelLinie, hoehen, wandbildN, wandbildS, wandbildO, wandbildW)
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                mussZeichnen = True
                if event.key == pygame.K_UP:
                    spielfeld.geheVor()
                elif event.key == pygame.K_DOWN:
                    spielfeld.geheZurueck()
                elif event.key == pygame.K_LEFT:
                    spielfeld.dreheLinks()
                elif event.key == pygame.K_RIGHT:
                    spielfeld.dreheRechts()
            if mussZeichnen:
                hoehen = raum.raycasting(spielfeld)
                zeichneSpielfeld(screen, raum.mittelLinie, hoehen, wandbildN, wandbildS, wandbildO, wandbildW)
                mussZeichnen = False


if __name__ == '__main__':
    spielfeld = Spielfeld('spielfeld.txt', 64, 10)
    screen = init(500, 500)
    raum = Raum(60, 500, 500, 64)
    hauptschleife(raum, spielfeld, screen, 500, 500)


AnregungenBearbeiten