# Logical Operators/Truth Tests

Logical operators perform Boolean (TRUE/FALSE) comparisons on an expression. Since NWNScript does not support a strict Boolean data type, the result of a logical operation will be an int value of either FALSE (0) or TRUE (1).

Logical Operators

Symbol Conditional
== Equality test ("is equal to").
!= Inequality test ("is not equal to").
< Less than equality test.
> Greater than equality test.
<= Less than or equal to equality test.
>= Greater than or equal to equality test.
&& Short circuit logical AND.
& Bitwise AND.
Short circuit logical OR.
Bitwise OR.
! Logical NOT.

The following expressions all equate to TRUE or 1:

```// data
int nValue1 = 3;
int nValue2 = 3;

// expressions
int bTest = nValue1 == nValue2;
int bTest = nValue1 != 0;
int bTest = (nValue1 == 3) &amp;&amp; (nValue2 != 0);
int bTest = (nValue1 == 3) || (nValue2 == 0);```

The following examples all equate to FALSE or 0:

```// data
int nValue1 = 3;
int nValue2 = 3;

// expressions
int bTest = nValue1 != nValue2;
int bTest = nValue1 == 0;
int bTest = (nValue1 == 3) &amp;&amp; (nValue2 == 0);
int bTest = (nValue1 != 3) || (nValue2 == 0);```

One good use for logical operators is to test multiple expressions in a single if statement. This will prevent unnecessary nested if statements which make code difficult to follow, and in some cases slower.

The Logical NOT operator is an exception because it's a unary operator (only operates on a single expression):

```int bRunning = TRUE;
int bRunTest = !bRunning;```

In this example bRunTest will equate to 0 or FALSE.

It should be noted that && and || are considered short-circuit operators: that is, in an && conditional the first condition to evaluate as FALSE from left-to-right stops evaluation of the remaining statements, and in an || conditional the first condition to evaluate as TRUE from left-to-right stops evaluation of the remaining statements. What does this mean? Suppose you had two functions and either function returns TRUE or FALSE:

```int bFunction1()
{
// check to see if a specific item is in the player's inventory
int bRet = FALSE;
bRet = GetItemPossessedBy(OBJECT_SELF, "some_item");
PrintInteger(bRet); // out to the log file
return bRet;
}

int bFunction2()
{
// moves the camera around
SetCameraFacing(270.0f, CAMERA_TRANSITION_TYPE_SLOW);
// returns TRUE for absolutely no reason
return TRUE;
}```

bFunction2, above, has what is known as a side effect. That means that although it is a function, it also causes something else to happen as well. When we use a short circuit AND operator (&&)...

```void main()
{
if (bFunction1() &amp;&amp; bFunction2())
{
// do something here
}
}```

If OBJECT_SELF does not have the item "some_item" then bFunction2() will never be called, thus the camera angle will never change. Contrast that to the following:

```void main()
{
if (bFunction1() &amp; bFunction2())
{
// do something
}
}```

In this second example, the camera angle will be changed because we are not using a short circuit operator; the entire statement will be evaluated.

Don't get "==" confused with the assignment operator "="! Assigning a statement to a value always returns TRUE and is a common source of bugs in code.

```int nNumber = 4;
if (nNumber = 5) // assignment; assigns value and returns TRUE!
{
PrintInt(nNumber);
}
// this will print "5" to the log file because nNumber is assigned
// the value of 5 during the "if" test
// if (nNumber == 5) is what should really appear above```

Finally because "==", "!=", "<", ">", "<=", and ">=" return TRUE or FALSE, you can use them for shortcuts when assigning values to boolean (TRUE/FALSE) integers. For example, the following code:

```int nNumber = 3;
int bCondition = FALSE;
if (nNumber == 3)
bCondition = TRUE;
else
bCondition = FALSE;```

can become a single line of code:

```int nNumber = 3;
int bCondition = nNumber == 3;```

author: Ryan Hunt, editors: Charles Feduke, Mistress, additional contributors: Bradley Beacham, ccaswell, Ken Cotterill