Printable View
Hey hey!
I was just wondering how you go about storing two values in one with individual retrieval functionality.
Case in point - I'm saving a value between 0-127 in an unsigned byte and would really like to make use
of the 128-255 range too. Since my bitmasking skills are... lacking, I was wondering if someone who
already knows how could school me?
//EE
You can store 2 Short values in 1 32bit in INT but if you wanted to store bytes you could store upto 4 bytes. Or 2 bytes and 1 Short in the INT (or even 8 values 0-15, or 32 bit flags). Seems as you want to use 0-255 the remaining 16bits could be left over reserved for other use:
Mask for the first value in the INT: 11111111 (255 / 0xFF)
Mask for the second value in the INT: 1111111100000000 (65280 / 0xFF00)
Transferring values from store value to the working value (for addition within you app/game):
Value 1 = Store value AND 255
Value 2 = Store value AND 65280 / (2 POW 8) or 256 (Unfortunately fusion doesn't support shifting without another extension but its simple to work around by applying 2 the power of the amount of bits you need to shift in this case 8).
Now you can work with Values 1 and 2 until you need to store them again.
To store them:
Store value = (Value 1 AND 255) OR ((Value 2 AND 255) * (2 POW 8))
For example:
Store value = 44693
Value 1 = 44693 AND 255 = 149
Value 2 = 44693 AND 65280 = 44544 / (2 POW 8) = 174
add 10 to both values and then store them
Store Value = (159 AND 255) OR (184 * (2 POW 8)) = 47263
If you wanted to store a 3rd and 4th value in the INT you just need to shift the value another 8 bits for each value (2 POW 16, 2 POW 24) and then apply the bit mask (16711680 / 0xFF0000, 4278190080 / 0xFF000000)
Thanks a lot for the that! :D
I'm trying to minimize filesize for external levels while at the same time keeping data processing at it's lowest for good speed.
Currently I'm storing each cell (50x28 per screen) in a 1d byte array, thats why I'm interested in using the 0-255 range.
0-127 corresponds to the tile used, so it makes sense including the collision data too since I have the space.
I'm gonna try and experiment some with the info!
Bear in mind 127 is 7 bits. 255 is 8. So if you're wanting to store the tile number and something else in the byte you'll only have a bit to work with. I also opt for the binary object for storing level data in my own format too instead of the array object.
After reading up a tiny bit more I quickly realized my error... XDQuote:
Originally Posted by danworth
I had the byte value range mixed up in dreams of nibbles and bit fields!
Anyway, my options are nice; either extend the tileset to 256 tiles and keep the
collision data in the next Z-layer in turn doubling the memory usage. Or I keep
to 127 tiles and use the 8:th bit as collision test.
I think you'll benefit from documenting your format and requirements. Its best to try to included everything you'll think you'll need otherwise if you wanted to add to the format you'll have to included some sort of upgrade/conversion code to make older levels compatible. I can post an example of a file format if needed. I've been thinking of making an example of a level format with level editor.
Yeah, I tend to make it up as I go along way too often. An example on file formats would be really cool since I'd love to make my own! :D
Something like this is how I'd go about things. I'd also add some sort of identification to the header like a 4 byte string so that the game could confirm that its a compatible file and the compression/encryption to the file:
(Offset: Datatype - Description)
Header (0x00000000):
0x00000000: Int - File version (eg 0x00010203 / v1.02.03)
0x00000004: Short - Grid Width
0x00000006: Short - Grid Height
0x00000008: 32 bytes (string) - Level Name
0x00000028: Byte - Sprite Set
0x00000029: Byte - Tile Set
0x0000002A: Byte - Music Track
0x0000002B: Short - Time limit
0x0000002D: Byte - Difficulty
0x0000002E: Short - Level Number
0x00000030: Short - Layer 1 Pointer (Multiply by 4)
0x00000032: Short - Layer 2 Pointer (Multiply by 4)
0x00000034: Short - Layer 3 Pointer (Multiply by 4)
Each Layer then will have its own structure and header:
Layer Header:
0x00000000: Int - Tile count
0x00000004: 12 Bytes - Reserved for future use
0x00000010: [First tile in layer]
0x00000016: [Secord tile in layer]
0x0000001C: [and so on...]
Tile Structure:
Short - X Position (grid position could be a byte if grid is 256x256 or smaller)
Short - Y Position (grid position could be a byte if grid is 256x256 or smaller)
byte - Sprite ID
byte - Sprite Flag (Special characteristics)
Byte - Sprite Attribute value 1
Byte - Sprite Attribute value 2
This is a great topic. Some useful info here danworth.
That was a really smart way of using the binary object. :D
I'm gonna go ahead and dive into this more. I'm still in the process of designing my level editor so to remake the code to work with the binary object instead of the byte array shouldn't be impossible. :D
Thanks alot!