Evitar catástrofes de sobreviragem em jogos de corrida

Ao jogar GTA III no Android, notei algo que me incomodava em quase todos os jogos de corrida que joguei (talvez exceto Mario Kart): Dirigir sempre em frente é fácil, mas as curvas são realmente difíceis. Quando troco de faixa ou passo por alguém, o carro começa a girar para frente e para trás, e qualquer tentativa de corrigi-lo só piora. A única coisa que posso fazer é pisar no freio. Eu acho que isso é algum tipo de oversteering.

O que o torna tão irritante é que isso nunca acontece comigo na vida real (graças a Deus :-)), então 90% dos jogos com veículos dentro parecem irreais para mim (apesar de provavelmente ter realmente bons motores de física). Conversei com algumas pessoas sobre isso, e parece que você 'pega' jogos de corrida ou não. Com muita prática, consegui me tornar semi-bom em alguns jogos (por exemplo, da série Need for Speed), dirigindo com muito cuidado, freando muito (e geralmente sentindo cãibras nos dedos).

O que você pode fazer como desenvolvedor de jogos para evitar a catástrofe de ressonância excessiva e fazer a direção parecer certa? (Para um jogo de corrida casual, que não busca uma física 100% realista)

Também me pergunto o que jogos como Super Mario Kart fazem exatamente de forma diferente, para que eles não tenham tanto excesso de controle?

Acho que um problema é que, se você toca com um teclado ou uma tela sensível ao toque (mas não com rodas e pedais), só tem entrada digital: gás pressionado ou não, direção esquerda / direita ou não, e é muito mais difícil dirigir adequadamente por um dada velocidade. A outra coisa é que você provavelmente não tem um bom senso de velocidade e dirige muito mais rápido do que faria (com segurança) na realidade. Do alto da minha cabeça, uma solução pode ser variar a resposta da direção com a velocidade.

Uma solução seria enganar um pouco e adivinhar o que o jogador quer fazer. Quando o jogador está em uma seção reta e pressiona à esquerda, você pode assumir que ele quer mudar de faixa. Quando ele está perto de uma curva ou cruzamento, ele certamente quer virar. O jogador não consegue controlar seu ângulo exato de direção em uma curva; portanto, você pode optar por dar ao jogador o benefício da dúvida e sempre deixá-lo percorrer as curvas no ângulo ideal quando ele pressiona o botão giratório no momento certo (desde quanto fisicamente possível - qualquer jogador que tentar dirigir com uma curva em gancho de cabelo a 200 km / h merece ser punido por um pequeno vôo sobre a grama).

Isso, é claro, pode ficar complicado quando o jogador realmente quer virar em uma seção reta ou realmente quer mudar de faixa antes de um cruzamento.

Outra solução seria ter uma diferença entre pressionar e segurar uma tecla. Quanto mais tempo o jogador segurar a tecla Turn, maior será o ângulo de rotação. Isso nem parece irreal, porque quando você tem um volante, precisa de tempo para girá-lo completamente.

Editar: em uma tela sensível ao toque, você pode usar controles deslizantes em vez de botões para controlar a direção e a velocidade de forma analógica. Quando a tela é sensível à pressão, você também pode interpretar a pressão (mas fornecer feedback visual sobre a pressão máxima, ou jogadores com excesso de zelo podem interromper a exibição). Quando o dispositivo possui sensores de orientação, você pode usar a inclinação do dispositivo para controlar a direção.

Eu me deparei com essa pergunta (antiga) enquanto pesquisava o que outros jogos além de Grand Theft Auto IV e V implementaram, mas tenho uma resposta decente para obter sobreviragem controlável. Eu só tenho alguma experiência brincando com o modelo de direção no Grand Theft Auto V, mas essas informações devem ser aplicáveis ​​aos modelos de direção mais realistas.

O que parece acontecer na maioria dos jogos de direção é que a saída da direção do carro está diretamente ligada à entrada do jogador - mesmo que algum tipo de suavização (temporal) seja usada. Isso causa uma sensação lenta ou brusca - e o carro não se corrige depois de soltar os controles. Isso contrasta com um carro real, onde o carro tende a se centralizar depois de liberar força no volante. Alguns jogos tentam corrigir isso alterando o modelo de manipulação ou tendo modelos de manipulação de arcade.

O que pode ser observado no Grand Theft Auto V, é que a entrada da direção do usuário não está diretamente ligada à saída da direção. O veículo dirige sozinho, em direção ao seu vetor de velocidade atual. Isso é visível ao forçar uma ligeira situação de sobreviragem e observar as rodas de direção - sem nenhuma entrada, elas contra-atacam sozinhas. Qualquer entrada do usuário é adicionada sobre essas correções "naturais".

Uma desvantagem dessa abordagem, no entanto, é o carro parecer muito pegajoso e um pouco teimoso para entrar em um deslizamento de poder ou deriva - de modo que esse valor no contra-ataque pode ser limitado a algum ângulo.

Essa teoria pode ser verificada reimplementando o sistema de direção e comparando-o com o comportamento original.

• Ao vincular a entrada à saída diretamente, o veículo é realmente extremamente difícil de controlar, mesmo depois de aplicar o limitador de entrada da direção com base na velocidade.
• Ao adicionar o contra-ataque natural, o comportamento é quase idêntico à implementação dos jogos, mas os carros são "muito" estáveis.
• Ao adicionar um limite de 15 graus ao contra-ataque, o comportamento é quase idêntico.

Um aspecto a ter em mente é que Grand Theft Auto V foi considerado "ideal" aqui - embora eu ainda precise encontrar outro jogo que implemente esse sistema.

Se você está curioso para algum código, aqui está um trecho da minha implementação.

// Returns in radians
float Racer_calculateDesiredHeading(float steeringMax, float desiredHeading,
    float reduction) {
    desiredHeading *= reduction;
    float correction = desiredHeading;

    // Get the relative velocity vector
    Vector3 speedVector = ENTITY::GET_ENTITY_SPEED_VECTOR(vehicle, true);
    if (abs(speedVector.y) > 3.0f) {
        // Simplify it to an angle
        Vector3 target = Normalize(speedVector);
        float travelDir = atan2(target.y, target.x) - static_cast<float>(M_PI) / 2.0f;
        if (travelDir > static_cast<float>(M_PI) / 2.0f) {
            travelDir -= static_cast<float>(M_PI);
        }
        if (travelDir < -static_cast<float>(M_PI) / 2.0f) {
            travelDir += static_cast<float>(M_PI);
        }
        // Correct for reverse
        travelDir *= sgn(speedVector.y);

        // Limit to some degree, R* uses 15 degrees
        travelDir = std::clamp(travelDir, deg2rad(-15.0f), deg2rad(15.0f));

        // User input deviation
        correction = travelDir + desiredHeading;
    }

    return std::clamp(correction, -steeringMax, steeringMax);
}