Prevenire la catastrofe di sovrasterzo nei giochi di corse

Durante la riproduzione di GTA III su Android ho notato qualcosa che mi ha infastidito in quasi tutti i giochi di corse a cui ho giocato (forse tranne Mario Kart): guidare dritto è facile, ma le curve sono davvero difficili. Quando cambio corsia o passo qualcuno, la macchina inizia a girare avanti e indietro e ogni tentativo di correggerla non fa che peggiorare la situazione. L'unica cosa che posso fare è premere i freni. Penso che sia una sorta di sovrasterzo.

Ciò che lo rende così irritante è che non mi succede mai nella vita reale (grazie a Dio :-)), quindi il 90% dei giochi con veicoli all'interno mi sembra irreale (nonostante probabilmente abbia dei motori fisici davvero buoni). Ne ho parlato con un paio di persone, e sembra che tu "prendi" i giochi di corse, oppure no. Con molta pratica, sono riuscito a diventare semi-bravo in alcuni giochi (ad esempio dalla serie Need for Speed), guidando con molta cautela, frenando molto (e di solito ottenendo un crampo alle dita).

Cosa puoi fare come sviluppatore di giochi per prevenire la catastrofe di risonanza di sovrasterzo e far sentire la guida giusta? (Per un gioco di corse casuali, che non mira a una fisica realistica al 100%)

Mi chiedo anche quali giochi come Super Mario Kart fanno esattamente diversamente in modo che non abbiano un sovrasterzo così elevato?

Immagino che un problema sia che se giochi con una tastiera o un touchscreen (ma non ruote e pedali), hai solo input digitali: gas premuto o no, sterzo a sinistra / destra o no, ed è molto più difficile guidare in modo appropriato per un data velocità. L'altra cosa è che probabilmente non hai un buon senso della velocità e guidi molto più velocemente di quanto faresti (in sicurezza) nella realtà. Dall'alto della mia testa, una soluzione potrebbe essere quella di variare la risposta dello sterzo con la velocità.

Una soluzione sarebbe quella di imbrogliare un po 'e indovinare cosa vuole fare il giocatore. Quando il giocatore è su una sezione diritta e preme a sinistra, puoi presumere che voglia cambiare corsia. Quando è vicino a una curva o a un incrocio, sicuramente vuole girare. Il giocatore non è in grado di controllare il suo angolo di sterzata esatto in una curva, quindi puoi decidere di dare al giocatore il beneficio del dubbio e lasciarlo sempre guidare attraverso le curve nell'angolo ideale quando preme il pulsante di svolta al momento giusto (per quanto tempo come fisicamente possibile - ogni giocatore che tenta di guidare attraverso una curva a forcina con 200 km / h merita di essere punito da un breve volo sopra l'erba).

Questo, ovviamente, potrebbe diventare complicato quando il giocatore vuole davvero girare su una sezione dritta o in realtà vuole cambiare corsia appena prima di un incrocio.

Un'altra soluzione sarebbe quella di fare la differenza tra toccare un tasto e tenere premuto un tasto. Più a lungo il giocatore tiene la chiave di svolta, maggiore è l'angolo di svolta. Questo non sembra nemmeno irrealistico, perché quando hai un volante, hai bisogno di tempo per girarlo fino in fondo.

Modifica: su un touchscreen, è possibile utilizzare i cursori anziché i pulsanti per controllare lo sterzo e la velocità in modo analogico. Quando lo schermo è sensibile alla pressione, puoi anche interpretare la pressione (ma dare un feedback visivo sulla massima pressione, oppure i giocatori troppo zelanti potrebbero rompere i loro schermi). Quando il dispositivo dispone di sensori di orientamento, è possibile utilizzare l'inclinazione del dispositivo per controllare lo sterzo.

Mi sono imbattuto in questa (vecchia) domanda mentre cercavo quali altri giochi oltre a Grand Theft Auto IV e V hanno implementato, ma ho una risposta decente per ottenere un sovrasterzo controllabile. Ho solo un po 'di esperienza con il modello di guida in Grand Theft Auto V, ma queste informazioni dovrebbero essere applicabili alla maggior parte dei modelli di guida in qualche modo realistici.

Ciò che sembra accadere nella maggior parte dei giochi di guida, è che l'uscita dello sterzo dell'auto è direttamente collegata all'input del giocatore, anche se viene utilizzata una sorta di livellamento (temporale). Ciò provoca una sensazione lenta o a scatti - e la macchina non si corregge dopo aver lasciato andare i comandi. Ciò è in contrasto con un'auto reale, in cui l'auto tende a centrarsi dopo aver rilasciato la forza sulla ruota. Alcuni giochi cercano di correggere questo problema cambiando il loro modello di gestione o avendo modelli di gestione arcade.

Ciò che si può osservare in Grand Theft Auto V è che l'ingresso dello sterzo dell'utente non è direttamente collegato all'uscita dello sterzo. Il veicolo sterza da solo, verso il suo vettore di velocità attuale. Ciò è visibile quando si forza una leggera sovrasterzatura e si osservano le ruote sterzanti - senza alcun input, si contrappongono da sole. Qualsiasi input dell'utente viene quindi aggiunto a queste correzioni "naturali".

Un aspetto negativo di questo approccio, tuttavia, è che la macchina si sente troppo appiccicosa e un po 'testarda per entrare in una frana o una deriva - quindi questo valore di controsterzo può essere limitato a una certa angolazione.

Questa teoria può essere verificata reimplementando il sistema di sterzo e confrontandolo con il comportamento originale.

• Quando si collega direttamente l'input all'output, il veicolo è davvero estremamente difficile da controllare, anche quando si è applicato il limitatore dell'ingresso dello sterzo basato sulla velocità.
• Quando si aggiunge il controsterzo naturale, il comportamento è quasi identico all'implementazione dei giochi, ma le auto sono "troppo" stabili.
• Quando si aggiunge un limite di 15 gradi al counterteteer, il comportamento è quasi identico.

Una cosa da tenere a mente è che Grand Theft Auto V è stato preso come "ideale" qui - anche se devo ancora trovare un altro gioco che implementa questo sistema.

Se sei curioso di avere un po 'di codice, ecco uno snippet della mia implementazione.

// 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);
}