08.08.2011, 14:47
(
Последний раз редактировалось RyDeR`; 24.02.2012 в 22:09.
)
Introduction
Last days I did some research regarding bit manipulation and extractions and ended up with this small, very useful include. This include will save you lots of memory if you use it efficient.
Integer Limits
A higher/lower value will just repeat until the limit and start over again till done.
Usage
Declaration
The syntax is quite simple. You just use BitX and replace X with the prefered bit type as tag, followed by the name and then the size between < and >.
So for example let's declare a 4-bit array b4_Nibble with a size of 32:
Set and get a bit
You can use the BitX_Set/Get function for this. For example:
This will set b4_Nibble at index 0 to a value of 4.
Retrieving the value is as simple as:
This will return the value in b4_Nibble at index 0 which will be 4 in this case.
Examples
Here are some simple examples of what I mean by "saving lots of memory". I often see people doing things like this:
The .amx size after compile is 726 bytes. Nothing much, but as you can see we're using 32-bit variables for only 0 and 1, so that's a waste of a lot memory. The most relevant bit type in this case would be 1-bit:
The .amx size of this after compile is only 473 bytes. Probably not a big deal right now, but imagine with larger arrays or just a couple of more arrays like this.
This is just analog all the rest of the bit-types, just make sure you pick the right bit-type for your value.
Download
rBits.inc
FAQ
Last days I did some research regarding bit manipulation and extractions and ended up with this small, very useful include. This include will save you lots of memory if you use it efficient.
Integer Limits
1-Bit | 2-Bit | 4-Bit | 8-Bit | 16-Bit | |
| Limit | 1 ─ 0x1 | 3 ─ 0x3 | 15 ─ 0xF | 255 ─ 0xFF | 65535 ─ 0xFFFF |
Usage
Declaration
The syntax is quite simple. You just use BitX and replace X with the prefered bit type as tag, followed by the name and then the size between < and >.
So for example let's declare a 4-bit array b4_Nibble with a size of 32:
pawn Код:
new
Bit4: b4_Nibble <32>
;
You can use the BitX_Set/Get function for this. For example:
pawn Код:
Bit4_Set(b4_Nibble, 0, 4);
Retrieving the value is as simple as:
pawn Код:
Bit4_Get(b4_Nibble, 0);
Examples
Here are some simple examples of what I mean by "saving lots of memory". I often see people doing things like this:
pawn Код:
#include <a_samp>
new
bool: g_PlayerSpawned[MAX_PLAYERS]
;
public OnPlayerSpawn(playerid) {
g_PlayerSpawned[playerid] = true;
}
public OnPlayerDeath(playerid) {
g_PlayerSpawned[playerid] = false;
}
public OnPlayerDisconnect(playerid, reason) {
g_PlayerSpawned[playerid] = false;
}
stock IsPlayerSpawned(playerid) {
return g_PlayerSpawned[playerid];
}
pawn Код:
#include <a_samp>
#include <rBits>
new
Bit1: g_PlayerSpawned <MAX_PLAYERS>
;
public OnPlayerSpawn(playerid) {
Bit1_Set(g_PlayerSpawned, playerid, true);
}
public OnPlayerDeath(playerid) {
Bit1_Set(g_PlayerSpawned, playerid, false);
}
public OnPlayerDisconnect(playerid, reason) {
Bit1_Set(g_PlayerSpawned, playerid, false);
}
stock IsPlayerSpawned(playerid) {
return Bit1_Get(g_PlayerSpawned, playerid);
}
This is just analog all the rest of the bit-types, just make sure you pick the right bit-type for your value.
Download
rBits.inc
FAQ
- How can I use this with enum?
- You can just sort per bit type. For example for 1-bit arrays:
pawn Код:enum e_Bit1_Data {
e_bSpawned,
e_bIsDeath,
e_bInDM,
// ...
};
new
g_Bit1_Data[e_Bit1_Data] <MAX_PLAYERS>
;
Bit1_Set(g_Bit1_Data[e_bSpawned], playerid, true);
Bit1_Get(g_Bit1_Data[e_bSpawned], playerid);
- You can just sort per bit type. For example for 1-bit arrays:
- How to increase/decrease the value?
- Since x++ is equal to x = x + 1 we can simply use that technique:
pawn Код:Bit4_Set(b4_Nibble, 0, Bit4_Get(b4_Nibble, 0) + 1);
- Since x++ is equal to x = x + 1 we can simply use that technique:
- Other questions?
- Ask in the comments.
