[GranaT3]

Hola he estado viendo temas sobre Binarios y aprendн ciertas cosas.

Les enumerarй las cosas que sй o que he comprendido:

Quote:

Originally Posted by Cosas que sй - Como funciona el sistema Binario - Bits - Estructura de pesos (valor) de los nъmeros binarios - Pasar nъmeros binarios a Decimales - Operaciones con Bits (AND,OR,XOR,NOT)

Pero me quedan cosas que aprender, algunas las he visto pero como estбn en inglйs no sй.

Quote:

Originally Posted by Cosas que aprender - Shifts aritmйticos - Shifts lуgicos - Bit-flags - Pasar nъmeros binarios a Decimales. - Adaptarlo en PAWN - Formas de uso en PAWN

Obviamente estoy consiente de que se usan para ahorrar espacios y no desperdiciar memorias, pero ese no es el punto, sino saber como aplicarlo en PAWN. Porque siempre veo ejemplos las cuales yo denomino "ficticios" y que en cierta parte ayudan pero no del todo.

Ya si desean brindarme alguna informaciуn o ejemplos de los puntos que les mencione, por mбs mнnimo que sean, se les agradece.

[DesingMyCry]

Puedes colocar esos ejemplos que denominas "ficticios"?
Al principio dices que sabes utilizar los operadores, por lo que encuentro que es una contradicciуn.

Por cierto, debe tener el tag OFF.

[GranaT3]

Quote:

Originally Posted by DesingMyCry Puedes colocar esos ejemplos que denominas "ficticios"? Al principio dices que sabes utilizar los operadores, por lo que encuentro que es una contradicciуn. Por cierto, debe tener el tag OFF.

Na' error de ediciуn, me confundн.
Es decir, yo les llamo "ficticios" porque son ejemplos pero no completos o que simplemente son grбficos. Algo como esto:

XOR (^) compara bit x bit, en caso de que solo uno de los 2 bits es 1, pues darб 1, caso contrario 0. Ejemplo

00101
00100
--------
00001

Vale, їY para que me servirнa hacer eso? aparte de lo anteriormente dicho.

Y no es OFF, porque el punto (como lo repetн varias veces) es como aplicarlo en PAWN.

[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.

[GranaT3]

Cuando vi las variables, pensй que ibas a seguir con la misma sintaxнs, pero luego empezaron solo los numeros binarios y me perdн. Te resumirй lo que logre comprender.

- pawn solo soporta 32 bits (x84) o digitos de 0-1
- en PAWN cada celda ocupa 4 bytes, cada byte son 8 bits y 8*4 son 32 bits disponibles por celdas. Cuando se declara una variable sin corchetes significa que tendra limite de solo 1 celda, es decir, 32 bits
- para saber el numero limite de cierta cantidad de bits, se debe elevar a 2 y restarle -1 al resultado
- comprendн lo de las separaciones.

Ahora, digamos que grбficamente entendн, pero llevado a pawn o cуdigo, no sй.

Код:

estadisticas = 0b00000000000000000000000010011100;
    printf("%i", estadisticas);

No sй si me entiendes lo que quiero decirte. Gracias.

[DesingMyCry]

Debes entender que en PAWN, el colocar:

pawn Код:

new variable = 255;

Lo tomarб de forma automбtica a nъmero binario, por lo que no hay que transformar nada. Para ver a que nъmero binario representa, debes usar la funciуn "printf" con "%b".

Llevado a cуdigo PAWN, serнa:

pawn Код:

new estadisticas = 0; // Reiniciamos todos los valores

estadisticas |= ((22 & 255) << 0); // Establecemos muertes a 22
estadisticas |= ((66 & 255) << 8); // Establecemos asesinatos a 66
estadisticas |= ((88 & 255) << 16); // Establecemos experiencia a 88

printf((estadisticas >> 0) & 255); // Imprimimos muertes
printf((estadisticas >> 8) & 255); // Imprimimos asesinatos
printf((estadisticas >> 16) & 255); // Imprimimos experiencia

[GranaT3]

Vale muchas gracias. Una pregunta, una celda їExactamente quй es?, lo de

Quote:

new var = n; o new array[n];

Es que no soy mucho de nombres tйcnicos xD.

[DesingMyCry]

Yo tampoco soy mucho de nombres tйcnicos ya que aprendo solo probando.

Segъn creo, en PAWN, las celdas son la cantidad de caracteres que soportarб una variable.
Cuando declaras una variable del tipo:

pawn Код:

new variable;

Dicha variable adquiere un valor vacнo, que en PAWN es el ASCII 0, o \0, por eso es que si lo imprimes con:

pawn Код:

printf("contenido: %c", variable);

No te devolverб datos, pero si le estableces el valor numйrico de 77 (por ejemplo) y vuelves a usar printf de la misma forma, te mostrarб el valor ASCII del nъmero 77.

Entonces, cuando creas un arreglo, ejemplo:

pawn Код:

new arreglo[12];

Estas creando algo asн como 12 variables y estableciendo todas ellas a valor vacнo (o nulo) con ASCII 0.

------------------------

Dicho de forma prбctica:

pawn Код:

new singular = 5; // Variable de 1 celda
new arreglo[12]; // Variable de 12 celdas
new arreglo2[2][2]; // Variable de 4 celdas (2*2)
new arreglo3[2][4][6]; // Variable de 48 celdas (2*4*6)

[GranaT3]

Vale y eso de x64 їA quй se refiere?.

[DesingMyCry]

Es la arquitectura del sistema.

Si te descargas algun sistema operativo, tendrбs la opciуn x86 (32bits) y x64 (64bits). La mayorнa de los procesadores actuales soportan x64.

Osea que el lнmite ya no serб de 2^31-1 sino de 2^63-1. Aunque SA-MP esta compilado para x86 por lo que aunque lo corras en un SO de x64, el lнmite seguirб siendo el de 32bits.