How can I rule out object rotation only twice in a row on same direction ?

Unity Engine
1

The object is rotating to both directions randomly. Right or left. The range is between 90 and 270.

But I want to add a rule that if the object rotated for example twice in a row on the left direction or the right direction the next random number should on the other side. So the object can rotate randomly only twice in a row in the same side. If rotated twice on the same side range the next it must be rotating randomly on the other side.

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

public class RotateRandom : MonoBehaviour
{
   bool noTarget = true;
   Quaternion qTo;
   Quaternion[] qTos;
   float rotateSpeed = 3.0f;
   float timer = 0.0f;

   private void Start()
   {
       qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(90.0f, 270.0f), 0.0f));
       qTos = new Quaternion[100];
       for(int i = 0; i < qTos.Length; i++)
       {
           qTos[i] = Quaternion.Euler(new Vector3(0.0f, Random.Range(90.0f, 270.0f), 0.0f));
       }
   }

   private void Update()
   {

       timer += Time.deltaTime;

       if (noTarget == true)
       {     
           if (timer > 2)
           { // timer resets at 2, allowing .5 s to do the rotating
               qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(90.0f, 270.0f), 0.0f));
               timer = 0.0f;
           }
           transform.rotation = Quaternion.Slerp(transform.rotation, qTo, Time.deltaTime * rotateSpeed);
       }
   }
}

I tried to add a qTos array and maybe to make that rule already in the Start or using this array to make the rule inside the Update.

Or maybe to make the rule directly already in the Euler line in the timer :

qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(90.0f, 270.0f), 0.0f));

Then I tried this but it’s not working like I wanted it keep just rotating randomly like before :

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

public class RotateRandom : MonoBehaviour
{
   bool noTarget = true;
   Quaternion qTo;
   float speed = 1.25f;
   float rotateSpeed = 3.0f;
   float timer = 0.0f;
   int counter = 0;

   private void Start()
   {
       qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(90.0f, 270.0f), 0.0f));
   }

   private void Update()
   {

       timer += Time.deltaTime;

       if (noTarget == true)
       {     
           if (timer > 2)
           {
               var rand = Random.Range(90.0f, 270.0f);
               counter += 1;
               if (rand >= 90 && rand <= 180)
               {
                   if(counter == 2)
                   {
                       rand = Random.Range(180.0f, 270.0f);
                       counter = 0;
                   }
               }

               if (rand >= 270 && rand >= 180)
               {
                   if (counter == 2)
                   {
                       rand = Random.Range(90.0f, 180.0f);
                   }
                   counter = 0;
               }

               qTo = Quaternion.Euler(new Vector3(0.0f, rand, 0.0f));
               timer = 0.0f;
           }
           transform.rotation = Quaternion.Slerp(transform.rotation, qTo, Time.deltaTime * rotateSpeed);
       }
   }
}
2

A pragmatic (though ugly) solution is to use a counter for how many times you have turned to the current direction, and use a direction variable.

This means that you first randomly determine the angle as an absolute (0…90, half of the total range)
Then you determine the direction as random bool (false = left, true = right)
If the direction is the same as last time, increment the counter. If the counter is greater than a threshold (in your case two), force the other direction (direction = not direction)
If the new direction is different from the last direction, reset the direction counter
According to the direction, calculate the final turn value and apply it to object.

-ch

1 Like
3

Can you show me how to do it in my code ?

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

public class RotateRandom : MonoBehaviour
{
    bool noTarget = true;
    Quaternion qTo;
    float rotateSpeed = 3.0f;
    float timer = 0.0f;
    int counter = 0;
    bool directions = false;

    private void Start()
    {
        qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(135.0f, 225.0f), 0.0f));
    }

    private void Update()
    {
        timer += Time.deltaTime;

        if (noTarget == true)
        {     
            if (timer > 2)
            { 
                var rand = Random.Range(135.0f, 225.0f);
               
                if(rand < 180)
                {
                    directions = false;
                }

                if(rand > 180)
                {
                    counter++;
                    directions = true;
                }

                qTo = Quaternion.Euler(new Vector3(0.0f, rand, 0.0f));
               
                timer = 0.0f;
            }
            transform.rotation = Quaternion.Slerp(transform.rotation, qTo, Time.deltaTime * rotateSpeed);
        }
    }
}
4

Ok, here’s how this could work. The code isn’t tested, and carefully read the final comment about the way you slerp sloppily :slight_smile:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class RotateRandom : MonoBehaviour
{
    bool noTarget = true;
    Quaternion qTo;
    float rotateSpeed = 3.0f;
    float timer = 0.0f;
    int sameDirectionCounter = 0;
    public int maxSameDirection = 2;
    bool currentDirection = false; // false = left, true = right, would be more elegant to use an enum
    private void Start()
    {
        qTo = Quaternion.Euler(new Vector3(0.0f, Random.Range(135.0f, 225.0f), 0.0f));
    }
    private void Update()
    {
        timer += Time.deltaTime;
        if (noTarget == true)
        {  
            if (timer > 2)
            {
            // to arrive at a range from 90 to 270 (180 degrees) we
            // take a random range of 0..90, and add or subtract that from
                // 180. This will then range from 90 to 270.
 
                float rand = Random.Range(0.0f, 90.0f);
        // now flip a coin for left / right
                bool newDirection = Random.Range(0.f, 1.0f) < 0.5f;            

        // now see if the new direction is the same as the old direction
        if (newDirection == currentDirection) {
            // if we are here, this is the same direction as last time
            // so we need to check how many times this happened already,
            // and if it happened too many times, force the other direction
            sameDirectionCounter += 1;
          
            if (sameDirectionCounter >= maxSameDirection) {
                // if we are here, we need to flip the direction
                newDirection = !newDirection; // flip direction
                samedirectionCounter = 0; // reset count
            }
          
        } else {
           samedirectionCounter = 0;
        }

        durrentDirection = newDirection;

        // now calculate the effective turn in degrees
        float turnAmount = 180.0f;
        if (newDirection) {
            // right
            turnAmount += rand; // add the random value
        } else {
            // left
            turnamount -= rand; // subtract the random value
        }
                qTo = Quaternion.Euler(new Vector3(0.0f, rand, 0.0f));
             
                timer = 0.0f;
            }
         // note that the way you use Slerp here will probably work, but only because you compount two errors :)
         // because the Slerp value should run from 0..1 (yours will alway be 1/FPS), and because the starting
             // slerp value should be constant (yours is constantly changing because you are changing transform.rotation)
            transform.rotation = Quaternion.Slerp(transform.rotation, qTo, Time.deltaTime * rotateSpeed);
        }
    }
}
1 Like
5

Tried it. And it’s not working good enough. In some cases I could count more then twice in a row at the same side.