Boa maneira de lidar com IA fora da tela?

Por exemplo, saquê:

• Digamos que existem 10 quartos no mundo.
• E digamos que o mundo seja habitado por 10 entidades.
• E cada entidade possui sua própria "rotina diária", na qual executa determinadas ações na sala e também pode navegar entre as salas.

Como o jogador pode estar apenas em uma sala de cada vez, qual é uma boa maneira de acompanhar as ações que as outras entidades estão realizando em outras salas fora da tela?

1. A opção mais direta é verificar cada uma das 10 entidades em cada quadro, verificar sua posição / estado e determinar se a entidade deve ou não estar na sala em que o jogador está localizado a qualquer momento. (Isso, no entanto, parece realmente muito pesado, especialmente quando o valor da sala / entidade é aumentado.)

2. Outra opção é acompanhar o tempo decorrido desde o início do jogo, então cada uma das entidades verifica se seu padrão se cruza com a sala em que o jogador está, e se isso verifica com o tempo se o jogador está ou não A entidade deve estar na mesma sala nesse momento específico, as entidades cujos padrões não se cruzam com a sala atual em que o jogador está localizado não fazem nada até que o jogador entre em uma sala na qual seu padrão se cruza e somente nesse ponto calcule se deve ou não eles devem renderizar. (Mas se eles interagirem com a sala, deverão sempre verificar o estado das salas que cruzam sua rota para determinar sua localização naquele momento, o que não é tão bom.)

3. A terceira opção a que cheguei seria, antes de mais nada, olhar apenas as rotas que cruzam a localização do jogador (como descrito anteriormente); depois, ao entrar em uma sala, verificar se o jogador está nessa sala; se não, verificar apenas o estado da sala e quanto tempo levará para avançar para a próxima sala. Por exemplo, um NPC de zelador entra na sala, verifica o estado da sala, vê que há um derramamento feito pelo jogador, calcula quanto tempo levará para limpar isso e quanto tempo levará o caminho etc. E até o mencionado é hora de entrar na próxima sala, só verificamos se o jogador está na sala. A localização exata do NPC para fins de renderização somente será calculada quando o jogador entrar na sala.

Depois de um tempo de brainstorming, cheguei à terceira opção, mas fiquei pensando se talvez haja uma maneira conhecida ou melhor de lidar com coisas como essas.

Uma abordagem muito simples é usar o "Nível de detalhe da IA". Grosso modo, isso significa que você atualiza a IA com mais frequência, quanto mais próximo do player / câmera. Você também pode reduzir a complexidade dos cálculos de IA que estão mais longe, esp. para encontrar o caminho. Afinal, se o jogador não consegue ver o personagem direito ou não, não faz sentido se esforçar muito para simular o personagem com a maior precisão.

No seu exemplo, a sala em que o jogador está pode ter a maior precisão (a AI atualiza todos os quadros, com resolução total). As salas adjacentes podem ter a próxima precisão mais alta (atualiza a cada 10 tiques, remove suavização de caminho e animações). Todas as outras salas podem ter a menor precisão (atualiza a cada segundo, localização de caminho de baixa resolução, elimina interações não essenciais de NPC para NPC).

Jogos maiores e mais complexos podem (e têm) usado abordagens semelhantes. Eles podem simplificar os cálculos de combate, teleportar personagens em vez de encontrá-los quando precisam se mover, etc.

Se o seu jogo for grande o suficiente para que você não consiga manter tudo em memória o tempo todo, uma boa solução é armazenar o último tempo de atualização nos dados salvos da sala e reproduzir a simulação fora da tela (na resolução mais baixa) quando está carregado de volta.

Se você espera que a IA se mova para áreas "ativas" a partir de áreas "adormecidas" não carregadas em um cronograma, convém criar dados de fidelidade super baixa para essas regiões manterem em memória o tempo todo (por exemplo, apenas as mais grosseiras) nível de detalhe navmesh e locais principais de objeto / personagem) ou você deseja alternar periodicamente essas áreas (por exemplo, mantenha X áreas "adormecidas" na memória e simulação com baixa fidelidade com atualizações infreqüentes e, em seguida, alterne entre elas " adormecido "que possuem NPCs ativos principais, descarregando e carregando áreas ao fazê-lo).

Eu armazenaria as entidades que estão atualmente em uma sala nessa instância da sala, o objeto da sala também acompanhará quando as entidades precisam ser atualizadas (por exemplo, viajar para outra sala ou alterar algo nessa sala etc.). E eu também atualizaria uma (ou mais) sala a cada segundo (talvez em outro segmento).

Quando você atualiza uma sala, as posições do NPC devem ser atualizadas e todas as ações que eles executaram que interagem com a sala desde a última atualização também devem ser tratadas. Por fim, a hora da próxima atualização necessária deve ser verificada / atualizada.

Se uma entidade viaja de uma sala para outra, sua instância deve ser armazenada na outra sala e a próxima atualização da entidade também deve ser atualizada.

Dessa forma, você só precisa atualizar a sala atual e as salas que têm uma atualização agendada nesse momento; atualizar as outras salas é apenas opcional (mas recomendado se você tiver uma IA que seja atualizada sempre que o jogador se mover ou fizer alguma coisa) .