Wie ändert man den Variablenwert nach einem bestimmten Muster in der Einheit 3d?

Question

Es tut mir leid, die Frage könnte ein bisschen komisch sein, aber ich weiß nicht, wie ich das sonst fragen soll.

Ich habe ein endloses Läufer-Spiel entwickelt, und diese großartige asset package aus dem Laden heruntergeladen. Es wird die Straße oder Fliesen nach links oder rechts entsprechend der gewünschten Menge biegen.

Ich habe eine Reihe von Zahlen in meinem Kopf -10, 0 und 10,

10 die Kacheln nach links biegen. (nach der Anlage, (+) ist links.)

0 wird nichts tun, es wird gerade Fliesen.

-10 biegen sich die Fliesen nach rechts

Gerade jetzt habe ich entwickelt es nach und nach die Kurve nach links zu erhöhen und halten am 10.

Dies ist der Code.

float curve = 0; 
float curTarget = 10; 

void Update() 
    { 
if (curve <= curTarget) 
     { 
      curve = curve + (Time.deltaTime * .5f); 
     } 
     else if (curve == curTarget) 
     { 
      HB.ApplyCurvature(curve); //method called from the package. 
     } 
     HB.ApplyCurvature(curve); //method called from the package 
} 

Also meine Frage ist, wie diese Werte zwischen einander zu erhöhen und zu verringern (-10, 0, 10). Grundsätzlich möchte ich, dass das Muster ist;

Abnahme allmählich von 0 auf -10 waitForSeconds (5)

schrittweise Erhöhung von -10 bis 0 waitForSeconds (5)

schrittweise Erhöhung von 0 bis 10 waitForSeconds (5)

Schließlich dann Verringere von 10 auf 0 WaitForSeconds (5) und dann wieder von oben.

Wie erreiche ich ein solches Szenario, habe ich versucht, einen Schalter zu verwenden, aber es hat nicht geklappt. Dies ist auch das gleiche wie die U-Bahn-Surfer. Es geht wunderbar mit diesem Muster durch. Ich bin etwas neu in der Einheit. Hilfe würde sehr geschätzt werden.

Answer 1

Als neues Unity-Programm ist es wichtig, dass Sie verstehen, wie Sie coroutine und die lerp-Funktion verwenden. Dies ist ein Beispiel, wo es benötigt wird. Wie man das Objekt im Laufe der Zeit bewegt ... Dies wurde schon oft gefragt, daher sollte das Googlen ein großartiges Ergebnis liefern und den Einstieg erleichtern. Sie müssen diese kennen, um dies zu tun.

bool keepRunning = false; 
IEnumerator pattern() 
{ 
    while (keepRunning) 
    { 
     float mainPatternValue = 0; 

     //decrease gradually from 0 to -10 waitForSeconds(5) 
     const float patternDuration = 5f; 
     float counter = 0; 
     while (counter < patternDuration) 
     { 
      if (!keepRunning) 
       yield break; 

      counter += Time.deltaTime; 
      mainPatternValue = Mathf.Lerp(0, -10, counter/patternDuration); 
      Debug.Log("<color=red>Decr from 0 to -10: " + mainPatternValue + "</color>"); 
      yield return null; 
     } 

     Debug.Log("<color=yellow>DONE</color>"); 

     //Increase gradually from -10 to 0 waitForSeconds(5) 
     counter = 0; 
     mainPatternValue = -10; 
     while (counter < patternDuration) 
     { 
      if (!keepRunning) 
       yield break; 

      counter += Time.deltaTime; 
      mainPatternValue = Mathf.Lerp(-10, 0, counter/patternDuration); 
      Debug.Log("<color=green>Incr from -10 to 0: " + mainPatternValue + "</color>"); 
      yield return null; 
     } 

     Debug.Log("<color=yellow>DONE</color>"); 

     //Increase gradually from 0 to 10 waitForSeconds(5) 
     counter = 0; 
     mainPatternValue = 0; 
     while (counter < patternDuration) 
     { 
      if (!keepRunning) 
       yield break; 

      counter += Time.deltaTime; 
      mainPatternValue = Mathf.Lerp(0, 10, counter/patternDuration); 
      Debug.Log("<color=red>Incr from 0 to 10: " + mainPatternValue + "</color>"); 
      yield return null; 
     } 

     Debug.Log("<color=yellow>DONE</color>"); 

     //Finally then decrease from 10 to 0 waitForSeconds(5) and then from top again 
     counter = 0; 
     mainPatternValue = 10; 
     while (counter < patternDuration) 
     { 
      if (!keepRunning) 
       yield break; 

      counter += Time.deltaTime; 
      mainPatternValue = Mathf.Lerp(10, 0, counter/patternDuration); 
      Debug.Log("<color=green>Decr from 10 to 0: " + mainPatternValue + "</color>"); 
      yield return null; 
     } 

     Debug.Log("<color=yellow>Finally DONE</color>"); 
     Debug.Log("<color=yellow>Starting Over Again!</color>"); 
     yield return null; 
    } 
} 

void start() 
{ 
    if (keepRunning) 
     return; 

    keepRunning = true; 
    StartCoroutine(pattern()); 
} 

void stop() 
{ 
    keepRunning = false; 
} 

Um den coroutine Anruf start() zu starten. Um es zu stoppen, rufen Sie stop().

Answer 2

ich auf mobiles bin so kann ich es nicht testen, aber hoffentlich hilft ...

Mit dieser Funktion einen Wert zurückgeben/verringern, indem die aktuelle Krümmung zu erhöhen, basierend auf der Differenz zwischen der Zielkurve und die aktuelle Kurve.

Derzeit wird nur Time.deltaTime als Inkrement verwendet. Ich habe eine auskommentierte Kurvengeschwindigkeit hinzugefügt, die Linie auskommentiert, entferne einfach das/* und */und gebe curveSpeed ​​einen Wert, um es zu benutzen.

float Bend(float current, float target) { 
    //Don't bend if current curve is equal to target curve 
    if (current == target) 
     return 0; 
    //Find the sign of the difference between current and target 
    float sgn = (target - current)/Math.Abs(target - current); 
    //Apply the sign to the incremental value 
    float val = /*curveSpeed * */Time.deltaTime * sgn; 
    //If the absolute value of the increment/decrement + the current value is greater than 
    //the absolute value of the target, only return the difference (prevents over curving) 
    if (Mathf.Abs(current + val) > Mathf.Abs(target)) { 
     return target-current; 
    } 
    //Return the incremental/decremental value 
    return val; 
} 

So ein Beispiel dafür innerhalb Update in einem Muster der Umsetzung:

enum Pattern { a, b, c, d } 
Pattern pattern; 

float curve = 0; 
float curveSpeed = 2; 

void Update() { 
    switch (pattern) { 
     case Pattern.a: 
      HB.ApplyCurvature(Bend(curve, -10)); 
      if (Bend(curve, -10) == 0) pattern = Pattern.b; 
      break; 

     case Pattern.b: 
      HB.ApplyCurvature(Bend(curve, 0)); 
      if (Bend(curve, 0) == 0) pattern = Pattern.c; 
      break; 

     case Pattern.c: 
      HB.ApplyCurvature(Bend(curve, 10)); 
      if (Bend(curve, 10) == 0) pattern = Pattern.d; 
      break; 

     case Pattern.d: 
      HB.ApplyCurvature(Bend(curve, 0)); 
      if (Bend(curve, 0) == 0) pattern = Pattern.a; 
      break; 

    } 
} 

Das einzige, was fehlt, ist die Verzögerung Sie erwähnt.