The bitwise AND (&) and bitwise OR (|) operators consider each "bit" in a number individually, in contrast to the logical AND (&&) and logical OR (||) operators which consider the entire the value.

Because the directions in BYOND are bit flags, they can be broken apart and combined with the bitwise operators. I don't have the time or the knowledge to give you a crash-course on binary number representation, but the gist is that instead of each digit increasing by a factor of ten like in decimal, they increase by a factor of 2 (so instead of 1, 10, 100, 1000, ect it's 1, 2, 4, 8, 16, 32, 64, ect). Regardless, here's what you need to know about how the bitwise operators work with directions:


So you can think of the bitwise OR (|) operator as combining two directions. The bitwise AND (&) operator is equivalent to taking the "union" of the two directions (returns what they have in common).

Applying this to Forum_Account's code, the first thing he does it use a trick to check if the direction is a diagonal. If a direction is diagonal, then ANDing that direction with one less than itself will return a true value. It works out this way because each of the values BYOND chose for the directions only have a single true bit, so subtracting 1 from a cardinal direction will unset that bit and carry over the remainder to all the less significant bits, causing the AND to return a false value. But for diagonal directions, two bits are set, so the more significant bit survives the subtraction and causes the AND to return a true value. You don't need to understand that, though, you can just regard it as binary magic ;)

Next, he breaks the direction into its x (EAST and WEST) and y (NORTH and SOUTH) components. He does this by creating a composite direction for each axis ("NORTHSOUTH" and "EASTWEST") and ANDing it with the direction. So d1 will be left with either NORTH or SOUTH depending on which component it contained, and d2 will be left with either EAST or WEST.

Now, since you don't want to allow diagonal movement, you have to pick one of the two component directions to step in instead. However, FA didn't want the mob to always favor vertical directions over horizontal ones, or vice-versa, so he adds a 50% chance to swap them so it can try the horizontal directions first half the time.

Next, it tries stepping in the first component direction. If that succeeds, it returns 1 and we're done.

If it failed, it tries the other component direction, and returns 1 if that succeeds.

If it failed to step along either axis, it reaches the bottom and returns 0.

--------------------------------------------

So, to summarize that wall of text, it breaks a diagonal movement into its two components, and then tries stepping in either one of those.