Czytałem o wykrywaniu kolizji w grach na stackoverflow i innych stronach. Wielu z nich mówi o BSP, ograniczaniu elipsów, integracji itp. Jednak w NES udało im się wykryć kolizje podłóg i ścian w grach i trudno mi uwierzyć, że wykonali wiele obliczeń w celu wykrycia kolizji ścian.

Myślę, że moje pytanie brzmi, biorąc pod uwagę poziom złożony z płytek, jak wykryli kolizje ze ścianami i podłogami w grach takich jak Mario i Megaman, które miały niewielką moc obliczeniową?

Czy podążali ścieżką ruchu i określali najbliższy łączący się kafelek? (trochę wyszukiwania) (priori)Czy określili kolizję z podłogą, a następnie ustalili najlepszy sposób dostosowania postaci? (posteriori) Jest to ryzykowne ze zmiennymi znacznikami czasu, możesz przeskoczyć przez kafelek, jeśli jesteś wystarczająco szybki. Chociaż zakładam, że znaczniki czasu gier NES były synchronizowane z częstotliwością odświeżania telewizora.Czy grawitacja zawsze wpływa na twoją postać, gdy jesteś na ziemi? A może po prostu „wyłączasz”, gdy jesteś zdecydowany chodzić po kaflu? A co, kiedy zejdziesz z krawędzi urwiska? Potrzebowałbyś jakiegoś sposobu określania kafelków pod tobą inaczej.Jeśli zderzyłeś się z płytką, czy znalazłbyś krawędź tego kafelka i przesunął swoją postać na bok (w zależności od kierunku podróży)?co ze spadzistymi płytkami jak w super metroidach i mario?A co z „platformami”, gdzie możesz przeskakiwać przez dno i lądować na szczycie. Jak radziłbyś sobie z kolizjami z tymi kafelkami, gdybyś robił to „posteriori”?

Napisałem kod kolizji, który jest w zasadzie „priori”, gdy szuka pierwszej płytki, którą trafisz w określonym kierunku. Zastanawiam się tylko, czy jest lepszy sposób. (może zamiast tego użyć wykrywania kolizji po fakcie)

np. kod do sprawdzania kolizji płytek w celu przesunięcia w dół (sprawdzam ruch w poziomie, a następnie w poziomie):

  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