You might have seen if statements with some confusing symbols: &&, || or !. These are called the logical operators, and are used to create more complicated logic within an if statement. They are:

&& – the Logical AND operator

|| – the Locical OR operator

– the Logical NOT operator

I use them frequently in Puzzledorf to check when certain things are occurring. For example, take a look at the image below. When the player moves, I want to check if there’s any object in the space he wants to move. If the space is empty, he can walk. If it’s not empty, what’s in the space? Can he push it, or is it immovable? etc.

## Quick Examples

But what do they do? I will give some quick examples.

```if (A && B)
{
Jump;
}```

In the above psuedocode, both and B have to be true for the player to jump. That is what && AND means, that both conditions either side must be true.

```if (A || B)
{
Jump;
}```

In the above case, the player will jump when either A or B are true, but they do not both have to be true. So || OR is true so long as one of the checks on either side of || OR are true.

```number1 = 5;
number2 = 10;

if (number1 != number2)
{
PrintScore;
}```

In the above case, the score will print if number1 is NOT equal to number2. ! NOT literally means NOT. It can be used in a variety of ways.

```lightOn = false;
pressButton = false;

if(lightOn)
{
LightUpRoom;
}

if(!lightOn)
{
MakeRoomDark;
}

if (pressButton)
{
!lightOn;
}
```

Above are other ways you can use ! NOT. First, it’s a different way to check if a value is true or false.

`if (lightOn)`

is the same as:

`if (lightOn == true)`

In the same way:

`if (!lightOn)`

is the same as:

`if (lightOn == false)`

So first we check to see whether the light is on or not, and if the light is on, we light up the room. If it’s not, the room becomes dark.

Then we check to see if the button is pressed.

```if (pressButton)
{
!lightOn;
}```

In the above code snippet:

`!lightOn;`

can be the same as writing:

`lightOn = false;`

or writing:

`lightOn = true;`

It simply means that, when applied in this way, it flips the value of a boolean, which is a true or false variable, to be the opposite value. So when we write:

`!lightOn;`

If lightOn was initially false, it would be switched to true. If it was initially true, it will be switched to false. It’s a perfect toggle for a light switch, because every time you press the light switch, it will be swapped to the opposite state. This means we don’t need to check if the light switch is on or off, saving us writing lots of extra code.

## Ordering of Operations

All code runs from left to right, top to bottom. This is important to know – it can be useful for solving errors, setting up correct logic, and optimisation.

Consider the following code:

```if (A && B)
{
Jump;
}```

We know that both A and B must be true. However, if A is false, the if statement will not even check if is true. This can be useful in optimisation, as the program will not keep checking your other conditions, saving CPU power.

A lot of CPU power will go to checking your if / else statements, so consider them wisely. If you can reduce how much code needs to run or be checked, this can go a long way in optimisation.

On the other hand:

```if (A || B)
{
Jump;
}```

If A is false, the statement will still check if B is true.

## Complex Examples

Now that you understand the basics, here are some more complex examples showing ways you can combine them together.

```if ( A && B && C )
{
PrintScore;
}```

In the above, you check if both A, B and C are all true. If A is false, it won’t check and C. If B is false, it won’t check C. So the more you combine together, it will always stop checking at the first condition that returns false.

Consider the following:

```if ( A && ( B || C ) )
{
PrintScore;
}```

Here we have used && and || together. Notice that we have nested if statements together in parentheses. This is similar to math class, where:

`1 + ( 6 / 2 )`

You always solve the brackets first. In the math equation, you have to divide 6 by 2, which is 3, before you add 1, which is 4. Furthermore, if you had:

`1 + ( 6 / ( 4 / 2) )`

You have to solve the innermost brackets first. In this case, you divide 4 by 2, which is 2, then divideby the result, which is 3, then you add 1 to that result. The answer is 4.

In our if statement, first it checks whether is true. If it is, it also then checks our || OR statement in the brackets. Either or C would have to be true for PrintScore to run.

```if ( A && ( B && C ) )
{
PrintScore;
}```

In this variation, A, B and C would still all have to be true, and so you don’t really need the ( ) parentheses.

```if ( A || ( B && C ) )
{
PrintScore;
}```

In the above example, it will be true if either A is true, OR either B and C are both true.

```if ( A || ( (B && C) || D ) )
{
PrintScore;
}```

If A is true, or and C are both true, or D is true, then our score will be printed.

So I hope you now have a good idea of what the logical operators are, and helpful ways that you might use them.