Introduction to Game Design, Prototyping, and Development (2015)

Part II: Digital Prototyping

Chapter 20. Boolean Operations and Conditionals

Most people have heard that computer data is, at its base level, composed entirely of 1s and 0s, bits that are either true or false. However, only programmers really understand how much of programming is about boiling a problem down to a true or false value and then responding to it.

In this chapter, you learn about Boolean operations like AND, OR, and NOT; you learn about comparison statements like >, <, ==, and !=; and you come to understand conditionals like if and switch. These all lie at the heart of programming.

Booleans

As you learned in the previous chapter, a bool is a variable that can hold a value of either true or false. Bools were named after George Boole, a mathematician who worked with true and false values and logical operations (now known as “Boolean operations”). Though computers did not exist at the time of his research, computer logic is fundamentally based upon it.

In C# programming, bools are used to store simple information about the state of the game (for example, bool gameOver = false; ) and to control the flow of the program through the if and switch statements covered later in this chapter.

Boolean Operations

Boolean operations allow programmers to modify or combine bool variables in meaningful ways.

!—The NOT Operator

The ! (either pronounced “not” or “bang”) operator reverses the value of a bool. False becomes true, or true becomes false:

print( !true ); // Outputs: false
print( !false ); // Outputs: true
print( !(!true) ); // Outputs: true (the double negative of true is true)

! is also sometimes referred to as the logical negation operator to differentiate it from ~ (the bitwise not operator), which is explained in the “Bitwise Boolean Operators and Layer Masks” section of Appendix B, “Useful Concepts.”

&&—The AND Operator

The && operator returns true only if both operands are true:

print( false && false ); // false
print( false && true ); // false
print( true && false ); // false
print( true && true ); // true

||—The OR Operator

The || operator returns true if either operand is true as well as if both are true:

print( false || false ); // false
print( false || true ); // true
print( true || false ); // true
print( true || true ); // true

Shorting Versus Non-Shorting Boolean Operators

The standard forms of AND and OR (&& and ||) are shorting operators, which means that if the shorting operator can determine its return value from the first argument, it will not bother to evaluate the second argument. By contrast, a non-shorting operator (& and |) will always evaluate both arguments completely. The following code listing includes several examples that illustrate the difference. In the code listing, a double slash followed by a number (e.g., // 1) to the right of a line indicates that there is an explanation of that line following the code listing.

1 // This function prints "--true" and returns a true value.
2 bool printAndReturnTrue() {
3 print( "--true" );
4 return( true );
5 }
6
7 // This function prints "--false" and returns a false value.
8 bool printAndReturnFalse() {
9 print( "--false" );
10 return( false );
11 }
12
13 void ShortingOperatorTest() {
14 // The first half of this test uses the shorting && and ||
15 bool tfAnd = ( printAndReturnTrue() && printAndReturnFalse() ); // 1
16 print( "tfAnd: "+tfAnd );
17
18 bool tfAnd2 = ( printAndReturnFalse() && printAndReturnTrue() ); // 2
19 print( "tfAnd2: "+tfAnd2 );
20
21 bool tfOr = ( printAndReturnTrue() || printAndReturnFalse() ); // 3
22 print( "tfOr: "+tfOr );
23
24 bool tfOr2 = ( printAndReturnFalse() || printAndReturnTrue() ); // 4
25 print( "tfOr2: "+tfOr2 );
26
27
28 // The second half of this test uses the non-shorting & and |
29 bool tfAnd3 = ( printAndReturnFalse() & printAndReturnTrue() ); // 5
30 print( "tfAnd3: "+tfAnd3 );
31
32 bool tfOr3 = (printAndReturnTrue() | printAndReturnFalse() ); // 6
33 print( "tfOr3: "+tfOr3 );
34
35 }

The numbers in the list below refer to lines in the preceding code that are marked with // 1 and // 2 to the right of the line.

1. This line will print --true and --false before setting tfAnd to false. Because the first argument that the shorting && operator evaluates is true, it must also evaluate the second argument to determine that the result is false.

2. This line only prints --false before setting tfAnd2 to false. Because the first argument that the shorting && operator evaluates is false, it returns false without evaluating the second argument at all. On this line, printAndReturnTrue() is not executed.

3. This line only prints --true before setting tfOr to true. Because the first argument that the shorting || operator evaluates is true, it returns true without evaluating the second.

4. This line prints --false and --true before setting tfOr2 to true. Because the first argument that the shorting || operator evaluates is false, it must evaluate the second argument to determine which value to return.

5. The non-shorting & operator will evaluate both arguments regardless of the value of the first argument. As a result, this line prints --false and --true before setting tfAnd3 to false.

6. The non-shorting | operator will evaluate both arguments regardless of the value of the first argument. This line prints --true and --false before setting tfOr3 to true.

It is useful to know about both shorting and non-shorting operators when writing your code. Shorting operators (&& and ||) are much more commonly used because they are more efficient, but & and | can be used when you want to ensure that you evaluate all of the arguments of a Boolean operator.

If you want, I recommend entering this code into Unity and running the debugger to step through the behavior and really understand what is happening. To learn about the debugger, read Chapter 24, “Debugging.”

Bitwise Boolean Operators

| and & are also sometimes referred to as bitwise OR and bitwise AND because they can also be used to perform bitwise operations on integers. These are useful for a few esoteric things having to do with collision detection in Unity; and you can learn more about them in the “Bitwise Boolean Operators and Layer Masks” section of Appendix B.

Combination of Boolean Operations

It is often useful to combine various Boolean operations in a single line:

bool tf = true || false && true;

However, care must be taken when doing so because order of operations extends to Boolean operations as well. In C#, the order of operations for Boolean operations is as follows:

! - NOT
& - Non-shorting AND / Bitwise AND
| - Non-shorting OR / Bitwise OR
&& - AND
|| - OR

This means that the previous line would be interpreted by the compiler as:

bool tf = true || ( false && true );

The && comparision is executed before the || comparison every time.