[DesingMyCry]

El uso de binarios es igual en todos los lenguajes de programaciуn, por eso dirнa que es OFF. De todas formas te dн una recomendaciуn que rechazaste; "liarla otra vez"? No se a que te refieres.

Te mostrarй un ejemplo prбctico y fбcil de entender. Intentarй explicar lo mejor posible, aunque se me da muy mal.
-----------------

Primero debes entender de cuantos bits dispones... en el caso de SA-MP son 32 (x84); otros lenguajes tienen tambiйn para 64 (x64). Dichos bits son la cantidad de dнgitos que podrб tener como mбximo en cuanto a 0 y 1.

Osea, el lнmite que tenemos en SA-MP serнan 32 dнgitos. Si llegбsemos a utilizar menos, entonces se rellenarнa el resto con 0.

Me saltarй el uso de operadores ya que sabes utilizarlos.

Bien; como ya sabes que tenemos de lнmite 32 bits, podemos hacer "separaciones" de estos bits, asн, por ejemplo, podemos convertir variables que guarden datos:

pawn Код:

new muertes = 0;
new asesinatos = 0;
new experiencia = 0;

En una sola que guarde todo:

pawn Код:

new estadisticas = 0;

En PAWN, cada celda ocupa 4 bytes, cada byte son 8 bits; y 8*4 son 32 bits disponibles por celda (ojo, no confundir con variable, ya que los arreglos igual son variables que pueden contener mъltiples celdas). Cuando se declara una variable sin corchetes (como la del ejemplo anterior) significa que tendrб de lнmite solo 1 celda; osea 32 bits.

Ahora, como podemos hacer que esas 3 variables (muertes, asesinatos y experiencia) este todo en una simple variable (estadisticas); primero debemos saber el nъmero lнmite que puede soportar una cierta cantidad de bits:

Las variables "comunes", osea:

pawn Код:

new comun = 0;

Tiene 32 bits disponibles, y el nъmero mбximo que soporta es 2 multiplicado por si mismo 32 veces (resultado 4294967295) pero como PAWN (al menos en la versiуn que usa SA-MP a la fecha) no soporta "unsigned", ese nъmero se reduce a 2147483647.
Dicho de otra forma, para saber el mбximo que soporta una cantidad de bits debes elevar 2 a la cantidad de bits que quieras y al resultado le restas 1.

Una mini tabla de que nъmero soporta de acuerdo a ciertos bits:

1 bit: 1 mбximo
2 bits: 3
3 bits: 7
4 bits: 15
5 bits: 31
6 bits: 63
7 bits: 127
8 bits: 255

Por cierto; "unsigned" se le llama (o al menos asн le llamo yo por como se le dice en SQL) a cuando no soportarб nъmeros negativos. Osea irб de 0 a el lнmite. Y como dije, PAWN no soporta "unsigned" en sus variables por lo que por mucho que lo intentes, el lнmite serб 2^31-1.

Ahora, como hacer para distribuir los bits que tenemos disponibles en varios. Aquн utilizaremos operadores.

Primero, separemos los 32 bits que tenemos disponibles en los datos que necesitamos:

Код:

00000000000000000000000000000000

Cada color representa a un dato, y si lo notas, cada dato tendrб un lнmite de 8 bits, osea que el nъmero no podrб superar el dнgito 2^8-1 que es 255.

Entonces, la separaciуn de bits serб asн:

Код:

bits desde 0 hasta 7 -> muertes (color plomo)
bits desde 8 hasta 15 -> asesinatos (color naranja)
bits desde 16 hasta 23 -> experiencia (color morado)
bits desde 24 hasta 31 -> vaciу, sin informaciуn (color verde)

Entonces, primero se crea el contenedor:

pawn Код:

new estadisticas = 0; // Esto establece todos los bits a 0, osea se vaciarбn todas las estadнsticas

Ahora, cambiaremos los asesinatos, osea, debemos cambiar los bits desde el 8 hasta el 15, osea:

Код:

00000000000000000000000000000000

Tener en claro que el lнmite que soporta es 255, y llevado a bits serнa: 11111111, y a los bits que queremos cambiar:

Код:

00000000000000001111111100000000

Entonces, primero debemos usar el operador AND en el mбximo nъmero posible que tenemos y el nъmero que queremos establecer. Suponiendo que queremos establecer los asesinatos a 156, serнa:

Код:

00000000000000000000000010011100 // 156 en decimal
&
00000000000000000000000011111111 // 255 en decimal
=
00000000000000000000000010011100 // 156 en decimal

Esto lo haremos para evitar que se intente ingresar nъmeros mayores a los 8 bits que tenemos.

ADICIONAL: lo que hace este operador es comparar cada bit y si ambos estбn encendidos, devuelve encendido, de lo contrario serб apagado.

NOTA: encendido = 1; apagado = 0.

Con nuestro resultado:

Код:

00000000000000000000000010011100 // 156 en decimal

Nosotros con eso, modificamos los bits 0 a 7, pero necesitamos de 8 a 15. Utilizamos el operador de desplazamiento a la izquierda.

Код:

00000000000000000000000010011100 // 156 en decimal
<<
00000000000000000000000000001000 // 8 en decimal
=
00000000000000001001110000000000 // 39936 en decimal, aunque no lo necesitaremos jamбs

Osea, nuestro resultado (156 asesinatos) a binario serнa:

Код:

00000000000000001001110000000000

Y recordando a nuestro valor "inicial", que es:

Код:

00000000000000000000000000000000

Debemos juntar los datos. El operador OR es perfecto para esto (de hecho):

Код:

00000000000000000000000000000000
|
00000000000000001001110000000000
=
00000000000000001001110000000000

Este operador compara bit a bit, y devuelve encendido mientras uno de ellos este encendido. Devolverб apagado solo (y SOLO) ambos bits estбn apagados.

Asн es posible modificar ciertos bits que queramos sin necesidad de tocar el resto.

Para obtener el valor de ciertos bits, debemos hacer lo contrario a establecer, tenemos nuestro nъmero "resultado":

Код:

00000000000000001001110000000000

Movemos los bits que queremos, del 8 al 15:

Код:

00000000000000001001110000000000
>>
00000000000000000000000000001000 // 8 en decimal
=
00000000000000000000000010011100

Luego obtener los bits que estйn encendidos en el resultado y el mбximo de los bits que estamos manipulando (estamos usando 8 bits con 255 de lнmite), por lo que:

Код:

00000000000000000000000010011100
&
00000000000000000000000011111111
=
00000000000000000000000010011100

Y eso, bбsicamente.