He estado leyendo sobre la detección de colisiones en juegos en stackoverflow y otros sitios. Muchos de ellos hablan de BSP, elipses de límites, integración, etc. Sin embargo, en la NES, lograron detectar la colisión en el piso y la pared en los juegos y me cuesta creer que hicieron muchos cálculos para detectar colisiones en la pared.

Supongo que mi pregunta es que, dado un nivel compuesto solo por azulejos, ¿cómo detectaron colisiones con paredes y pisos en juegos como Mario y Megaman que tenían poca capacidad de procesamiento?

¿Siguieron el camino del movimiento y determinaron la baldosa de conexión más cercana? (un poco de búsqueda) (a priori)¿Determinaron una colisión con el piso y luego descubrieron la mejor manera de ajustar el personaje? (posteriori) Esto es riesgoso con pasos de tiempo variables, podría saltar a través de una ficha si fuera lo suficientemente rápido. Aunque supongo que los tiempos de los juegos de NES se sincronizaron con la frecuencia de actualización de la televisión.¿La gravedad siempre afecta a tu personaje cuando estás en el suelo? ¿O simplemente lo 'apaga' cuando está decidido a caminar sobre una baldosa? ¿Qué pasa cuando caminas por un borde del acantilado? Necesitarías algún tipo de manera de determinar las fichas debajo de ti, de lo contrario.Si chocó con una ficha, ¿encontraría el borde de esa ficha y movería a su personaje a un lado (dependiendo de la dirección del viaje)?¿Qué hay de los azulejos inclinados como en super metroid y mario?¿Qué pasa con las 'plataformas' donde puedes saltar a través de la parte inferior y aterrizar en la parte superior? ¿Cómo manejaría las colisiones con estos mosaicos si lo estuviera haciendo 'posteriori'?

He escrito un código de colisión que es básicamente 'a priori', ya que busca la primera ficha que golpearás en cierta dirección. Me pregunto si hay una mejor manera. (simplemente utilizando la detección de colisión posterior al hecho, tal vez)

por ejemplo, código para verificar colisiones de azulejos para moverse hacia abajo (verifico vert y luego movimiento horizontal):

  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