Turbinen anhand der Lenkung bewegen lassen ?

[vreezer]

Dieses

beschreibt am besten was ich suche.

Ich möchte ein Script auf die Turbinen eines Hovercraft Fahrzeuges legen, damit sich die einzelnen Turbinen passend zur Lenkung bewegen. Ich habe leider aber keine Ahnung nach welchen Begriffen ich da suchen müsste. Fliegt da vielleicht ein Scriptbeispiel im Web rum ?

[Zer0Cool]

Ich vermute, daß unter dem Fahrzeug Wheelcollider hängen (die nicht sichbar sind) und diese über eine Fahrzeugsteuerung bewegt werden. Wenn er das Fahrzeug dann beispielsweise nach links fährt drehen diese Collider in die entsprechende Fahrrichtung ein und diese Rotation kann man dann vermutlich einfach auf die "Hoverkapseln" übertragen. Bedeutet, sobald man die Scripte für eine Fahrzeugsteuerung mit Wheelcollidern hat, ist es dann nur noch eine Umrechnung zwischen der horizontalen Rotation eines Wheelcollider und der vertikalen Rotation der entsprechend zugeordneten Hoverkapsel. Oder man nimmt den Winkel der über die Fahrzeugsteuerung definiert wird (z.b. der Maus) - der auf auf die Wheelcollider übertragen wird - und überträgt diesen Winkel direkt auf die vertikale Rotation der Hoverkapsel.

 

transform.Rotate(0, 0, zAngle);  // zAngle ist der Winkel des Lenkradeinschlags (steerAngle)

 

Du kannst diese Methode hier verwenden, um die Kapsel langsam zu drehen (aber ist evtl. nicht nötig, je nachdem wie deine Lenkung funktioniert):

void Update() {
 ...
 if(Input.GetAxis("Horizontal") != 0) {
     float maxSteeringAngle = 45.0f; // Maximale Lenkradeinschlagwinkel
     float speed = 45.0f // 45 Grad pro Sekunde
     angle = maxSteeringAngle * Input.GetAxis("Horizontal");
     StartCoroutine(RotateBy(angle, Vector3.forward, speed));
 }
}
IEnumerator RotateBy(float angle, Vector3 axis, float speed) {
 rotating = true;
 Quaternion start = transform.rotation;
 float curAngle = 0.0f;
 while (Mathf.Abs (curAngle - angle) > 0.0001f) {
	 curAngle = Mathf.MoveTowards (curAngle, angle, Time.deltaTime * speed);
	 transform.rotation = Quaternion.AngleAxis (curAngle, axis) * start;
	 yield return null;
 }
 transform.rotation = Quaternion.AngleAxis (angle, axis) * start;
 rotating = false;
}

[vreezer]

Mein Hovercraft-Fahrzeug basiert auf diesem Script. Wie im Video sollten die Halbkugeln wieder zurück in die Ursprungsstellung verfallen, wenn man kein Gas gibt oder lenkt. Dafür könnte man evtl. wirklich die Fahrzeugsteuerung nutzen, da es einen seperaten Gravitationswert gibt, der das Fahrzeug in der Luft wieder ausrichtet. Ich wäre aber auch mit einen seperaten Script zufrieden.

 

Ich habe dieses hier im Internet gefunden, aber bin mir nicht sicher, wie ich es aufräumen kann, damit es auf die vertikale und horizontale Achse reagiert ?

 

using UnityEngine;
using System.Collections;
[DisallowMultipleComponent]
[AddComponentMenu("RVP/C#/Hover/Hover Steer", 2)]
//Class for steering hover vehicles
public class HoverSteer : MonoBehaviour
{
Transform tr;
VehicleParent vp;
public float steerRate = 1;
float steerAmount;
[Tooltip("Curve for limiting steer range based on speed, x-axis = speed, y-axis = multiplier")]
public AnimationCurve steerCurve = AnimationCurve.Linear(0, 1, 30, 0.1f);
[Tooltip("Horizontal stretch of the steer curve")]
public float steerCurveStretch = 1;
public HoverWheel[] steeredWheels;
[Header("Visual")]

public bool rotate;
public float maxDegreesRotation;
public float rotationOffset;
float steerRot;
void Start()
{
 tr = transform;
 vp = (VehicleParent)F.GetTopmostParentComponent<VehicleParent>(tr);
}

void FixedUpdate()
{
 //Set steering of hover wheels
 float rbSpeed = vp.localVelocity.z / steerCurveStretch;
 float steerLimit = steerCurve.Evaluate(Mathf.Abs(rbSpeed));
 steerAmount = vp.steerInput * steerLimit;
 foreach (HoverWheel curWheel in steeredWheels)
 {
  curWheel.steerRate = steerAmount * steerRate;
 }
}
void Update()
{
 if (rotate)
 {
  steerRot = Mathf.Lerp(steerRot, steerAmount * maxDegreesRotation + rotationOffset, steerRate * 0.1f * Time.timeScale);
  tr.localEulerAngles = new Vector3(tr.localEulerAngles.x, tr.localEulerAngles.y, steerRot);
 }
}
}

[Zer0Cool]

Wenn ich den Code richtig interpretiere, dann setzt er den Lenkradeinschlagwinkel (steerAmount) der einzelnen HoverWheels in der Update-Methode (ob hier vertikal gedreht wird in der HoverWheel-Klasse entschieden) . In der FixedUpdate-Methode rotiert er dann das komplette Fahrzeug vertikal. Was du brauchst, wäre der Code für die HoverWheel-Klasse.

 

Ich würde mir gleich mal das ganze Projekt schnappen:

https://github.com/R...Vehicle-Physics

 

Siehe ab Minute 13.02:

[vreezer]

Das Projekt im github finde ich vom Fahrverhalten nicht so interessant und der Code ist für mich zu verworren und komplex, dass ich ihn allein nicht entwirren könnte. Da ich nicht mal dein Script zum laufen bekomme, befürchte ich, dass ich mich an den rotierend Schälchen übernommen habe :-) Falls jemand noch einen schlichtes einfaches Tutorial kennt, würde ich mich über Tipps freuen.

[Zer0Cool]

So, ich habe nun mal eine einfache Rotation der Räder gebastelt, die mit deinem Projekt zusammenarbeitet.

 

Dinge die du in deinem Projekt einstellen musst:

1) Jedes Rad in Z auf 90 Grad drehen (Rotation im Inspektor), damit steht das Rad dann quer zum Boden

2) Das Wheel Controller Skript anhängen

3) In der HoverCarControl Klasse in der FixedUpdate Methode folgendes ergänzen:

 

foreach (WheelControl wheel in Wheels)
{
   if (!wheel.rotating)
		{
			//Debug.Log("rotateby "+ wheel .gameObject.name + " by: " + turnValue);
			float maxSteeringAngle = 45.0f;
			float angle = maxSteeringAngle * turnValue;
			wheel.Rotate(angle);
		}
}

 

4) Neues Skript erstellen mit folgendem Inhalt:

using UnityEngine;
using System.Collections;
public class WheelControl : MonoBehaviour {
public bool rotating = false;
float speed = 45.0f;
float maxSteering = 45.0f;
public void Rotate(float angle)
{
	StartCoroutine(RotateBy(angle, Vector3.forward, speed));
}
IEnumerator RotateBy(float angle, Vector3 axis, float speed)
{
	rotating = true;
	Quaternion start = transform.localRotation;
	if ((start.eulerAngles.z + angle) < (90.0f - maxSteering) || (start.eulerAngles.z + angle) > (90.0f + maxSteering))
	{
		rotating = false;
		yield break;
	}

		float curAngle = 0.0f;
	while (Mathf.Abs(curAngle - angle) > 0.0001f)
	{
		curAngle = Mathf.MoveTowards(curAngle, angle, Time.deltaTime * speed);
		transform.localRotation = Quaternion.AngleAxis(curAngle, axis) * start;
		yield return null;
	}
	transform.localRotation = Quaternion.AngleAxis(angle, axis) * start;
	rotating = false;
}
}

 

Was noch fehlt ist eine Rotation der Räder in ihre Ausgangsstellung, wenn der Spieler keine Taste drückt.

Hierfür müsstest du eine weitere Coroutine schreiben, in welcher du "Quaternion.AngleAxis" durch "Quaternion.SetFromToRotation" ersetzt, damit du Z auf 90 Grad drehen kannst.

 

Des weiteren müsstet du noch eine Rotation für die Input.GetAxis("Vertical") hinzufügen, hierfür müsstest du dann um Y rotieren.

[Zer0Cool]

Hier noch eine leicht verbesserte Version mit Rotation um 2 Achsen:

Wheelcontrol:

using UnityEngine;
using System.Collections;

public class WheelControl : MonoBehaviour {

   public bool rotating = false;
   float speed = 45.0f;
   float maxSteering = 45.0f;

   public void Rotate(float angle, Vector3 axis)
   {
       StartCoroutine(RotateBy(angle, axis, speed));
   }

   IEnumerator RotateBy(float angle, Vector3 axis, float speed)
   {
       rotating = true;
       Quaternion start = transform.localRotation;


       if ((start.eulerAngles.z + angle) < (90.0f - maxSteering) || (start.eulerAngles.z + angle) > (90.0f + maxSteering))
       {
           rotating = false;
           yield break;
       }

      // Debug.Log("x. " + start.eulerAngles.x + " angle: " + angle + " sum ");

       if ((start.eulerAngles.x != 0) && (start.eulerAngles.x - angle) < (360f - maxSteering) && ((start.eulerAngles.x - angle) > (maxSteering)))
       {
           rotating = false;
           yield break;
       }

       float curAngle = 0.0f;
       while (Mathf.Abs(curAngle - angle) > 0.0001f)
       {
           curAngle = Mathf.MoveTowards(curAngle, angle, Time.deltaTime * speed);
           transform.localRotation = Quaternion.AngleAxis(curAngle, axis) * start;
           yield return null;
       }
       transform.localRotation = Quaternion.AngleAxis(angle, axis) * start;
       rotating = false;
   }
}

 

Hovercarcontrol:

using UnityEngine;
using System.Collections;

public class HoverCarControl : MonoBehaviour
{
  Rigidbody body;
  float deadZone = 0.1f;
public float groundedDrag = 3f;
public float maxVelocity = 50;
  public float hoverForce = 1000;
public float gravityForce = 1000f;
  public float hoverHeight = 1.5f;
  public GameObject[] hoverPoints;

  public float forwardAcceleration = 8000f;
  public float reverseAcceleration = 4000f;
  float thrust = 0f;
   float acceleration = 0f;


    public float turnStrength = 1000f;
  float turnValue = 0f;

public ParticleSystem[] dustTrails = new ParticleSystem[2];

   public WheelControl[] Wheels;

   int layerMask;

 void Start()
 {
   body = GetComponent<Rigidbody>();
body.centerOfMass = Vector3.down;

   layerMask = 1 << LayerMask.NameToLayer("Vehicle");
   layerMask = ~layerMask;
 }

   // Uncomment this to see a visual indication of the raycast hit points in the editor window
   //  void OnDrawGizmos()
   //  {
   //
   //    RaycastHit hit;
   //    for (int i = 0; i < hoverPoints.Length; i++)
   //    {
   //      var hoverPoint = hoverPoints [i];
   //      if (Physics.Raycast(hoverPoint.transform.position, 
   //                          -Vector3.up, out hit,
   //                          hoverHeight, 
   //                          layerMask))
   //      {
   //        Gizmos.color = Color.blue;
   //        Gizmos.DrawLine(hoverPoint.transform.position, hit.point);
   //        Gizmos.DrawSphere(hit.point, 0.5f);
   //      } else
   //      {
   //        Gizmos.color = Color.red;
   //        Gizmos.DrawLine(hoverPoint.transform.position, 
   //                       hoverPoint.transform.position - Vector3.up * hoverHeight);
   //      }
   //    }
   //  }


   void Update()
 {
// Get thrust input
thrust = 0.0f;
acceleration = Input.GetAxis("Vertical");
if (acceleration > deadZone)
      thrust = acceleration * forwardAcceleration;
     else if (acceleration < -deadZone)
      thrust = acceleration * reverseAcceleration;

     // Get turning input
turnValue = 0.0f;
    float turnAxis = Input.GetAxis("Horizontal");
    if (Mathf.Abs(turnAxis) > deadZone)
      turnValue = turnAxis;
 }

 void FixedUpdate()
 {

   //  Do hover/bounce force
RaycastHit hit;
bool  grounded = false;
    for (int i = 0; i < hoverPoints.Length; i++)
    {
      var hoverPoint = hoverPoints [i];
if (Physics.Raycast(hoverPoint.transform.position, -Vector3.up, out hit,hoverHeight, layerMask))
{
body.AddForceAtPosition(Vector3.up * hoverForce* (1.0f - (hit.distance / hoverHeight)), hoverPoint.transform.position);
grounded = true;
}
      else
      {
// Self levelling - returns the vehicle to horizontal when not grounded and simulates gravity
      if (transform.position.y > hoverPoint.transform.position.y)
{
body.AddForceAtPosition(hoverPoint.transform.up * gravityForce, hoverPoint.transform.position);
}
      else
{
body.AddForceAtPosition(hoverPoint.transform.up * -gravityForce, hoverPoint.transform.position);
}
      }
    }

var emissionRate = 0;
if(grounded)
{
body.drag = groundedDrag;
emissionRate = 10;
}
else
{
body.drag = 0.1f;
thrust /= 100f;
turnValue /= 100f;
}

for(int i = 0; i<dustTrails.Length; i++)
{
var emission = dustTrails[i].emission;
emission.rate = new ParticleSystem.MinMaxCurve(emissionRate);
}

   // Handle Forward and Reverse forces
   if (Mathf.Abs(thrust) > 0)
     body.AddForce(transform.forward * thrust);

   // Handle Turn forces
   if (turnValue > 0)
   {
     body.AddRelativeTorque(Vector3.up * turnValue * turnStrength);
   } else if (turnValue < 0)
   {
     body.AddRelativeTorque(Vector3.up * turnValue * turnStrength);
   }

// Limit max velocity
if(body.velocity.sqrMagnitude > (body.velocity.normalized * maxVelocity).sqrMagnitude)
{
body.velocity = body.velocity.normalized * maxVelocity;
}

   foreach (WheelControl wheel in Wheels)
   {
      if (!wheel.rotating)
           {
               //Debug.Log("rotateby "+ wheel .gameObject.name + " by: " + turnValue);

               float maxSteeringAngle = 45.0f;
               //Debug.Log(maxSteeringAngle * acceleration);
               float angleh = maxSteeringAngle * turnValue;
               float anglev = maxSteeringAngle * acceleration;
              wheel.Rotate(angleh, Vector3.forward);
              wheel.Rotate(anglev, Vector3.left);
           }
   }
 }
}

 

Weitere Verbeserungen wären wie gesagt, die Räder wieder auf ihre 0-Positionen zu bringen und die Rotation in V und H in eine Coroutine zu packen (ist sogar dringend angesagt, da aktuell eigentlich nur um eine Achse zu gleichen Zeit gedreht werden kann, du könntest auch 2 Coroutinen erstellen und müsstet dann den "rotating" bool für 2 Routinen auslegen bspw. "rotatingh" und "rotatetingv"). Die Räder scheinen auch noch bei ihren maximalen Ausschlagswinkeln ab und zu hängen zu bleiben, da muss man noch an der RotateBy()-Routine drehen, an der Stelle wo ich die Coroutine verlasse (yield break), wenn der maximale Ausschlagswinkel erreicht wird (mit Rotation auf 0-Stellung entfällt dieses Problem).

[vreezer]

Wow, danke für deine Mühen. Ich hab Dir dazu noch eine pm geschickt.

[Zer0Cool]

Falls noch jemand diesen Thread verfolgt, hier noch 2 verbesserte Versionen:

 

Änderung in "HoverControl.cs" in der Methode-FixedUpdate():

 foreach (WheelControl wheel in Wheels)
       {
           float wheelSpringPower = 100.0f;
           float steeringPower = 3.0f;

           float angleh = steeringPower * turnValue;
           if (!wheel.rotating1 && Mathf.Abs(angleh) > 0.5f)
           {
               //Debug.Log("rotateby " + wheel.gameObject.name + " by: " + angleh);
               wheel.Rotate1(angleh, Vector3.forward);
           }
           float anglev = steeringPower * acceleration;
           if (!wheel.rotating2 && Mathf.Abs(anglev) > 0.5f)
           {
               //Debug.Log("rotateby " + wheel.gameObject.name + " by: " + anglev);
               wheel.Rotate2(anglev, Vector3.left);
           }

           // Always rotate the wheel back to the zero position
           if (!wheel.rotating1) { 
              float step = wheelSpringPower * Time.deltaTime;
              wheel.transform.localRotation = Quaternion.RotateTowards(wheel.transform.localRotation, Quaternion.Euler(wheel.transform.localRotation.eulerAngles.x, 0, 0), step);
           }
           if (!wheel.rotating2)
           {
               float step = wheelSpringPower * Time.deltaTime;
               wheel.transform.localRotation = Quaternion.RotateTowards(wheel.transform.localRotation, Quaternion.Euler(0, 0, wheel.transform.localRotation.eulerAngles.z), step);
           }

       }

 

WheelControl.cs:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class WheelControl : MonoBehaviour
{
   /// <summary>
   /// Wheel controller to simulate hoover turbines based on this tutorial:
   /// http://www.doofah.com/tutorials/unity/bouncy-vehicle-tutorial/
   /// 
   /// Usage:
   /// Assign this script to all 4 wheels.
   /// Local axis alignment Must be as follows:
   /// - Forward axis (blue) facing to direction of movement (front of the car)
   /// - Right axis (red) facing to the right
   /// - Up axis (green) facing to the sky
   /// 
   /// You must change the HooverControl class in the method FixedUpdate():
   /// http://forum.unity-community.de/topic/12551-turbinen-anhand-der-lenkung-bewegen-lassen/
   /// 
   /// Assign all 4 wheels to the changed HooverControl script in scene.
   /// 
   /// by zer0f0rce (skype) Feb 2017.
   /// </summary>

   public bool rotating1 = false;
   public bool rotating2 = false;
   public float rotationSpeed = 45.0f;
   public float maxSteering = 45.0f;

   public void Rotate1(float angle, Vector3 axis)
   {
       StartCoroutine(RotateBy1(angle, axis, rotationSpeed));
   }

   public void Rotate2(float angle, Vector3 axis)
   {
       StartCoroutine(RotateBy2(angle, axis, rotationSpeed));
   }

   IEnumerator RotateBy1(float angle, Vector3 axis, float speed)
   {
       rotating1 = true;
       Quaternion start = transform.localRotation;

       // Bad hack to limit the steer angle, at the moment this only works for Vector3.forward
       if (((start.eulerAngles.z != 0) && (start.eulerAngles.z + angle) < (360f - maxSteering)) && (start.eulerAngles.z + angle) > (maxSteering))
       {
           rotating1 = false;
           yield break;
       }

       float curAngle = 0.0f;
       while (Mathf.Abs(curAngle - angle) > 0.0001f)
       {
           curAngle = Mathf.MoveTowards(curAngle, angle, Time.deltaTime * speed);
           transform.localRotation = Quaternion.AngleAxis(curAngle, axis) * start;
           yield return null;
       }
       transform.localRotation = Quaternion.AngleAxis(angle, axis) * start;
       rotating1 = false;
   }

   IEnumerator RotateBy2(float angle, Vector3 axis, float speed)
   {
       rotating2 = true;
       Quaternion start = transform.localRotation;

       // Bad hack to limit the steer angle, at the moment this only works for Vector3.left
       if ((start.eulerAngles.x != 0) && (start.eulerAngles.x - angle) < (360f - maxSteering) && ((start.eulerAngles.x - angle) > (maxSteering)))
       {
           rotating2 = false;
           yield break;
       }

       float curAngle = 0.0f;
       while (Mathf.Abs(curAngle - angle) > 0.0001f)
       {
           curAngle = Mathf.MoveTowards(curAngle, angle, Time.deltaTime * speed);
           transform.localRotation = Quaternion.AngleAxis(curAngle, axis) * start;
           yield return null;
       }
       transform.localRotation = Quaternion.AngleAxis(angle, axis) * start;
       rotating2 = false;
   }

}

[vreezer]

Am 28.2.2017 um 15:57 schrieb Zer0Cool:

Falls noch jemand diesen Thread verfolgt, hier noch 2 verbesserte Versionen

Vielen Dank nochmal, damit bewegen sich die "Reifen". Zwar nicht ganz so flüssig, aber das ist momentan eher nebensächlich.

Aktuell will das HoverControl Script gar nicht mehr laufen, ich habe das Projekt eine ganze weil gar nicht angerührt und jetzt nach dem Update scheint das Hoverscript nicht mehr richtig zu funktionieren. Die Fehlermeldung lautet:

Zitat

NullReferenceException: Object reference not set to an instance of an object
HoverControl.FixedUpdate () (at Assets/Scripts/HoverControl.cs:121)

Die entsprechende Codezeile:

Zitat

            var hoverPoint = hoverPoints;
            if (Physics.Raycast(hoverPoint.transform.position, -Vector3.up, out hit, hoverHeight, layerMask))
            {
                body.AddForceAtPosition(Vector3.up * hoverForce * (1.0f - (hit.distance / hoverHeight)), hoverPoint.transform.position);
                grounded = true;
            }

und hier:

Zitat

            var hoverPoint = hoverPoints;
            if (Physics.Raycast(hoverPoint.transform.position, -Vector3.up, out hit, hoverHeight, layerMask))

Ausserdem wird in der Console folgender Fehler ausgegeben:

Zitat

In order to call GetTransformInfoExpectUpToDate, RendererUpdateManager.UpdateAll must be called first.

Leider versteh ich so rein gar nicht, was Unity hier von mir will.

[Zer0Cool]

Was meinst du mit Update? Unityupdate?
Die erste FM bedeutet, daß eine Referenz nicht vorhanden ist. Meistens ist in einem Skript eine von außen übergebene Referenz nicht mehr vorhanden, die ja normalerweise über den Editor gesetzt wird (ein GameObjekt aus der Szene wird auf einen "Slot" eines Skriptes gezogen). Vermutlich ist "hoverPoints" nicht mehr gesetzt. Die andere FM sieht komisch aus... sieht eher nach einem internen Unity(editor)fehler aus. Referenzen in einer Szene gehen gerne mal verloren, wenn mit den Assets ein Problem auftritt, also wenn sie gelöscht oder umbenannt werden, oder korrupt werden.

[malzbie]

Die 2te Fehlermeldung ist eindeutig ein Unity Bug. Der ist zwar schon sein der 5.6 Beta bekannt und angeblich auch gefixt, aber inzwischen gibt es mehrere unterschiedliche Meldungen dazu. Gefixt ist scheinbar ein GUI Fehler. Noch offen ist ein Fehler mit dem Skinned Mesh Renderer. Andere Unser haben den Fehler ohne sagen zu können wann er genau auftritt. Ich habe den Fehler heute bei mir selbst bemerkt. Seltsamerweise nur eine kurze Zeit lang. Dann war er wieder weg...

Also erstmal ignorieren.

[vreezer]

Mit Update meinte ich, dass ich vor ~2 Wochen auf die neue Version Unity 5.6.0f3 gewechselt bin. Mittlerweile fliegt das Fahrzeug auch wieder. Es fehlte nur die richtige Layerbezeichnung, damit das Kollisionsmesh vom Hoverskript ausgeschlossen wird. Wie auch immer, die Fehler bestehen weiterhin, obwohl die Hoverpoints richtig gesetzt sind. Ich werde die Szene mal weiter aufräumen und das Script bereinigen. Falls ich den Fehler dann nicht alleine löse, melde ich mich noch einmal hier. Danke für die Tipps und Infos.

[vreezer]

Also, das Script funktioniert nun so, aber es haut mich irgendwie nicht vom Hocker. Richtige Rennspaßlaune kommt so nicht wirklich auf. Mittlerweile denke ich, dass ein einfacher unsichtbarer Collider der über den Boden "schubbert" fast besser geeignet ist und weniger Probleme beschwert. Ich bin noch über ein weiteres Script gestoßen, was ich gerne testen würde, aber da scheinen sich ein paar Fehler eingeschlichen zu haben. 2x unknow identifier. Weiß jemand warum es liegt ?

#pragma strict

var driveForce: float;
var hoverHeight: float;
var thrustForce: float;
var steerForce: float;
var steerPosZ: float;
var thrusters: Vector3[];
var maxVelocity: float;
var layerMask: LayerMask;
var enableControl: boolean = false;
static var driveMulti: float =1;
static var steerMulti: float =-1;
var steer: float;
var targetNormal : Vector3;
var hoverHit: RaycastHit;
function Start (){
 
    //code to set height from start height
    var dwn = transform.TransformDirection (Vector3.down);
    if (Physics.Raycast (transform.position, dwn, hoverHit)) {
        print (hoverHit.distance);
    }
    hoverHeight = hoverHit.distance;
 
    targetNormal = transform.up;
 
 
 
}
 
function FixedUpdate () {
    var hit: RaycastHit;
    var normalhit :RaycastHit;
    var addedhit :RaycastHit;
    var thrustMulti : float;
    var adjustRatio : float = 0.1; //amount of the difference to rotate by
    var addedforce : float;
     
    //Cast a ray to the object below to apply a fake gravity. You can comment these lines out if you want to use real gravity.
    if (Physics.Raycast(transform.position, -transform.up, normalhit)){
        targetNormal = hit.normal;
        print (targetNormal);
        Debug.DrawLine (transform.position, normalhit.point);
    }
     
     
    if (enableControl){    
        steer = Input.GetAxis("Horizontal");
        var brakeLeft:float;
        var brakeRight:float;
     
        //Fake Gravity
        GetComponent.<Rigidbody>().AddRelativeForce(-targetNormal.up * 100);
     
        var fwd: float = Input.GetAxis("Vertical");
        if (fwd >0){
            GetComponent.<Rigidbody>().AddForceAtPosition(transform.forward * (driveForce * fwd), transform.TransformPoint(Vector3.forward * 1));
        }
         
        if (fwd <0){
            GetComponent.<Rigidbody>().AddRelativeForce(transform.forward * (driveForce * fwd));
        }
     
     
        //Steering
        GetComponent.<Rigidbody>().AddRelativeForce(transform.right * steer*steerForce);
         
        GetComponent.<Rigidbody>().AddForceAtPosition(transform.right * (steerForce * steer * steerMulti), transform.TransformPoint(Vector3.forward * steerPosZ));
     
     
        if (Physics.Raycast(transform.position, -transform.up, addedhit)) 
        {
            addedforce    = (hoverHeight - addedhit.distance);
            if (addedforce <=0){
                addedforce=0;
            }
        }
        if (addedhit.distance <=2){
            GetComponent.<Rigidbody>().AddRelativeForce(targetNormal.up *(addedforce*20));}
         
        GetComponent.<Rigidbody>().AddRelativeForce(targetNormal.up * (thrustForce*(addedforce*addedforce)));
     
        //Create an array for the vertical thrusters and apply a force to each one.
        for (i = 0; i < thrusters.Length; i++) {
            var wdThruster: Vector3 = transform.TransformPoint(thrusters[i]);
         
            if (Physics.Raycast(wdThruster, -transform.up, hoverHit)) 
            {
                discrep    = (hoverHeight - hoverHit.distance);
                if (discrep <=0.1){discrep=0;}
             
                var upVel: float = GetComponent.<Rigidbody>().GetRelativePointVelocity(wdThruster).y;
                GetComponent.<Rigidbody>().AddForceAtPosition(transform.up * (thrustForce *discrep), wdThruster);
            }
        }
    }
}
 
//Draw some gizmos to indicate thruster position.
function OnDrawGizmos() {
    for (i = 0; i < thrusters.Length; i++) {
        Gizmos.DrawWireSphere(transform.TransformPoint(thrusters[i]), 0.1);
    }
     
    Gizmos.DrawWireSphere(transform.TransformPoint(Vector3.right * steer), 2);
}

Fehlermeldung:

Unknown identifier: 'i'.

Unknown identifier: 'discrep'.

[Sascha]

Aus

for (i = 0; i < [...]; i++)

mach

for (var i = 0; i < [...]; i++)

 

Ebenso fehlt ein "var" vor der ersten Verwendung von "discrep".

[vreezer]

Ah jetzt ja. Vielen Dank für die Hilfe bei Noobfragen  nun läuft's!