[ES][Tutorial] Tutorial de Pawn

Esta guia esta diseñada para darte una mejor descripción general acerca de la programación basica en Pawn.


* 1 Introducción
o 1.1 Paradigmas del Lenguaje
o 1.2 Implementaciones
o 1.3 Licencia
* 2 Variables
o 2.1 Tipos
+ 2.1.1 Integers
+ 2.1.2 Floats
+ 2.1.3 Bools
* 3 Arrays
* 4 Strings
* 5 Funciones
* 6 Expresiones
* 7 Condicionales
o 7.1 If Statements
o 7.2 Switch Statements
* 8 Loop
o 8.1 For Loops
o 8.2 While Loops
o 8.3 Dimensional Arrays
* 9 Compiler Pre-processor Directives
* 10 Conclusion
* 11 External Links
Introducción

Pawn es un programa facil para usar el lenguaje de scripting que es compilado en una maquina virtual. El AMXX Usa Pawn para hookear funciones de

scripting en el Half-Life engine, usando la maquina virtual de Pawn y el MetaMod (El Pawn es escrito en C, El Metamod en C++). Cuando se escriben

scripts de pawn en un editor de texto, los scripts deben ser compilados con un "Compilador", que produce un binario para el AMXX.
El AMXX Team distribuye un especial y modificado compilador de Pawn.
Programar scripts en pawn es relativamente fácil, y no tiene conceptos en otros lenguajes que son innecesarios para uso general, tales como pointers,

vectors, structs, classes, allocation, etc.

Paradigmas del Lenguaje

El Pawn fue nombrado originalmente como "Small" para enfatizar el tamaño del lenguaje específico. El lenguaje sacrifica muchas características que se

pueden encontrar en lenguajes más modernos para lograr la simplicidad y velocidad, que son requeridos para estos usos.

* El pawn posee solo un tipo de información -- la "cell". Es el tamaño del pointer integral del procesador (4 bytes - 32bit, 8 bytes - 64bit). Este tiene dos

mayores dificultades - Pawn Bytecode es un procesador específico, y los pointers pueden caber en un "cell".
* Tag - El pawn deja crear de forma debilmente "tags", que pueden ser asociados con variables para un operador primitivo.
Por ejemplo, el Pawn no tiene concepto acerca de los floating point numeros (solo integers). En cambio, los operadores son sobrecargados con la Float:

un tag que redirecciona la computación a nuevas funciones. El checkeo de tag está solo definidio como un "warning".
* Ya que el Pawn posee solo un tipo de información, no soporta structs, records, objetos, o cualquier otra cosa.
* El Pawn soporta arrays of cells, que lidera el estilo C de arrays for strings.
* El Pawn no posee un espacio de asignación. Todas las variables son almacenadas en la sección de información. Por lo tanto, no hay necesidad de

"basura acumulada" ni memoria necesitada para el lenguaje.
* El Pawn se encuentra totalmente comprendido por solo subrutinas. No se encuentran funciones "lambda", ni funciones "miembro", "constructores", etc.

Las funciones también pueden ser internas (dentro del script) o publicas (expuestas al VM por nombre)


Implementaciones
[/LEFT]

* Cross-platform compatible compiler, which outputs bytecode and debug browsing information.
* Cross-platform compatible Virtual Machine (VM), with support for debug browsing, halting/stopping execution, and interacting with scripts from C/C++

libraries.
* IA32 JIT Compiler for vastly increasing script execution time.

Because the footprints of the VM and JIT are so small, Pawn is ideal inside games which need a simple and highly fast event system, embedded devices

or applications, and realtime systems.

Licencia

ZLib/libpng_License

Variables


Las variables son simples estructuras para mantener data en todas partes con un periodo de tiempo sobre un script

Tipos

El Small posee tres tipos de información para declarar variables. El tipo "variable default" es regularmente un numero entero, o un "integer". Un nombre

de variable, por problemas de compatibilidad, debería tener 19 caracteres o menos, y DEBE empezar con una letra. Puede contener los simbolos A-Z,

a-z, 0-9 y el guión bajo ( " _ " ). Es importante notar que los nombres de las variables son de caso sensible: "myvar", "MyVaR" y "MyVAR" son tres

símbolos separados.

Integers

El tipo de información más simple en Pawn son los "integers". Los integers son todos los números. Para declarar una variable nueva de tipo "integer",

hay que usar el operador "new" como por ejemplo:


new a // Declara la variable vacia "a"
new b=5.0 // Declara la variable "b" con el valor de "5"
new c=5.0 // Esta variable es inválida, tecnicámente no es un número entero!
new d="hello" // La variable "d" que contiene "hello" también es inválida, nisiquiera es un número.

// También se pueden declarar muchas variables en una misma línea
new e,f,g,h
new x=7, y=3
new z = 1_000_000 // El pawn soporta números como este. Los grandes valores son más fáciles de leer.
[/php]Floats:

También se puede declarar una variable como una "Float:", que significa que esta variable puede contener números con decimales. Estos números son

llamados "floating points" ("puntos de flota", Ejemplo:


// Float(N) es una función que toma el número N y lo hace A.
// Floating Point Números
new Float:var = float(5)
new Float:var2 = 5.0
new Float:var3 = 1.0*5
new var4 = floatround(5.0)

// Nota: La función floatround(N) es aquella que toma el número N y lo hace un número entero.
// Esto hace que la variable var4 sea válida.
[/php]Nota: Usar la barra espaciadora generalmente no importa, siempre y cuando el compilador pueda apartar los símbolos uno de otro. Si uno usa la barra

espaciadora realmente mal, tendrá errores o warnings. Por Ejemplo, "new var = 5" y "new var=5" son lo mismo para el compilador, pero "newvar=5" está

totalmente mal.

Booleans

El último tipo de variables son las "booleans". Es muy simple, Se trata de "true" o "false". Ambos "true" y "false" son estructuras predefinidas de

información.


new bool:IsItOn // Declara una nueva variable "IsItOn" qué automáticamente es "falsa" por defecto.
new bool:xyz=true // Declara una nueva variable "xyz" con el valor definido como "true"
[/php]Arrays

Los arrays son variables simples que agregan y contienen información. Esto significa que se pueden almacenar valores múltiples en una variable. Un

array sigue las mismas reglas que una variable cualquiera, y posee la misma estructura. Simplemente puede contener múltiples valores. Se define el

array con corchetes ( [ ] ), y cuanta información puede tener. Ejemplo:


// Esto declarará una nueva array llamada "Players" que contendrá 32 números.
new Players[32]

// Ahora es posible almacenar valores en cualquiera de los 32 "slots" que posee la variable.
// Los slots son numerados desde 0 hasta n-1, en este caso, desde 0 a 31.
// Cada slot empieza desde 0 SIEMPRE.

// Setear el Slot 0 a 5
Players[0] = 5

// Setear el slot 1 a lo que se encuentre en el slot 0, en este caso, el número 5.
Players = Players[0]

// Esto es inválido !
// Aunque hayan 32 slots, estos son numerados desde el 0 al 31.
// Haciendo esto se obtiene un error: AMX Native Error - AMX_ERR_BOUNDS
// O, Simplemente no compilará
Players[32] = 15

// Esto también es totalmente inválido
Players[-1] = 6

new A = 3
// Esto también es totalmente inválido
// La variable A Debe ser un número CONST.
new BadArray[A]

// Entonces, esto es válido:
const B = 3
new GoodArray

// También se puede usar Compiler Pre-Directives (visitar última sección)

#define ARRAY_SIZE 3
new Array[ARRAY_SIZE]
[/php]Las Arrays también pueden ser declaradas con grupos de información default, Por ejemplo:


new Numbers[4] = { 0,1,2,3 }
// Nota: Es importante estar seguro del monto de números puestos
// que posee y el tamaño del array.
[/php]También se puede usar cualquier tipo de información con arrays:


// Array "floating poitns":
new Float:Numbers[4] = { 0.0, 1.2, 2.4, 3.8 }

// Array con bools. Esto setea todos los slots a TRUE
new PlayerHasGun[32] = true
[/php]Strings

Probablemente se ha notado que un importante tipo de información y caracteres se pierde (Letras y símbolos). Estos son llamados "strings", y en pawn,

técnicamente son números. Una string es una array de números que se traduce a ASCII (caracteres) símbolos. Por Ejemplo:


// Esto declarará un string llamado "MyString" que contenerá la información "Hello"
// Tendrá 6 slots, ya que son 5 caracteres.
// El último slot se encuentra reservado para el slot 0, que le dice al engine del Pawn que esto es una string
new MyString[] = "Hello"
[/php]Nota: Cualquier cosa entre /* y */ también es un comentario. No se puede usar un /* */ dentro de un /* */. Los siguiente comandos poseen el mismo

propósito, sin embargo, es más largo y no recomendado. Esto funciona porque cada caracter de la string "Hello" está almacenada en un slot del array.


new MyString[6]
MyString[0] = 'H'
MyString = 'e'
MyString = 'e'
MyString[3] = 'l'
MyString[4] = 'l'
MyString[5] = 'o'
[/php]Nota: Las arrays que proponen ser strings deben terminar en 0, o en un caracter vacío. Esto es para saber donde el string termina.
No se puede hacer ESTO !. Es altamente peligroso y puede causar errores y overflow:


new MyString[6]
MyString = "Hello" // INVÁLIDO !
MyString[0] = "Hello" // INVÁLIDO !

// Para agregar información a una string, se puede hacer esto:
new GoodString[7]
copy(GoodString, 6, "Hello"
[/php]Notemos que hemos copiado 6 lugares del array dentro de un array que puede contener 7. Si copiaramos 7 lugares dentro del array, copy() podría

potencialmente copiar un byte más para el caracter vacío, haciendo overflow sobre el array. Esto es llamado un Buffer Overflow y debe ser evitado.

Más Ejemplos:


// La función Copy toma tres parámetros:
copy(Destino[] , Length, Source[])

// Copia la string dentro del source array y sus respectivos lugares
// Va sobre el array de destino, pero solo copia los caracteres del LENGTH.

// Por último, para probar que una string es realmente un array de números, esto es completamente válido.
new Weird[6]
Weird[0] = 68
Weird = 65
Weird = 73
Weird[3] = 86
Weird[4] = 60
Weird[5] = 0
// Esto seteará la variable Weird al string "DAVID".
[/php]Para ver como los símbolos y letras se traducen en números, visiten Aquí,.

Funciones

El pawn permite definir tus propias funciones. Esto es práctico para remover el código que es usado en múltiples lugares. Notemos que todas las

funciones deben volverse un valor. Para hacer esto, si se usa el comando "return", que inmediatamente retorna la función y retorna el valor de la

expresión pasada a él. Ningún código es ejecutado en una función una vez que el return es encontrado. Aquí un par de ejemplos:


// Esta función no toma parámetros y retorna en 1.
// Cuando es activada, usa la (no existente) función de print.

show()
{
print("Hello"
return 1 // Termina, retorna 1.
}

// Se activa de la siguiente manera:
show().
[/php]También se pueden declarar funciones para tomar parámetros:


// Esto declara una función llamada "add_two_numbers" (agregar dos números), que toma dos números y devuelve la suma.

add_two_numbers(first,second)
{
new sum = first + second
return sum // Devuelve la Suma
}

// Entonces se puede usar en funciones como esta:

new a,b
a = 5
b = 12
new c = add_two_numbers(a,b)

// C equivalerá a 17 ahora.
[/php]No estás limitado por cuales tipos de información y parametros pueden ser aceptados. Cuando se dan parámetros en una función, se le llama "passing"

(paso). También es posible pasar información o una variable a un parámetro en una función.


// Esto define una nueva función llamada "add_two_floats" (agregar dos floats)
// Toma dos floats y devuelve la suma

Float:add_two_floats(Float:first, Float:second)
{
new Float:sum = first + second
return sum
}

new Float:a
new Float:b
a = 5.0
b = 6.3
new Float:c
c = add_two_floats(a+b)

// C Equivalerá a 11.3 ahora
[/php]También se pueden pasar arrays. No hay que especificar el tamaño del array, si esto se hace, hay que estar seguro de que estamos haciendo una
función con un array de mismo tamaño y tipo.


add_two_from_array(array[],a,b)
{
new First = array[a]
new Second = array
new Sum = add_two_numbers(first,second) // Usamos nuestra función usada anteriormente
return Sum
}
[/php]Notemos, que cuando se pasan arrays por una función son pasadas por lo que es llamado "por referencia". Cuando una variable normal es pasada a una

función, es copiada en la memoria, y la copia es mandada luego. En el caso de un array, ya que los arrays pueden ser muy largas, el o los arrays son

referenciados en vez de ser copiados. Esto significa que si cambias el array, luego será cambiado. Por ejemplo:


// Esta función intercambiará los slots a y b dentro de un array pasada a esta función.

swap_slots(array[], a, b)
{
// Nota, se necesitará contener un slot antes de intercambiarlo, temporalmente.
// De otra manera, no se podrán intercambiar los dos valores, es un problema clásico
// Si uno posee A y B, El valor de b equivale a el valor de A y elimina el anterior valor de B
new temp

temp = array
array = array[a]
array[a] = temp
}

new myArray
myArray[0] = 5
myArray = 6
swap_slots(myArray, 0, 1)
//myArray[0] equivale a 6, myArray equivale a 5
[/php]También se puede prevenir que se modifiquen arrays declarandolas como "constantes", entonces:


add_two_from_array(const array[], a, b)
{
new first = array[a]
new second = array
new sum = add_two_from_array(first, second)
return sum
}
// Nota: Cuando esta función es usada, esta garantizado que tu Array no será modificada de ninguna manera.
[/php]Esta función modificará un array pasado como una constante. No funcionará:


bad_function(const array[])
{
array[0] = 0
}
[/php]
Expresiones

Las expresiones son justamente como suenan en matemática. Son grupos de símbolos que devuelven una pieza de información. Las expresiones son

normalmente comprendidas por operaciones con parentesis, y son evaluadas en un cierto orden (primero los paréntesis, luego las

multiplicaciones,divisiones,sumas,restas, etc). Se pueden poner expresiones en cualquier lado, también se pueden setear variables que equivalgan a

ellas o pasarlas a funciones.


// Esta es la más simple expresión, ya que devuelve el número 0.

0

// Sin embargo, para hacerla mas leíble, esto también es válido:

(0)
[/php]Si una expresión no es cero no es "false", no solo devuelve un valor, también se devuelve como "true". De otra manera, devolverá 0 como "false".


// Aquí se encuentran mas expresiones matemáticas. Los operadores matemáticos son:
// + para SUMA
// - para RESTA
// * para MULTIPLICACIÓN
// / para DIVISIÓN
// % para Módulos (encontrar el resto de un número dividido por otro, por ejemplo, 5%2 es 1)

(5+6) // Devuelve 11
((5*6)+3) // Devuelve 33
(((5+3) /2) *4) -9) // Devuelve 5
((5*6) % 7) // Devuelve 2

// Acá, otras expresiones:

(true) // Devuelve el estado "true"
(5.0 + 2.3) // Devuelve 7.3 como una float.
[/php]También hay extensiones en estos operadores para poder ser utilizados en variables.


new a = 5
new b = 6

// Lo primero son los post/pre operadores de incremento.

a++ // Devuelve a+1, o 6. Esto es un post incremento
++a // Devuelve a+1, o 6. Esto es un PRE Incremento
[/php]La diferencia entre el pre/post incrementos es simple pero importante. a++ es evaluado al final en una expresión, cuando ++a es evaluado primero. Esta

diferencia es práctica para los códigos que usan Loops. También es importante saber que los operadores de incremento/decremento no solo devolverán

a+1, pero van a setear la variable a en A+1.


a-- // Devuelve 4 - Post Decremento
--a // Devuelve 4 - PRE Decremento
[/php]Notemos que a++ esencialmente no funcionará bien con este código:


a = a+1
[/php]Sin embargo, hay otro camino para hacer un código así, de esta forma:


a = a OP y
[/php]Dónde OP es un operador matemático. Puede ser más corto haciendo así:


a OP= x
[/php]
Observemos:



a += 1 // Esto setea la variable A en a + 1
a -= b // Esto setea la variable A en A menos la variable B
a *= 0 // Esto multiplica por un 0
a /= 2 // Esto divide a por 2.
[/php]Sin embargo, los operadores matemáticos no son los únicos operadores. También existen operadores de "bools" para ayudar con circuitos lógicos o

decisiones lógicas.
El operador "and" toma las dos expresiones (izquierda y derecha), si las dos son "true", devuelve el estado "true".


// Esto es falso, ya que 1 devuelve "true" pero 0 devuelve "false"
// Ya que ambos no son "true", devolverá "false".
(1 && 0)

(1 && 2) // Ambos números son "true", entonces la expresión sera "true"
(true && false) // "False"
(false && false) // "False"
(true && true) // "True"
[/php]Los otros importantes operadores son "o". Devuelve "true" si una de las dos expresiones son "true".


(1 || 0) // True, ya que uno de los valores es "true"
(1 || 2) // "True"
(true || false) // "True"
(false || false) // "False"
(true || true) // "True"
[/php]Se encuentran también otros operadores, qué no son usados tanto. El operador "bitwise and" (Entre Y) Devuelve si una secuencia binaria se encuentra

adentro de otra secuencia. En términos técnicos, realiza una operación "y (&&" en cada bit en los dos números. Por ejemplo, digamos que tenés el

número "9", que es el binario "1001", si necesitás saber si la secuencia contiene el número 8 (binario 1000), hay que hacer esto:


// Esto devolverá 8, significa que 8 está dentro de un bit de 9
(9 & 8)

// 4 (00100) no es un bit dentro de 16 (10000) y esto devolverá 0
(16 & 4)

// El siguiente operador es "bitwise or" (Entre O)
// Que hace una operación "o ( || )" en cada bit de los dos números.
// Esto tomará 9 (1001) y lo hara coincidir con 3 (0011), el resultado será 1011, o 11.
(9 | 3)
[/php]Estos dos operadores también son importantes, pero no son usados siempre. Estos son llamados los operadores "bitwise" (entre) shift. << es izquierda

y >> es derecha. Estos toman los bits de un número segun la dirección.


// Esto toma el número 3 (00011) y hace un "shift" 3 veces sobre el binario (11000), o 24.
(3 << 3)

// Esto toma el número 24 (11000) y hace un "shift" 3 veces sobre el binario (00011), o 3.
(24 >> 3)
[/php]El último operador es llamado "bitwise not" (entre NO). Devuelve lo exacto contrario de cualquier cosa que sea dado a él. Cuando es usado en un

número, devolverá cada uno de los bits (1 a 0, 0 a 1).


// Esto devolverá "false"
(!true)

// Esto devolverá "true"
(!false)

// Esto toma el binario 9 (1001) y lo convierte en 6 (0110)
// Esto es el operador "bitwise complement" (Entre complemento), qué realiza un ! (no) sobre cada bit.
(~(9))
[/php]Condicionales

Los condicionales te dejan probar si una expresión conoce un standard, y ejecutar el código basado en esa decisión.

If Statements

El más importante condicional es llamado "si...entonces" (if ..then). Evalua si una expresión dada es "true" o "false". Si es "true", ejecutará un bloque de

código. Sino, ejecutará un bloque distinto de código. Por ejemplo:
Esto es un ejemplo de el if...then más basico. La primera línea checkea si la expresión es "true". En este caso, si la variable equivale a 5, entonces

ejecutará el bloque de código que lo setea a 6.


if (a == 5)
{
a = 6
}
[/php]Sin embargo, qué pasa si no equivale a 5? Entonces el código no será ejecutado. Es posible decirle que ejecute el código aunque las condiciones no

sean "true". Ahora, si a equivale a 5, a sera seteada a 6. De otra manera, será seteada a 7.


if (a == 5)
{
a = 6
} else {
a = 7
}
[/php]Hay muchos operadores que pueden ser usados dentro de la funcion if (). De hecho, se puede usar cualquier expresión que evalue a "true" (no cero) o

"false" (cero)


// Esto devolverá "true" si A no equivale a 5
if (a != 5) {}

// Esto devolverá "true" si A es mayor a 5
if (a > 5) {}

// Esto devolverá "true" si A es menor que 5
if (a < 5) {}

// Esto devolverá "true" si A es mayor o equivalente a 5
if (a >= 5) {}

// Esto devolverá "true" porque 11 es true.
if (5+6) {}

// Esto devolverá "true" si los dos valores son "true"
if (a && b) {}

// Esto devolverá true si 7.5 es mayor que la variable c
if ( ( ( 5*3 ) / 2 ) > c ) {}

// Esto devolverá true siempre, no importa qué
if (true) {}

// Nunca devolverá true
if (false) {}
[/php]Notemos que comparar arrays tiene restricciones. Esto es inválido:


my ArrayOne[3]
my ArrayTwo[3]

if (ArrayOne == ArrayTwo) {
[/php]Es necesario hacer:


if ((ArrayOne[0] == ArrayTwo[0] && ArrayOne == ArrayTwo && ArrayOne == ArrayTwo)) {}
[/php]Obviamente, esto se volverá tedioso con largos arrays. Luego veremos como comparar strings y array fácilmente.
El modelo condicional de "if...then" puede ser llevado a otro nivel. El Pawn provee varias maneras para ustedes de proveer niveles múltiples de

expresiones "true" y "false".


// Ejemplo de "if ...else if"
if (a == 5)
{
// Este código se ejecutará si A es 5
} else if (a < 6) {
// Este código se ejecutará si A es menor a 6
} else if (a == 7) {
// Este código se ejecutará si A es 7
} else {
// Si ninguna de las condiciones es válida, este código se ejecutará
}
[/php]Es importante notar que en el código de ejemplo, cada bloque de código no fracasará. Esto significa que cada condición sera checkeada en orden, y si

una es "true", el codigo será ejecutado y la función "if...then" estará realizada. No ejecutará condiciones múltiples de "true"

Switch Statements

Por último, se encuentra un último tipo de estado de condición. Es llamado un "switch" (intercambio), y te permite crear una ordenada lista de

condiciones similares, pero no es tan poderoso como el "if ..else if".


// Ejemplo del switch
switch (a)
{
case 5:
{
// Este código será ejecutado si A equivale a 5
}

case 6:
{
// Este código será ejecutado si A equivale a 6
}

case 7:
{
// Este código será ejecutado si A equivale a 7
}

default:
{
// Este código será ejecutado si ninguno de los otros casos es válido
}
}
[/php]Condiciones múltiples son posibles en Pawn:


// Ejemplo de múltiple switch.
switch (a)
{
case 1, 2, 3:
{
// Este código será ejecutado si A equivale a 1 2 o 3.
}

case 4, 5, 6:
{
// Este código será ejecutado si A equivale a 4, 5, o 6.
}

case 7, 8, 9:
{
// Este código será ejecutado si A equivale a 7, 8, 9
}

default:
{
// Este código será ejecutado si ninguno de los otros casos es válido
}
}
[/php]También se puede usar el switch para rangos:


// Ejemplo de un rango con el condicional switch:
switch (a)
{
case 0 .. 50:
{
// Este código será ejecutado si A es mayor o igual a 0 y menor o igual a 50
}

case 51 .. 100:
{
// Este código será ejecutado si A es mayor o igual a 51 y es menor o igual a 100
}

case 101 .. 200
{
// Este código será ejecutado si A es mayor o igual a 101 y menor o igual a 200
}

default:
{
// Este código será ejecutado si ninguno de los otros casos es válido
}
}
[/php]Notemos que un switch tampoco se trata de evaluar todos los casos y buscar el caso "falso". Si un caso es "true", los otros casos no serán evaluados

Looping
[/LEFT]

El looping es esencial para cualquier lenguaje. Permite personalizar el mismo bloque de código una y otra vez, construyendo condiciones en el código

que sería repetido.

For Loops


La primera condición mas usada de loops es llamada "for loop..". Toma un valor inicial, una condición que debe parar, y un post incremento. Entonces

ejecuta código si las condiciones dadas no son más "True". Esto deja repetir el mismo bloque de código cualquier número de veces.
Ejemplo:


/* La condición for loop posee tres parámetros:

for (inicial; condición; incremento)
{
// Código
}

Antes de que el primer loop se ejecute, se ejecutará la primera condición
Entonces empieza el for loop con los siguientes pasos:

1 - Checkear si la condición es "true". Si es así, continuar, Sino, parar.
2 - Ejecutar el Código
3 - Ejecutar el parámetro de POST-incremento
4 - Volver al paso Número 1
*/

// Ejemplo de un "for loop"
new i
new sum

for (i = 1; i <= 10; i++)
{
sum += i
}
[/php]Explicación:
1 - El primer parámetro, i=1, setea la variable i a uno. Esto pasa antes que el loop comienze.
2 - Luego, el parámetro de incremento es checkeado. Este parámetro es un operador de post-incremento, entonces 1 sera adherido a i luego de evaluar

el bloque completo de código.
3 - Entonces la condición es checkeada. Es i menor o igual a 10 ?
4 - Ya qué la condición es "true" sum += i es ejecutado. Esto significa que i es adherido a la suma.
5 - El bloque de código ha terminado, e i++ incrementa el i a 2.
6 - Ahora se repite
7 - Es i menor o igual a 10 ? Si, es 2. Ahora sum += i se ejecuta de vuelta, y ahora sum equivale a 3.
8 - El bloque de código ha terminado, y ahora i incrementa a 3.
9 - Esto pasa mientras...
10 - El parámetro de incremento setea i a 11. La condición no es más "true", y el "for loop" es terminado.
11 - La variable sum ahora contiene el número 55, qué es la suma de 1 sobre 10.

Esto provee una buena manera para arrays.


// Nota: Esto provee una buena manera para hacer "loops" con arrays. Observemos la función abajo:
sum_of_array(myArray[], size)
{
// Nota: Hay que estar seguro de que no pase el tamaño del array, asi no hay overflow.
new i, sum

// Este loop comenzará con 0 y parará justo antes de que el tamaño sea alcanzado
// Si el usuario pasa el tamaño del array,
// El loop pasará de ser 0 a -1
// Esto correctamente equivale con los slots del array
for (i=0; i<size; i++)
{
// Por cada vez que el loop se ejecuta
// i pasará de 0 a -1 en el tamaño
// Se agregará el valor del slot (i) en el array a sumar
// Una vez que esto termina, sum contendrá
// la suma de todos los slots del array.
sum += myArray
}
return sum
}

new NumberArray[4]
NumberArray[0] = 3
NumberArray = 1
NumberArray = 4
NumberArray[3] = 1

new answer = sum_of_array(NumberArray, 4)
// La respuesta será 3+1+4+1, o 9

// Aquí hay una función para comparar si un array equivale a otro array
bool:compare_arrays(array1[], array2[], size)
{
new i

for (i=0; i<size, i++)
{
// Si un slot de tamaño no equivale, la función sera salteada y devolverá el estado "falso"
if (array1 != array2)
{
return false
}
}
// Si la función llega a este punto sin volverse "false", devolverá "true"
return true
}
[/php]
While Loops


El siguiente tipo de loop es muy importante, y es más simple que un Loop. Es llamado "while" loop, solo toma un parámetro: una condición. Si la

condición es "true" el código seguira siendo ejecutado. Miremos los ejemplos debajo escritos con while loops


// Loop Básico
new i=0
new sum

while (++i <= 10)
{
sum+=i
}

sum_of_array(array[], size)
{
new i=0, sum

// Haciendo este loop i es menor que el tamaño de la variable (array)
// i es incrementado al término de cada loop.

while (i++ < size)
{
sum += array
}
return sum
}

bool:compare_arrays(array1[], array2[], size)
{
new i

while (i++ < size)
{
if (array1 != array2)
{
return false
}
}
return true
}
[/php]Dimensional Arrays

En pawn es posible tener arrays donde cada slot es otro array. Esto es muy útil para almacenar una tabla de información, donde la primera sección de

los slots es una fila y la segunda sección de slots es una columna. Dos arrays dimensionales son declaradas como, por ejemplo:


// Esto declara un array con 50 filas y 50 columnas.
new BigArray[50][50]

// Esto declara una array float con 25 filas y 10 columnas
new Float:BigArray[25][10]
[/php]Cada slot en el primer subconjunto del array se transforma en su propio array:


new BigArray[3][3]
BigArray[0][0] = 10
BigArray[0] = 20
BigArray[0] = 30
BigArray[0] = 40
BigArray = 50
BigArray = 60
BigArray[0] = 70
BigArray = 80
BigArray = 90
[/php]El resultado de BigArray se verá como esto:

--------------------------------------------------------
BigArray 0 1 2
--------------------------------------------------------
0 10 20 30
----------------------------------------------------------
1 40 50 60
---------------------------------------------------------
2 70 80 90
---------------------------------------------------------

Notemos que nuestra vieja función sum_of_array() todavía puede funcionar, podemos hacer:


new sum = sum_of_array(BigArray, 3)
[/php]Porqué BigArray contiene un segundo, una simple array dimensional, que contiene { 7, 8, 9 }. Sin embargo, vamos a escribir una suma entre funciones

array


// Esta función hara que una array equivalga a otra
sum_of_table(array[][], rows, cols)
{
new i, j, sum

// Dentro del loop se encuentra otro loop
// Esto deja que vayas a cada array dentro de
// los arrays mas grandes.

for (i=0; i<rows; i++)
{
for (j=0; j<cols; j++)
{
sum += array[j]
}
}
return sum
}
[/php]También es posible almacenar arrays de strings usando dos arrays dimensionales:


new StringList[3][] = {"Hello", "my", "friend"}
/*
StringList[0][0] por [0][5] contiene "Hello"
StringList[0] por contiene "my"
StringList[0] por [6] contiene "friend"
*/
[/php]La tabla para la variable StringList se verá como: StringList 0 1 2 3 4 5 6 0 H e l l o \0 1 m y \0 2 f r i e n d \0
Comparar strings en multidimensionales arrays también se considera normal:


if (StringList[0] == "Hello" // Inválido
if (StringList[0][0] == "Hello" // Inválido
if (equali(StringList[0], "Hello") // Válido
[/php]
Compiler Pre-Processor Directives


Los directivos del compilador permiten cambiar la manera de leer un código. Esto es más avanzado y solo será ejecutado en un tiempo breve.


// Para definir un valor, se puede hacer esto:
#define SYMBOL VALUE

// Por Ejemplo:
#define MAX_STRING 250
new String[MAX_STRING]

#define HELLO "Hello. This is a generic greeting."
new Hello[MAX_STRING] = HELLO
[/php]También se puede usar #define para cambiar el código que el compilador crea.


#if defined LINUX
// Esta porción sera compilada si el define "LINUX" Existe
execute_command("ls -l"
#else
// Esta porción sera compilada si el define "LINUX" no Existe
execute_command("dir"
#endif
[/php]También es posible cambiar la memoria que tu script usa:


#pragma dynamic 4096
// Esto crea una capacidad de 16K de memoria (default)
// Es almacenada en bloques de 4 bytes
[/php]Se puede especificar si el punto y coma ( ";" ) es necesario para terminar una linea de código (por defecto no es requerido)


#pragma semicolon 1
[/php]También se puede cambiar el caracter de quotes (en Amx Studio: ^)


#pragma ctrlchar '\'
// Esto setea el caracter ^ en \
// Ahoran deberías usar el \ en vez del ^
// Ejemplo: "this is ^"^" " ahora debería ser " this is \"\" "
[/php]
Conclusión

Esta guia debería dar una breve introducción a la programación básica en Pawn. Esto no constituye la totalidad de conocimientos del Pawn. Para leer la

documentación oficial del Pawn y la guía del lenguaje, sigan el siguiente link: Link (Nota,

esta guia es muy larga y debería ser usada como referencia. También podrían tratar de entrar a los foros de

AMXX para tener mas información). Continuemos a la siguiente sección para ver como aplicar la programación

Small al AMXX Engine !

External Links


* Pawn Language Reference
* Pawn Homepage
* ITB CompuPhase



AVISO: EL TUTORIAL ESTÁ TRADUCIDO POR JUAN'

4 comentarios - [ES][Tutorial] Tutorial de Pawn

diego9307
Gracias! me re sirvio, justo ahora tengo mi propio servidor de cs, y no queria bajar todos los plugins, yo quiero hacerlos.

Te deje 10 puntos.
AGUSHHS
Favorito, recomendado, 10
palber
Macro
(((5+3) /2) *4) -9)

5 + 3 = 8 / 2 = 4 * 4 = 16 - 9 = 7

estoy loco ??