Pico 8 Tutorial 9: Verhindere, dass deine Spielfigur durch Gegenstände läuft

Einführung

Du hast nun eine fertige Map und eine Kamera, die deiner Spielfigur folgt. In diesem Tutorial lernst du, wie du verhinderst, dass deine Spielfigur einfach durch Gegenstände läuft (als wäre es ein Gespenst…).

Videotutorial

Wie gewohnt schaue dir gerne das folgende Video an:

Schritt 1: Markiere die Kacheln, durch die die Spielfigur nicht „hindurchgehen“ darf

Wir müssen Pico 8 irgendwie mitteilen, durch welche Objekte bzw. Gegenstände die Spielfigur laufen darf und durch welche nicht. Gehe in den SPRITE-Editor und klicke auf einen Sprite (bzw. eine Kachel), durch die man NICHT durchlaufen soll.

Rechts neben dem Bild der Kachel siehst du insgesamt 8 nebeneinanderliegende Kreise (siehe Mauszeiger auf dem Bild oben). Diese Kreise sind sogenannte „FLAGS“. Wenn du jetzt den Kreis ganz links anklickst, hast du die FLAG 0 für die ausgewählte Kachel gesetzt.

Setze nun für alle Kacheln, durch die dein Spieler NICHT einfach so durchlaufen soll, die FLAG auf 0.

Schritt 2: Überprüfe, wann eine Kachel mit gesetztem FLAG vom Spieler berührt wird

Die FLAG einer Kachel zu setzen, reicht leider nicht aus. Die Figur gleitet immer noch durch ausgewählten Kacheln. Wir müssen Pico 8 genau sagen, was er tun soll, wenn der Spieler die gesetzte Kachel berührt. Hierfür brauchen wir zwei insgesamt zwei Funktionen. Wie im letzten Tutorial mache ich es dir ein bisschen einfach(er). Du kannst dir die von mir erstellte Funktion in deinen Code kopieren, solltest aber ungefähr verstehen, was genau der Code macht.

Schauen wir uns zunächst die Funktion check_map_flag an:

Funktion 1: check_map_flag

function check_map_kollision      <--Name der Funktion
(x, y, w, h, flag)                                     <-- Hier werden  fünf Werte für die Funktion übergeben. 

local function tile_flag_at             <-- In dieser Funktion gibt es eine zweite Funktion
(px, py)                                                   <-- Diese Funktion überprüft, ob für die Kachel, an die der Spieler stößt,
                                                                   ein Flag gesetzt wurde
local tile_x = flr(px / 8)
local tile_y = flr(py / 8)
return fget(mget(tile_x, tile_y), flag)

end                                                           <-- Hier endet die zweite Funktion 
    
return tile_flag_at(x, y) or            <-- Hier wird nun überprüft, ob der Spieler die gesetzte Kachel oben links...
tile_flag_at(x + w - 1, y) or             <-- ... oder oben rechts...
tile_flag_at(x, y + h - 1) or              <-- ... oder unten links...
tile_flag_at(x + w - 1, y + h - 1)     <-- ... oder unten rechts... berührt
                                                                   <-- Wenn der Spieler einer der Ecken der Kachel berührt, gibt die Funktion  
                                                                   den Wert TRUE zurück
end                                                          <-- Zum Schluss wird die Funktion beendet

Was macht diese Funktion?

Diese Funktion überprüft, ob der Spieler eine Kachel berührt, für die ein FLAG gesetzt wurde.

Schritt 3: Die Kollisionsfunktion

Die zweite Funktion ist nun unsere eigentliche Kollisionsfunktion:

function kollision(obj,flag,dirx,diry) <-- Name der Funktion. Die Funktion erhält bei Auruf 4 Werte. Der erste 
                                                                                   Wert ist ein Objekt

if check_map_flag(obj.x,                    <-- Hier überprüfen wir, ob unsere erste Funktion (check_map_flag) ein  
obj.y,obj.w,obj.h,flag)                          TRUE (Kachel berührt) oder FALSE (Kachel nicht berührt) ausgibt. An 
                                                                        unsere check_map_flag-Funktion müssen wir wieder fünf Werte 
                                                                         übermitteln 
then          

spieler.speed = 0                                    <-- Wenn check_map_flag TRUE ausgibt, wird die Geschwindigkeit des 
                                                                       Spielers auf 0 gesetzt (damit er nicht weiterlaufen kann)

spieler.x += dirx                                      <-- Diese beiden Zeilen stoßen den Spieler bei Kollision kurz zurück, damit 
spieler.y += diry                                      er nicht an dem Objekt kleben bleibt


else

spieler.speed = 1.5                              <-- Sobald der Spieler vom kollidierten Objekt zurückgestoßen wurde, soll 
                                                                    er sich wieder normal bewegen können. Deshalb müssen wir spieler.speed 
                                                                    wieder auf 1.5 setzen

end                                                           <-- Hier endet der If-Befehl

end                                                           <-- Hier endet unsere Funktion

Schritt 4: Füge die beiden Funktionen in deinen Code ein

Kopiere dir die beiden Funktion (cmd und c) und füge sie in TAB 6 ein (cmd und v)

function kollision(obj,flag,dirx,diry)

if check_map_flag(obj.x,
obj.y,obj.w,obj.h,flag)
then

spieler.speed = 0

spieler.x += dirx
spieler.y += diry


else

spieler.speed = 1.5

end

end


function check_map_flag
(x, y, w, h, flag)

local function tile_flag_at
(px, py)

local tile_x = flr(px / 8)
local tile_y = flr(py / 8)
return fget(mget(tile_x, tile_y), flag)

end
    
return tile_flag_at(x, y) or -- obere linke ecke
tile_flag_at(x + w - 1, y) or -- obere rechte ecke
tile_flag_at(x, y + h - 1) or -- untere linke ecke
tile_flag_at(x + w - 1, y + h - 1) -- untere rechte ecke

end

Schritt 5: Füge deinem Spieler-Objekt zwei weitere Eigenschaften hinzu

Damit unsere Funktionen überprüfen können, ob ein Spieler mit einer markierten Kachel kollidiert, brauchen sie zwei weitere „Eigenschaften“ unseres Spielerobjekts: Höhe der Spielerfigur in Pixel und Breite der Spielfigur in Pixel.

Gehe auf TAB 0 und füge deinem Spielerobjekt die folgende Eigenschaften hinzu:

h=8,
w=8

Dein Spielerobjekt sollte nun wie folgt aussehen:

Schritt 6: Rufe unsere Kollisionsfunktion in der Update-Funktion auf

Zu guter Letzt müssen wir unsere Kollisionsfunktion an den richtigen Stellen aufrufen und ihm die korrekten Werte für den jeweiligen Fall übermitteln.

Gehe in TAB 2

Füge nun innerhalb des ersten IF-Befehls (if btn(0) then), direkt unter dem Funktionsaufruf _animation(false) die folgende Zeile ein:

kollision(spieler,0,1.5,0)

Dein Code sollte nun wie folgt aussehen:

Wir übermitteln unserer Funktion mit Namen „Kollision“ 4 Werte:

Wert: Spieler (unser Spieler-Objekt aus TAB0)
0: Der Wert der FLAG, die unsere Kollisionsfunktion überprüfen soll (In unserem Fall ist es 0)
1.5: Der X – Wert, um den die Spielfigur zurückgestoßen werden soll, wenn es eine markierte Kachel links berührt. Verhindert, dass die Spielfigur an einem Objekt kleben bleibt
0: Der Y-Wert, um den die Spielfigur zurückgestoßen werden soll, wenn es eine markierte Kachel oben oder unten berührt. Da sich unsere Figur in diesem IF-BLOCK nach links bewegt, soll sie nicht nach oben oder unten zurückgestoßen werden (sondern nach rechts). Deshalb übermitteln wir hier den Wert 0.

Füge nun für die folgenden If-Blöcke die folgenden Codezeilen ein:

If Block:	Codezeile:
if btn(1) then	kollision(spieler,0,-1.5,0)
if btn(2) then	kollision(spieler,0,0,1.5)
if btn(3) then	kollision(spieler,0,0,-1.5)

Deine gesamte UPDATE-Funktion in TAB2 sollte nun wie folgt aussehen:

function _update()


if btn(0) then 

spieler.x -= spieler.speed

_animation(false)

kollision(spieler,0,1.5,0)

end

if btn(1) then

spieler.x += spieler.speed

_animation(true)

kollision(spieler,0,-1.5,0)

end 

if btn(2) then

spieler.y -= spieler.speed


_animation2()

kollision(spieler,0,0,1.5)


end

if btn(3) then

spieler.y += spieler.speed

_animation3()

kollision(spieler,0,0,-1.5)


end

 einfachekam()

end

Starte das Spiel. Unsere Spielfigur läuft nun nicht mehr durch die markierten Gegenstände 🙂