Problème de contrôle de jeu spatial de haut en bas

Comme le titre le suggère, je développe un jeu spatial de haut en bas.

Je ne cherche pas à utiliser la physique newtonienne avec le vaisseau contrôlé par le joueur. J'essaie de réaliser un schéma de contrôle quelque peu similaire à celui de FlatSpace 2 (jeu génial). Je ne peux pas comprendre comment obtenir ce sentiment avec les commandes du clavier par opposition aux commandes de la souris. Aucune suggestion?

J'utilise Unity3d et C # ou javaScript (UnityScript ou quel que soit le terme correct) fonctionne très bien si vous souhaitez supprimer des exemples de code.

Edit: Bien sûr, je devrais décrire le schéma de contrôle de FlatSpace 2, désolé. Vous maintenez le bouton de la souris enfoncé et déplacez la souris dans la direction dans laquelle vous souhaitez que le navire entre. Mais ce ne sont pas les commandes que je ne sais pas faire, mais plutôt la sensation d'un mélange de conduite d'une voiture et de vol d'un avion. C'est vraiment bien fait. Lien Youtube: FlatSpace2 sur iPhone

Je ne développe pas de jeu iPhone mais la vidéo montre le principe du style de mouvement.
Edit 2 Comme il semble y avoir un léger intérêt, je posterai la version du code que j'ai utilisé pour continuer. Cela fonctionne assez bien. Parfois assez bon suffit!

using UnityEngine;
using System.Collections;

public class ShipMovement : MonoBehaviour 
{
    public float directionModifier;
    float shipRotationAngle;
    public float shipRotationSpeed = 0;
    public double thrustModifier;
    public double accelerationModifier;
    public double shipBaseAcceleration = 0;
    public Vector2 directionVector;
    public Vector2 accelerationVector = new Vector2(0,0);
    public Vector2 frictionVector = new Vector2(0,0);
    public int shipFriction = 0;
    public Vector2 shipSpeedVector;
    public Vector2 shipPositionVector;
    public Vector2 speedCap = new Vector2(0,0);

    void Update() 
    {

   directionModifier = -Input.GetAxis("Horizontal");


   shipRotationAngle += ( shipRotationSpeed * directionModifier ) * Time.deltaTime;


   thrustModifier = Input.GetAxis("Vertical");

   accelerationModifier = ( ( shipBaseAcceleration * thrustModifier ) ) * Time.deltaTime;

   directionVector = new Vector2( Mathf.Cos(shipRotationAngle ), Mathf.Sin(shipRotationAngle) );
   //accelerationVector = Vector2(directionVector.x * System.Convert.ToDouble(accelerationModifier), directionVector.y * System.Convert.ToDouble(accelerationModifier));
   accelerationVector.x = directionVector.x * (float)accelerationModifier;
    accelerationVector.y = directionVector.y * (float)accelerationModifier;
   // Set friction based on how "floaty" controls you want

    shipSpeedVector.x *= 0.9f; //Use a variable here
    shipSpeedVector.y *= 0.9f; //<-- as well
   shipSpeedVector += accelerationVector;


   shipPositionVector += shipSpeedVector;

   gameObject.transform.position = new Vector3(shipPositionVector.x, 0, shipPositionVector.y);
    }

}

Donc, si je comprends bien, vous voulez que les flèches gauche et droite tournent votre vaisseau et les flèches haut et bas pour contrôler la poussée.

J'ai implémenté ce schéma de contrôle dans un prototype de jeu de tir spatial que j'ai réalisé une fois.

Le code ci-dessous est un exemple de code non spécifique à une langue très naïf. Ne le prenez pas trop à la lettre.

EDIT: OOps, le code ne limite pas l'accélération négative causée par le frottement. Le navire commencera donc à reculer après un certain temps. Donc un peu changé le "code".

update( deltaTime ) 
{

   if( leftButtonPressed ) 
   { 
      directionModifier = 1
   }
   else if ( rightButtonPressed ) {
      directionModifier = -1
   }
   else {
     directionModifier = 0;
   }

   shipRotationAngle += ( shipRotationSpeed * directionModifier ) * deltaTime;


   if( upButtonPressed ) {
     thrustModifier = 1
   }
   else if( downButtonPressed ) {
     thrustModifier = -1
   }
   else {
     thrustModifier = 0
   }



   accelerationModifier = ( ( shipBaseAcceleration * thrustModifier ) ) * deltaTime

   directionVector = Vector2( cos( shipRotationAngle ), sin ( shipRotationAngle ) )
   accelerationVector = Vector2( directionVector.x * accelerationModifier, directionVector.y * accelerationModifier )

   // Set friction based on how "floaty" controls you want
   frictionVector = -directionVector * shipFriction

   shipSpeedVector += accelerationVector

   // APPLY friction vector to shipSpeedVector
   // Make sure that friction vector doesn't speed to go in the opposite of the 
   // original direction. Otherwise your ship will go backwards instead of stop.

   //IMPORTANT: (I'm too lazy to add code here) Cap speedvector to a maximum speed.
   //Remember to cap total speed, not just X and Y components of the speedVector 


   shipPositionVector += shipSpeedVector
}

j'ai converti le pseudo-code en C #:

void Update() 
{

   directionModifier = Input.GetAxis("Horizontal");


   shipRotationAngle += ( shipRotationSpeed * directionModifier ) * Time.deltaTime;


   thrustModifier = Input.GetAxis("Vertical");

   accelerationModifier = ( ( shipBaseAcceleration * thrustModifier ) ) * Time.deltaTime;

   directionVector = new Vector2( Math.Cos(shipRotationAngle ), Math.Sin(shipRotationAngle) );
   accelerationVector = new Vector2( directionVector.x * accelerationModifier, directionVector.y * accelerationModifier );

   // Set friction based on how "floaty" controls you want
   frictionVector = -directionVector * shipFriction;

   shipSpeedVector += accelerationVector;

   // APPLY friction vector to shipSpeedVector
   // Make sure that friction vector doesn't speed to go in the opposite of the 
   // original direction. Otherwise your ship will go backwards instead of stop.

   //IMPORTANT: (I'm too lazy to add code here) Cap speedvector to a maximum speed.
   //Remember to cap total speed, not just X and Y components of the speedVector 


   shipPositionVector += shipSpeedVector;
}

S'il y a quelque chose de mal à cela, veuillez laisser un commentaire.

Merci à Nailer pour fournir le pseudo-code