Question

Heads up: Even though this problem arose while I was working with Unity, it has nothing specific to Unity, and is more about programming logic, so please don’t shy away.

I’m using Unity and rotating an object by script. The thing is, if I rotate it to, say, 180 degrees, the object does not rotate exactly to that much and tends to stop at between 179 and 181 degrees. So, to check if rotation is complete I check if the rotation angle is targetAngle +/- 1, which works.

I check using

if (transform.eulerAngles.z > lowerLimit && transform.eulerAngles.z < upperLimit)

where

lowerLimit = targetAngle-1;
upperLimit = targetAngle + 1;

Now, the problem arises when the targetAngle is 0. In this case, my script checks if rotation angle is between -1 and 1. But, -1 should really be 359, so it needs to check if the angle lies between 359 and 1.

How can I implement this?
In other words, I guess I’m asking how to implement a wrap-around number system.

EDIT

Found one work-around. If targetAngle is 0, I treat is specially. It works, but isn’t the most elegant.

         if (targetAngle == 0.0)
        {
            if ((transform.eulerAngles.z > 359.0 && transform.eulerAngles.z <= 360.0) || (transform.eulerAngles.z >= 0.0 && transform.eulerAngles.z <= 1)) 
            {
                rotate = false;            
            }
        }
        else
        {
            if (transform.eulerAngles.z > targetAngle - 1 && transform.eulerAngles.z < targetAngle + 1)
            {
                rotate = false;            
            }
        }

Answer 1

You could do …

lowerLimit = (targetAngle % 360) + 359; //360 - 1;
upperLimit = (targetAngle % 360) + 361; //360 + 1;

if (((transform.eulerAngles.z + 360) % 360) > lowerLimit
 && ((transform.eulerAngles.z + 360) % 360) < upperLimit)

This moves the check away from the zero and you wouldn’t have to deal with positive/negative checking.

EDIT

The % operator on the targetAngle restricts the rotating to +/-359 degrees, so a target angle of 721 would come down to 1, and a target angle of -359 would come down to 1. This should do nicely for all cases I think.

EDIT 2

To fix the last case you mentioned in your comment, I guess you’d need to apply the same wrapping logic to your transform.eulerAngles.z values. Probably best to put this wrapping in an extra function now, so try this:

int wrapNumber(int input) // replace int with whatever your type is
{
  // this will always return an angle between 0 and 360:
  // the inner % 360 restricts everything to +/- 360
  // +360 moves negative values to the positive range, and positive ones to > 360
  // the final % 360 caps everything to 0...360
  return ((input % 360) + 360) % 360;
}

lowerLimit = wrapNumber(targetAngle) + 359; //360 - 1;
upperLimit = wrapNumber(targetAngle) + 361; //360 + 1;

if (wrapNumber(transform.eulerAngles.z) + 360 > lowerLimit
 && wrapNumber(transform.eulerAngles.z) + 360 < upperLimit)

Depending on how often you need to use this, checking for some cases might remove unneeded overhead. For example, the final % 360 within wrapNumber is only needed if the input was positive. If you’re calling this ten times per minute it probably won’t matter. If you’re calling it a hundred times per second, you may want to check how it performs in this situation.