Bitshift Encoding

[DCurrent]

Hey all, here's an old school trick using bit shifts to encode two or more numeric values (in this case three) into a single integer and decode them later. It's perfect when you need to keep or send two or more relatively small values and multiple variables or arrays are not a tenable option. You'd be surprised how often this happens.

As an example, one 32bit integer can accommodate three values of 0-255 each. Sound familiar? That's how color codes work, and in fact the native RGB() function will work as a decoding shortcut.

Here's some sample code that shows it in action. We take three numeric values with a range of 0-255 (8bit), encode them into to a single integer (32bit), decode them back to the original three values, and output to log. I'm using this for a cancel system, but there are hundreds of possible uses depending on your needs.

/* Masks and bit shift values. */
    #define MASK 0xFF
    #define SHIFT_B 8
    #define SHIFT_C 16

    /* Example values. */
    int value_a = 14;
    int value_b = 255;
    int value_c = 12;   
   
    int value_encoded = 0;

    /*
    * Encode our three values into one integer.
    *
    * Either of these will work. The first is faster
    * while the second allows you to set the
    * encoded values piecemeal.
    */

    // value_encoded = (value_a & MASK) | ((value_b & MASK) << SHIFT_B) | ((value_c & MASK) << SHIFT_C);

    value_encoded += (value_a & MASK);
    value_encoded += (value_b & MASK) << SHIFT_B;
    value_encoded += (value_c & MASK) << SHIFT_C;
   
    /* Decompress and output to log. */
    log("\n value_encoded: " + value_encoded);
   
    log("\n value_a: " + (value_encoded & MASK_A));
    log("\n value_b: " + ((value_encoded >> SHIFT_B) & MASK_A));
    log("\n value_c: " + ((value_encoded >> SHIFT_C) & MASK_A));

Output:

value_encoded: 851726
 value_a: 14
 value_b: 255
 value_c: 12

Enjoy!
DC

 

[O Ilusionista]

Nice, thanks for the info. I somes times use bitshift in Mugen but I haven't tried to play with it in OpenBOR.
I will give it a try once I can.

 

[DCurrent]

Nice, thanks for the info. I somes times use bitshift in Mugen but I haven't tried to play with it in OpenBOR.
I will give it a try once I can.

I used to hate bitmasks because they were impossible for me to keep up with in my head (still are), but it's amazing what you can do with them. 32 flags in one integer? Yes please! They're also blazing fast. OpenBOR uses them for all kinds of work internally.

It now only requires one mask and has two compression methods included.

DC

 

[DCurrent]

Updated with some better formatting and use of the C coding tag (colorizes output).

DC

 

[msmalik681]

I really need to learn bitwise it was so confusing i just skipped it maybe some practical learning is needed.

 

[DCurrent]

I really need to learn bitwise it was so confusing i just skipped it maybe some practical learning is needed.

I wish I could tell you some learning trick, but there's really nothing to it other than practice. Every value you see on any device is made from a combination of 0s or 1s. When you do bitwork, you're just acting on those 0 or 1 switches instead of the total value they are encoded to represent.

In OpenBOR, the numbers in script are all 32bit. That means you have 32 true or false values to play with. All values are encoded identically, regardless of bitsize. So, that means a 32bit integer has enough bits for any combination of values or numbers that require 32 bits or less to encode. In practice, it gets pretty messy if you combine different bit sizes though, so most of the time you write your code to make a uniform split. In my example above, I'm encoding three numbers with a range of 0-255 (8bit).

All the stuff that goes with it is just math. It's nothing more than a glorified abacus.

@Roel is a master of optimization and wrote a lot of bitwise code. If he ever happens by he could explain it much better than I can.

DC

 

[msmalik681]

@DCurrent

If a int is 4 bytes this method saves 8 bytes maybe it will add up if using hundreds of int values. There is the extra overhead with encoding and decoding the data. I know you said bitwise operations are fast but is decoding faster then just referencing a int ?

 

[DCurrent]

@DCurrent

If a int is 4 bytes this method saves 8 bytes maybe it will add up if using hundreds of int values. There is the extra overhead with encoding and decoding the data. I know you said bitwise operations are fast but is decoding faster then just referencing a int ?

No offense, but I didn't write this tutorial to have a debate about the benefits. I could cite at least a dozen examples in script or the engine, but then it's another TLDR I wasted my time on. Bit techniques are an inarguable net reduction in overhead and memory usage, because they're the fundamental basis of computing. The only thing a CPU actually does do is bitshifting. Everything else is just a coat of paint.

Bitwise encoding can also reduce coding complexity (like for keyscripts). The drawback is difficulty for humans and increased complexity if overused. That's something only experience can teach. You'll just have to decide for yourself.

DC

 

[msmalik681]

Thanks for the clear up.