Como posso implementar um recurso de "avanço rápido" no meu jogo?

Como posso implementar o recurso de avanço rápido para o meu jogo de defesa como em http://fieldrunners.com/ e outros jogos de TD?

Estou usando o Unity 3D. Haveria algo para gerenciar menos quadros por segundo ou algum tipo de movimento rápido manual de inimigos e velocidade de disparo da torre, etc.

se o seu jogo não tiver simulações complicadas ou computacionalmente caras que exijam separá-las em cronogramas de atualização independentes, você pode usar uma abordagem simples de basear o código em suas Update()funções no valor Time.time do Unity e, em seu código, definir o valor de Time .timeScale para ser o que você quiser. 0 == pausado, 1 = normal, nossos testadores adoram definir timeScale> 1 para fazer as coisas mais rapidamente.

http://unity3d.com/support/documentation/ScriptReference/Time-timeScale.html

Abordagem: Maior taxa de simulação

Seu tempo para a interface do usuário deve ser dissociado do loop do jogo real, assim como a renderização. Digamos, por exemplo, que seu mundo corra em velocidade 4x. Digamos que, na sua velocidade básica (1x), seu jogo executa 30 atualizações por segundo.

Você teria algo como o seguinte, quando estiver no modo de avanço rápido:

• A lógica mundial executa 4 atualizações para cada atualização da interface do usuário e do renderizador. Isso significa que ele precisa executar 120 atualizações por segundo. Assim, seu modelo mundial (dados) é atualizado nessa taxa.
• A lógica do renderizador e da interface do usuário continua pesquisando ou fazendo o que quer, com 30 atualizações por segundo.

Em outras palavras, o jogo como um todo não está rodando mais rápido. A simulação parte da é.

Você pode deduzir duas coisas disso:

1. Você precisa manter o seu jogo de lógica simples o suficiente para que você pode facilmente executá-lo quatro vezes mais rápido em sua plataforma de destino, ou você precisa de introduzir métodos de extrapolar vários aspectos do jogo mais rapidamente - isso pode resultar, no entanto, em um modelo que é diferente do que teria sido se você tivesse simplesmente usado uma simulação de ritmo mais rápido. Portanto, o compromisso seria o custo de processamento para a precisão. Veja a abordagem 2 abaixo.

2. É a separação de preocupações que permite acelerar facilmente a simulação do mundo, sendo essa separação modelo, visualização e controlador ( MVC ). Se seus dados mundiais (M), lógica de renderização (V) e lógica de jogo (C) estiverem todos misturados, você realmente não será capaz de fazer isso, pelo menos não sem enxaqueca maciça.

Abordagem: Extrapolação baseada em deltas temporais

Como mencionado acima, você precisará calcular o movimento com base na distância que algo teria percorrido em um determinado período. Isso pressupõe que a física do jogo seja inerentemente mais realista em sua simulação, o que pode não ser o caso. Este é um tópico bastante maior e consideravelmente mais complexo. Você precisará fazer mais perguntas sobre se deseja saber. Basicamente, você fará alguns cálculos para acertar as coisas. Você precisará lidar com a interpenetração em colisões e uma série de outras questões que não abordarei aqui.

Concluir

Isso fornece o esboço geral. Sua escolha de idioma é sua, presumivelmente você sabe como fazer isso no Unity ou não. O tempo em qualquer idioma exige que você entenda os detalhes de cada detalhe, sugiro começar pelos artigos de Gaffer e verificar os documentos da API da Unity.

Como princípio geral, a atualização da lógica do jogo deve ser dissociada da atualização dos gráficos do jogo - ou seja, a simulação de sua jogabilidade, IA, movimento de unidade etc. não deve estar ligada à velocidade com que o jogo está sendo renderizado. . Geralmente, o loop principal do jogo calcula quanto tempo passou desde a última atualização do jogo e envia essa etapa de tempo delta para as rotinas de atualização de cada objeto lógico do jogo.

Nesse cenário, torna-se simples implementar a escala de tempo (incluindo o avanço rápido) em seu jogo. Simplesmente pré-multiplique o passo da lógica do jogo por algum valor escalar que controla quanto "avançar rapidamente" ou diminuir o tempo. Por padrão, esse valor seria um e, por exemplo, quando o usuário pressionar a tecla "avanço rápido", você o definirá como 1,5 e todas as simulações parecerão 50% mais rápidas. Você ainda renderizaria na mesma taxa, no entanto.

Não estou muito familiarizado com o Unity e, portanto, poderia estar errado na sugestão a seguir, mas o Unity possui um componente de gerenciamento de tempo que pode ser útil para implementar isso. Na verdade, ele já possui uma propriedade de escala de tempo. A descrição do componente implica que a classe foi projetada para objetos de física, mas também pode ser aplicável ao seu cenário.