Wie haben ältere Spiele Kollisionserkennung mit Wänden, Böden und Decken gemacht?

Habe ich gelesen, über die Detektion von Kollisionen in spielen auf stackoverflow und anderen Webseiten. Viele von Ihnen sprechen über BSPs, begrenzenden Ellipsen, integration usw. Aber auf dem NES, gelang es Ihnen, das zu tun (Wand und Boden Kollisionsabfrage im Spiele-und ich finde es schwer zu glauben, dass Sie haben vielen Berechnungen, um zu erkennen, Wand-Kollisionen.

Ich denke, meine Frage ist, da eine Ebene aus Fliesen, wie haben Sie Kollisionen mit Wänden und Böden in Spiele wie Mario und Megaman hatte wenig Prozessorleistung?

  • Haben Sie Folgen dem Weg der Bewegung und die Bestimmung der engsten Verbindung Kachel? (ein bisschen suchen) (priori)
  • Haben Sie bestimmen, um eine Kollision mit dem Boden und dann herauszufinden, der beste Weg, die Anpassung der Charakter? (posteriori) Das ist riskant mit Variablen Zeitintervallen, die Sie springen könnte durch eine Kachel, wenn Sie schnell genug waren. Auch wenn ich davon ausgehen NES-Spiele Zeitintervallen wurden synchronisiert mit den tv refresh rate.
  • Ist die Schwerkraft immer auf Ihre Zeichen, wenn Sie auf dem Boden? Oder haben Sie einfach 'ausschalten', wenn Sie sich entschlossen haben, zu Fuß auf einer Fliese? Was ist, wenn Sie zu Fuß aus, ein Rand der Klippe? Sie müssten eine Art und Weise der Bestimmung der Fliesen unter Ihnen anders.
  • Wenn Sie haben, kollidierte mit einem Plättchen, würden Sie gerade finden, die Kante der Fliese und bewegen Sie Ihren Charakter auf der Seite (je nach Fahrtrichtung)?
  • was über schräge Fliesen wie in super metroid und mario?
  • Was über "Plattformen", wo können Sie springen durch den Boden und landet auf der Spitze. Wie würden Sie umgehen mit Kollisionen mit diesen Kacheln, wenn Sie es Taten, 'posteriori'?

Ich geschrieben habe, einige Kollisions-code-das ist im Grunde 'priori', wie es sucht nach dem ersten Ziegel, die Sie treffen, in eine bestimmte Richtung. Ich Frage mich nur, ob es einen besseren Weg. (nur unter Verwendung der nach-der-Tatsache Kollisionserkennung statt vielleicht)

eg, code zu überprüfen, für Fliesen-Kollisionen bei der Bewegung nach unten (ich check vert dann horizontale Bewegung):

  def tile_search_down(self, char, level):
        y_off = char.vert_speed
        assert y_off > 0

        # t_ are tile coordintes
        # must be int.. since we're adding to it.
        t_upper_edge_y = int( math.ceil((char.y+char.h) /self.tile_height ) ) #lowest edge
        while (t_upper_edge_y*self.tile_height) < (char.y+char.h+y_off): # lowest edge + offset

            t_upper_edge_x = int( math.floor(char.x/self.tile_width) )
            while (t_upper_edge_x*self.tile_width) < (char.x+char.w):

                t_x = t_upper_edge_x
                t_y = t_upper_edge_y 
                if self.is_tile_top_solid(t_x, t_y, plane):
                    char.y = t_y*self.tile_height - char.h
                    char.vert_speed = 0.0
                    char.on_ground = True
                    return

                t_upper_edge_x += 1
            t_upper_edge_y += 1

        char.y += y_off

InformationsquelleAutor der Frage Nick Sonneveld | 2009-07-15

Schreibe einen Kommentar