Konzepte für Jump and Run-Spiele

Aus Spieleprogrammierer-Wiki
Wechseln zu: Navigation, Suche

Bitte beachte, dass dieser Artikel noch unvollständig ist! Hilf mit, ihn fertigzustellen.
Näheres dazu findest du ggf. auf der Diskussionsseite. Wenn du der Meinung bist, dass der Artikel vollständig ist, kannst du diesen Hinweis entfernen.

Dieser Artikel soll dir zeigen, was ein Jump 'n' Run ist, wie ein Jump 'n' Run-Spiel aufgebaut ist und was zu beachten ist, wenn man ein eigenes programmiert.

Inhaltsverzeichnis

Was ist ein Jump 'n' Run?

In Jump 'n' Runs geht es prinzipiell darum, mit dem Spieler (engl. player) durch Level zu springen und zu rennen. "Platformer" ist das englische Synonym des Jump 'n' Runs-Genres. [1]

Bekannte Jump 'n' Runs

Bekannte Jump 'n' Runs sind z.B. die Mario- bzw. Super Mario-Reihe von Nintendo und die Sonic-Reihe von Sega.

Wie ist ein Jump 'n' Run aufgebaut?

Jump 'n' Runs bestehen meist aus Leveln und oft auch noch aus einer Welt, die oft als "Levelauswahl-Menü" fungiert.

2D-Jump 'n' Runs

Auch heute wird bei Jump 'n' Runs oft noch auf 2D-Grafik gesetzt, da für das Spielprinzip zwei Dimensionen vollkommen ausreichen.

Kachelbasierte Spiele

2D-Jump 'n' Runs sind meist kachelbasierte Spiele[2], da man diese Technologie einfach und schnell umsetzten kann. Wenn die Kacheln richtig gemalt werden, sieht es so aus, als wäre das Level ein einziges Bild. Ein weiterer Vorteil der Kacheltechnik ist, dass sie Kollisionserkennung erleichtert und somit Rechenleistung spart. Diese Technik wird vor allem in den Leveln eines Jump 'n' Runs verwendet, da eine Welt nicht so rechenaufwenig ist.

Gegner

Die meisten Jump 'n' Runs haben Gegner, die eine zusätzliche Schwierigkeit darstellen, jedoch durch Besiegen oft die Möglichkeit geben sich hochzuleveln. Gegner sollten gut auf die Level abgestimmt sein, so sollte man nicht im ersten Level einen Bossgegner einsetzen, sondern den Spieler erst mit wenigen, einfach zu besiegenden Gegnern konfrontieren und die Schwierigkeit mit jedem Level erhöhen.

Sammelbares

Sammelbares können Münzen sein oder wie in Super Mario Pilze. Sammelbares wird in Jump 'n' Runs gerne eingesetzt, weil es Spaß macht Dinge zu sammeln. Sie werden gerne als Währung eingesetzt, was dazu anregt sich auf das Sammeln zu konzentrieren.

Tipps für ein gutes Jump 'n' Run [3]

Für mehr Tipps und genauere Definitionen hier klicken.

Wie programmiert man ein Jump 'n' Run?

Hier werden nur ein paar Tricks und die Implementierung physikalischer Eigenschaften in Code gezeigt. Es wird in Pseudo-Code geschrieben.

Player

Der Player ist der wichtigste Teil eines Jump 'n' Runs und er muss viel können.

Variablen

Ein Player sollte folgende Variablen besitzen:

  • eine X- und eine Y-Position
  • eine X- und eine Y-Geschwindigkeit
  • ein alte X- und eine alte Y-Position
  • ein oder mehrere Sprites
program Player {
   Zahl x
   Zahl y
   Zahl xSpeed
   Zahl ySpeed
   Zahl altX
   Zahl altY
   Bild sprite
}

Springen

function Springen () {
   ySpeed = -100 //Hier belibige Zahl nehmen. Die Zahl ist negativ, da der oberste Pixel im Fenster die 0 ist.
}
 
function Update (Zahl ΔZeit) { //ΔZeit ist die Differenz der Systemzeit des letzten und des jetzigen Frames.
   y = y + ySpeed * ΔZeit
   ySpeed = ySpeed + 9,81 * ΔZeit //Physikalisch nicht 100% korrekt, aber einfach zu verstehen und umzusetzen.
}

Kollisionen bei kachelbasierten Spielen

Damit Kollisionen funktionieren muss man auf die alle Kacheln zugreifen können. So funktioniert die Kollisionserkennung.

function Update () {
   altX = x
   altY = y
   ... laufen und springen ...
   for alleKacheln
     if kollidiert then
        x = altx
        y = alty
        //Setzt den Spieler auf die richtig Position zurück
}

Diesen Code kann man auch bei allen anderen Spielen einsetzten, man muss nur die Kollision richtig (anders) überprüfen. Bei großen Leveln ist die überprüfung aller Kacheln in jedem Frame sehr zeitaufwendig, dann lohnt es sich die Level in "Chunks" (kleinere Bereiche) aufzuteilen.

Background

Der Backgound ist das Bild, das im Hintergrund (engl. background) des Levels zu sehen ist. Wichtig: Damit es richtig funktioniert muss der Background min. halb so breit und genauso hoch wie das Fenster sein.

Ein einfacher Background der sich mitbewegt

[4]

program Background {
   Zahl x
   Bild background
 
   function Update (Zahl ΔZeit) {
      x = x + Player.xSpeed * ΔZeit * 0,25 //* 0,25 damit sich der Hintergrund langsamer bewegt
      if x < 0 then x = background.width
      if x > background.width then x = 0
   }
 
   function Render () {
      background.RenderAtPosition(x, 0)
      background.RenderAtPosition(x - background.width, 0)
      background.RenderAtPosition(x + background.width, 0)
   }
}


Für mehr Tipps, wie man ein Jump 'n' Run programmiert, hier klicken (englisches Tutorial).

Einzelnachweise

  1. Wikipedias Jump 'n' Run-Artikel
  2. Wikipedias Artikel zu Kachelbasierten Spielen (Tile-based games)
  3. Tipps für ein lustiges Jump 'n' Run
  4. YouTube-Video zur Java-Spieleprogrammierung
Meine Werkzeuge
Namensräume
Varianten
Aktionen
Navigation
Werkzeuge