Top-Down-Space-Game-Control-Problem

Wie der Titel schon sagt, entwickle ich ein Top-Down-Weltraumspiel.

Ich möchte keine Newtonsche Physik mit dem vom Spieler kontrollierten Schiff verwenden. Ich versuche ein Kontrollschema zu erreichen, das dem von FlatSpace 2 (fantastisches Spiel) ähnelt. Ich kann nicht herausfinden, wie ich dieses Gefühl mit Tastatursteuerungen im Gegensatz zu Maussteuerungen erreichen kann. Irgendwelche Vorschläge?

Ich verwende Unity3d und C # oder JavaScript (UnityScript oder was auch immer der richtige Begriff ist) funktioniert gut, wenn Sie einige Codebeispiele löschen möchten.

Bearbeiten: Natürlich sollte ich das Steuerungsschema von FlatSpace 2 beschreiben, sorry. Sie halten die Maustaste gedrückt und bewegen die Maus in die Richtung, in die sich das Schiff bewegen soll. Aber es sind nicht die Bedienelemente, die ich nicht weiß, sondern das Gefühl einer Mischung aus Autofahren und Flugzeugfliegen. Es ist wirklich gut gemacht. Youtube-Link: FlatSpace2 auf dem iPhone

Ich entwickle kein iPhone-Spiel, aber das Video zeigt das Prinzip des Bewegungsstils.
Bearbeiten 2 Da ein geringes Interesse zu bestehen scheint, werde ich die Version des Codes veröffentlichen, mit dem ich fortgefahren bin. Es funktioniert gut genug. Manchmal reicht gut genug!

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

}

Wenn ich das richtig verstehe, möchten Sie, dass die Pfeile nach links und rechts Ihr Schiff drehen und die Pfeile nach oben und unten, um den Schub zu steuern.

Ich habe dieses Steuerungsschema in einem Space-Shooter-Prototyp implementiert, den ich einmal erstellt habe.

Der folgende Code ist ein sehr naives, nicht sprachspezifisches Codebeispiel. Nimm es nicht zu wörtlich.

EDIT: OOps, der Code begrenzt keine negative Beschleunigung, die durch Reibung verursacht wird. Das Schiff wird also nach einer Weile tatsächlich rückwärts fahren. Also den "Code" ein bisschen geändert.

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
}

Ich habe den Pseudo-Code in C # konvertiert:

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

Wenn etwas nicht stimmt, hinterlassen Sie bitte einen Kommentar.

Vielen Dank an Nailer für die Bereitstellung von Pseudo-Code