Ich habe über die Kollisionserkennung in Spielen auf Stackoverflow und anderen Sites gelesen. Viele von ihnen sprechen über BSPs, Bounding Elipses, Integration usw. Auf dem NES ist es ihnen jedoch gelungen, Boden- und Wandkollisionen in Spielen zu erkennen, und ich kann kaum glauben, dass sie viele Berechnungen zur Erkennung von Wandkollisionen durchgeführt haben.

Ich schätze, meine Frage ist, wie sie bei einem Level, das nur aus Kacheln besteht, Kollisionen mit Wänden und Böden in Spielen wie Mario und Megaman entdeckten, die wenig Rechenleistung hatten.

Sind sie dem Bewegungsweg gefolgt und haben sie die nächstgelegene Verbindungskachel bestimmt? (ein bisschen suchen) (priori)Haben sie eine Kollision mit dem Boden festgestellt und dann herausgefunden, wie der Charakter am besten angepasst werden kann? (posteriori) Dies ist mit variablen Zeitschritten riskant. Sie könnten durch ein Plättchen springen, wenn Sie schnell genug wären. Obwohl ich nehme, dass NES-Spiele Zeitschritte mit der Bildwiederholfrequenz des Fernsehers synchronisiert wurden.Beeinflusst die Schwerkraft immer Ihren Charakter, wenn Sie am Boden sind? Oder schalten Sie es einfach aus, wenn Sie entschlossen sind, auf einer Fliese zu laufen? Was ist, wenn du von einem Rand der Klippe gehst? Andernfalls müssten Sie die Kacheln unter sich auf irgendeine Weise bestimmen.Wenn Sie mit einem Plättchen kollidiert sind, finden Sie dann einfach den Rand dieses Plättchens und verschieben Ihren Charakter zur Seite (abhängig von der Fahrtrichtung)?Was ist mit schrägen Fliesen wie in Super Metroid und Mario?Was ist mit "Plattformen", auf denen Sie durch den Boden springen und oben landen können? Wie würden Sie mit Kollisionen mit diesen Kacheln umgehen, wenn Sie es "posteriori" machen würden?

Ich habe einen Kollisionscode geschrieben, der im Grunde genommen 'priori' ist, da er nach dem ersten Plättchen sucht, das Sie in eine bestimmte Richtung schlagen werden. Ich frage mich nur, ob es einen besseren Weg gibt. (Verwenden Sie stattdessen möglicherweise nur die Kollisionserkennung nach dem Entstehen)

zB Code, um nach Kachelkollisionen zu suchen, um sich nach unten zu bewegen (ich überprüfe dann die 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