C# Random Int: How to force Even or odd number

You could try something like this:

 storeResult.Value = (inclusiveMax) ?
     min.Value + Random.Range(0, (max.Value - min.Value) / 2) * 2 + 1 : 
     min.Value + Random.Range(0, (max.Value - min.Value) / 2) * 2;

Note that you may have to adjust it depending on whether min and max are even or odd.

Doesnt look like Random supports a specific return but you can always just write your own. Here's a small example, with the assumption that forcing if it's even or odd is also random

 //if you get 1 then even, if you get 0 then odd.
 if(Random.Range (0,2) == 1)){
     yourInt = RandomEven(min,max);
 } else {
     yourInt = RandomOdd(min,max);
 }


 int RandomEven(int min, int max) {
         int randint = Random.Range (min, max);
         while(randint % 2 != 0) {
             randint = Random.Range (min, max);
         } 
         return randint;
     }

I think this is a better way to check if a number is odd or even in some cases: http://answers.unity3d.com/questions/224860/determining-if-a-variable-is-even-or-odd.html

Basically, use something called modulo.

 if (number % 2 == 0) // it is even
 if(number % 2 == 1) // it is odd

Read the link for a slightly better explanation.

There's no "native" way of handling the Even and Odd numbers, but there's a really simple way of changing either the odd or even into the other one.

To change any odd number into their higher or lower number:

1) Divide the int by 2 into a float. Let's call the result X.

2) If you want the higher even number, use Mathf.Ceil(X). If you want the lower even number, Mathf.Floor(X).

3) Multiply by 2 and you changed the Odd number into an Even number.

This can be done in a single line like this:

 public int ConvertOddToEvenUp(int a){
 int Result = Mathf.RoundToInt( Mathf.Ceil( (float)a/2) * 2 );
 return Result ;
 }
 
 public int ConvertOddToEvenDown(int a){
 int Result = Mathf.RoundToInt( Mathf.Floor( (float)a/2) * 2 );
 return Result ;
 }

Ceil round up the number always toward the highest closest integer and Floor does the same, but toward the lowest.

From this dual sets of options, you can also do the same, but with a slight change to change Even numbers into Odd numbers.

     public int ConvertEvenToOddUp(int a){
     int Result = Mathf.RoundToInt( (Mathf.Ceil( (float)a/2) * 2) +1 );
     return Result ;
     }
     
     public int ConvertEvenToOddDown(int a){
     int Result = Mathf.RoundToInt( (Mathf.Floor( (float)a/2) * 2) -1 );
     return Result ;
     }

As you noticed, in both case, I find the Even number first because it's easier to get, then I either add or subtract 1 to that number and it returns the previous or next integer after the closest even integer which, by nature, is an Odd Integer.

The reason why I used wrap the formula with Mathf.RoundToInt() instead of just putting (int) in front is because this ensure that any float imprecision issues are avoided. For example, if you divide 101 by half, you might get 50.49863948 due to float imprecision. Then you Floor or Ceil it which, from the Unity doc, supposedly return the closest integer... as a float which again can be imprecise so you might end up with 49.9987224 or 50.0023445. You then multiply it by 2 which double the previous imprecision. Mathf.RoundToInt() is an "Convert" type from float to Int and guaranties the closest integer to be outputted. So even if the imprecision is far off the mark, it will work and give an actual true Integer. (It's more like a 3rd safeguard thing.)

Check whether it's even and increment by 1 if so.

 oddNumber = random.Next();
 if(isEven(oddNumber)) {
    oddNumber++;
 }