Adding Variables to packUpdate

#1 The key to adding things to the pack/unpack updates is to MAKE SURE YOU DO IT IN THE SAME ORDER IN PACK AND UNPACK!!! So, if you say stream->write(bar); right after stream->write(foo); in pack, you'd better put stream->read(&bar); right after stream->read(&foo); in unpack.

You can use flags/bitmasks in order to block writing in certain instances. You'll see a lot of things like this:

if (stream->writeFlag(mask & ShieldMask))
{
   //do some more writing
}

And then a matching:

if (stream->readFlag())
{
   //do some more reading
}

This might be a little hard to understand, but basically, "mask" is a 32 bit integer. You can think of this as a list of boolean values, since a 32 bit integer is just 32 bits, or bools, interpreted as an integer. Then, each type of mask (PositionMask, InitialUpdateMask, etc) is another 32 bit integer, defined in an enumeration. Usually, each mask type has exactly one bit in it's 32 set to 1. And, each mask type is usually unique, so each mask type affects a different bit position. Basically, every mask type maps to a different bit.

So, when you use the & operator, it's like the intersection operation in sets. It evalutes each bit individually and returns the bits that are both true in the left and right variables. Then, when any number is evaluated in an if statement, any non-zero number is considered to be "true". So, as long as the mask and mask type overlap in at least 1 bit, it returns true. If they don't share any bits, then it returns false.

To put it graphically...
Let's just consider 8 bits because I don't want to write out 32 :)

Say the mask is 00110010, and PositionMask is 00000010. If you line up the bits, you get something like this:

00110010 <-- mask
00000010 <-- PositionMask

They both share the second to last bit, so (mask & PositionMask) would return true. Now, if RotationMask is 00001000, the bits would line up like this:

00110010 <-- mask
00001000 <-- RotationMask

They don't share any bits, so it would return false.

So, if you wanted to write a 32 bit integer to the client only at certain times, every time you didn't want to send it, you'd write 1 bit (just the flag), and when you did want to, you'd write 33 bits (the flag + 32 bit integer). It makes the net code a LOT more efficient when things don't have to be transmitted all the time.

#2 Thanks Chris,

That gives me some understanding as to how the masks work. I am going to have to digest this a little while.


Thanks! :)
-Jeff