Come far scivolare uniformemente il giocatore contro il terreno

Sto realizzando un gioco isometrico. Quando il giocatore cerca di camminare in diagonale contro un muro, voglio che scivolino dolcemente attraverso di esso, quindi viene utilizzata qualunque parte del movimento sia legale e qualsiasi cosa nella direzione del normale viene gettata via. Le pareti possono avere qualsiasi angolo, non solo verticale o orizzontale, e il giocatore ha un movimento a 360 °.

Mi sento quasi arrivato, ma non riesco a mettere a posto l'ultimo pezzo.

Aggiornamento: grandi novità a tutti! Ho funzionato. Ma ... sono un po 'confuso su cosa dovrei normalizzare e cosa no. Il normale deve solo essere un vettore unitario, giusto? ma poi lo sto mescolando con il mio input, quindi lo sto normalizzando - sbaglio?

A proposito, ho anche scoperto che devo spingere il giocatore di 1 pixel nella direzione del normale, in modo che non rimangano bloccati sulle cose - funziona bene.

Proiettate semplicemente il vostro vettore di movimento sul piano normale e quindi sottraggete il risultato dal vostro vettore di movimento.

Vector undesiredMotion = normal * (dotProduct(input, normal));
Vector desiredMotion = input - undesiredMotion;

Qualcosa del genere comunque. Anche se nel tuo bel diagramma l'ingresso sembra essere lontano dal muro, quindi sono leggermente confuso.

Mentre è semplice rimuovere semplicemente il componente del movimento che è nella direzione del normale, può invece adattarsi al tuo gameplay per ruotare il vettore di movimento. Ad esempio, in un gioco d'azione in terza persona, potrebbe essere facile rimanere leggermente appesi alle pareti e ad altri confini, in modo da poter fare delle ipotesi su ciò che il giocatore intende.

// assume that 'normal' is unit length
Vector GetDesired(Vector input, Vector normal) {
   // tune this to get where you stop when you're running into the wall,
   // vs. bouncing off of it
   static float k_runningIntoWallThreshold = cos(DEG2RAD(45));

   // tune this to "fudge" the "push away" from the wall
   static float k_bounceFudge = 1.1f;

   // normalize input, but keep track of original size
   float inputLength = input.GetLength();
   input.Scale(1.0f / inputLength);

   float dot = DotProduct(input, normal);

   if (dot < 0)
   {
      // we're not running into the wall
      return input;
   }
   else if (dot < k_runningIntoWallThreshold)
   {
      Vector intoWall = normal.Scale(dot);
      intoWall.Scale(k_bounceFudge);

      Vector alongWall = (input - intoWall).Normalize();
      alongWall.Scale(inputLength);

      return alongWall;
   }
   else
   {
      // we ran "straight into the wall"
      return Vector(0, 0, 0);
   }
}