Eu tenho lido sobre detecção de colisão em jogos em stackoverflow e outros sites. Muitos deles falam sobre BSPs, elipses limitantes, integração, etc. No entanto, no NES, eles conseguiram fazer detecção de colisão de chão e parede em jogos e acho difícil acreditar que eles fizeram muitos cálculos para detectar colisões de parede.

Eu acho que a minha pergunta é, dado um nível composto de apenas telhas, como eles detectaram colisões com paredes e pisos em jogos como Mario e Megaman, que tinham pouco poder de processamento?

Eles seguiram o caminho do movimento e determinaram o ladrilho de conexão mais próximo? (um pouco de pesquisa) (priori)Eles determinaram uma colisão com o chão e depois descobriram a melhor maneira de ajustar o personagem? (a posteriori) Isto é arriscado com timesteps variáveis, você poderia saltar através de um azulejo se você fosse rápido o suficiente. Embora eu assuma que os timesteps dos jogos da NES foram sincronizados com a taxa de atualização da tv.A gravidade está sempre afetando seu caráter quando você está no chão? Ou você simplesmente "desliga" quando você está determinado a andar em uma telha? E quando você sai de uma borda do penhasco? Você precisaria de algum modo de determinar as peças embaixo de você.Se você colidiu com um ladrilho, você apenas encontraria a borda daquele ladrilho e moveria seu personagem para o lado dele (dependendo da direção da viagem)?que tal telhas inclinadas como em super metroid e mario?E sobre "plataformas", onde você pode saltar pelo fundo e aterrissar no topo. Como você lidaria com colisões com essas peças se estivesse fazendo isso "a posteriori"?

Eu escrevi algum código de colisão que é basicamente 'priori' enquanto ele procura o primeiro bloco que você vai atingir em uma certa direção. Só estou me perguntando se há um jeito melhor. (usando a detecção de colisão depois do fato, talvez)

por exemplo, código para verificar colisões de ladrilhos para mover para baixo (eu verifico vert e depois movimento 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