[Guia] Introducción al Source de eathena

Estado: Trabajando #Diseñando un protocolo estetico a la guia (colores, tamaños, etc) y estructurando la guia en secciones y subsecciones#

psmileha6

1- Primer contacto con el Src
antes de nada ya sabreis o deberíais saber que eathena es un emulador open source, es decir de código abierto, esto quiere decir que podemos editar el emulador al 100%, voy a introduciros al mundo del source de eathena, tanto eathena svn stable/trunk txt/sql estan escritos en el lenguaje C. Existe otro emulador llamado eApp, tambien conocido como eA++ escrito en el lenguaje C++, aun esta en desarrollo, no os invito a utilizarlo, en mi guia trataremos unicamente y exclusivamente eathena stable/trunk txt/sql.

1.1 Fases de desarrollo de eathena
Bueno, estas son las 3 fases que sufre vuestro eathena al compilarlo desde que es puro src asta que se combierte en archivos binarios ejecutables.

1- La preprocesación:
Transforma el src, lo combierte en otro archivo fuente “predigerido”. Las transformaciones incluyen:
-Eliminar los comentarios.
-Incluir en el fuente el contenido de los ficheros declarados con #include <fichero>
-Sustituir en el src las macros declaradas con #define (ej. #define tres 3)

2- La Compilación:
Convierte el src preprocesado en un archivo en lenguaje maquina: archivo objeto.
segun el compilador pasará por una fase intermedia en lenguaje ensamblador.

3- El enlazador:
Un archivo objeto es código binario, pero no se puede ejecutar, porque le falta código que se encuentra en otros archivos binarios.
El enlazador genera el ejecutable binario, a partir del contenido de los archivos objetos y de las librerias.
Las librerias contienen el código de funciones precompiladas, a las que el archivo fuente llama (por ejemplo printf, scanf, etc...).

2. Librerias

eathena carece de tipos y servicios que forman parte de otros lenguajes que no son C.
No tiene boolean, ni manejo de cadenas, ni manejo de memoria dinamica.
Pero eathena define un conjunto de librerias de funciones, que necesariamente vienen con todo entorno de compilación de eathena y que satisfacen estos servicios elementales y necesarios.
Las interfaces de estos servicios vienen definidas en unos ficheros cabeceras (header files). El nombre de estos ficheros suele terminar en .h
ejemplos:
#include "../common/cbasetypes.h"
#include "../common/mmo.h"
#include "../common/timer.h"
#include "atcommand.h"
#include "battle.h"
#include "chat.h"
#include "clif.h"

las mas importantes que tenemos en eathena son:
#include "stdio.h" -> entrada y salida de datos
#include "string.h" -> manejo de cadenas
#include "stdlib.h" -> memoria dinámica
#include "math.h" -> rutinas matemáticas

3. Componentes de eathena y su manipulación de datos

eathena sigue el paradigma de la programación estructurada:
algoritmo+estructura de datos = programa

Estructuras de datos:
-Literales:
un Literal es un dato escrito directamente (ej. 12345, “divinero”, etc...)
eathena maneja 6 tipos de Literales que son los siguientes:
1- Decimal: es un dato entero en base 10 (ej. 1234)
2- Hexadecimal: es un dato entero en base 16 (ej. 0x1234)
3- Octal: es un dato entero en base 8 (ej. 01234)
4- Caracter: es un dato BYTE en ASCII (ej. "A","B","J")
5- Coma Flotante: es un numero real decimal/periodico, no quiero entrar en profundidad de la aritmetica en sus consideraciones y sus limitaciones (ej. 3.456e6)
6- Cadena: es un texto literal: (ej. "hola, estoy escribiendo una guia")

-Tipos de datos:
Los datos en eathena deben de tener un tipo. Las variables contienen datos, y se han de declarar del tipo adecuado a los valores que van a contener.
Voy a explicaros los 5 tipos basicos que utilizareis
1- int: enteros (numeros enteros positivos y negativos)
2- char: caracteres (letras)
3- float: numeros en coma flotante (numeros reales)
4- double: numeros en coma flotante de doble precision
5- void: no-tipo (se usa con punteros)

Todos estos tipos excepto void son tipos numericos.

Se pueden construir tipos de datos mas elaborados a partir de estos tipos basicos:
-Vectores y matrices
-Punteros
-Tipos estructurados (registros)

-Declaraciones de variables:
Las variables se utilizan para guardar datos dentro del eathena.
Hay que declarar las variables antes de usarlas.
Cada variable tiene un tipo.
Declaración: tipo nombre; (ej. int guia;)

-Rangos de valores y tipos modificados:
Rango de los enteros:
Una variable entera acepta valores positivos y negativos dentro de un rango determinado,
aquí interviene algo muy importante, y es que depende de la plataforma y del compilador (en MS-DOS suele estar entre -32768 y 32767; en Linux son enteros de 32 bits).

Existen 4 modificaciones para el tipo int, para alterar el rango de valores sobre el que trabaja:
1- short: entero corto (rango mas pequeño)
2- long: entero largo (rango mas amplio)
3- unsigned: entero sin signo (0..N)
4- signed: entero con signo (-N-1 .. +N)

La palabra int se puede omitir en la declaracion de la variable
Los modificadores de tamaño ( short, long) y de signo ( signed, unsigned) se pueden combinar.
Por omision, un entero es signed.
Ejemplos:
unsigned sin_signo;
long saldo_en_movil;
unsigned long telefono;

Tipo char:
El tipo char permite manejar caracteres (letras), aunque se trata de un tipo numerico.
Normalmente el rango de valores va de –128 a +127 (signed char), o bien de 0 a 255 (unsigned char)
Los literales de tipo caracter se pueden utilizar como numeros.
Ejemplo:
char caracter; //declaramos
int entero; //declaramos

caracter = 65; // valdría como una 'A'
entero = ‘A’; // valdría como un 65

Ejemplos de Variables validas y no validas:
-validas:
char letra;
int Letra;
float CHAR;
int __variable__;
int cantidad_envases;
double precio123;
int __;

-no validas:
int 123var; -> Empieza por digitos
char int; -> Palabra reservada
int una sola; -> Contiene espacios
int DOLAR$; -> Contiene $
int var.nueva; -> Contiene el punto

Expresiones:
Los datos se manipulan mediante expresiones, que sirven para calcular valores. En eathena hay varios operadores para construir expresiones:
+ ->suma
- -> resta
* -> multiplicación
/ -> división
% -> residuo de la división

Una expresión combina varias operaciones y devuelve un valor.
Los operadores *, / y % tienen prioridad sobre la suma y la resta.
Se pueden utilizar parentesis para agrupar subexpresiones.
ej: 2+2 * ( (5*4) / (9-2) )

Asignación de una variable:
La forma de dar valor a una variable es:
variable = expresión ;
Se le llama asignación.

Tambien se puede dar valor a una variable en el mismo momento en que se declara:
tipo variable = expresión ;
ej. int numero = 1;
Una variable que se declara sin asignarle valor contiene un valor indeterminado, hasta que le asignemos un valor mas adelante.

ejemplo:
int valor1 = 1;
int valor2;

valor1 = valor1 + 3; -> el valor que contiene la variable es 4
valor2 = valor2 + 3; -> error
valor2 = 3+2; -> el valor que contiene la variable es 5

Las asignaciones son expresiones
Una asignación es una expresión. Esto quiere decir que: a) devuelve un valor; b) una asignación puede colocarse dentro de una expresión mas compleja.
El valor devuelto por la asignación a=b es el resultado de evaluar b.
ej. C = 20 - ( B = 2*(A=5)+4 ) ;
explico:
A valdra 5 (por la expresión A=5)
B valdra 2*(5)+4= 14
C valdra 20-(14)= 6
resumiendo, una asignación se puede colocar en cualquier sitio donde se puede emplear una expresión.

Operadores avanzados:
Los operadores de incremento, decremento y asignación compuesta permiten modificar el contenido de una variable de forma abreviada.

A++, ++A -> Incrementa en 1 el valor de A (A=A+1)
A--, --A -> Disminuye en 1 el valor de A (A=A-1)
A+=x -> A=A+x
A-=x -> A=A-x
A*=x -> A=A*x
A/=x -> A=A/x

Operadores “pre” y “post” y valor devuelto:
Si el operador ++ o -- se coloca a la izquierda, se llama preincremento (++) o predecremento (--). Si se coloca a la derecha, se llama postincremento(++) o postdecremento(--).
Cuando se escriben estas expresiones dentro de expresiones más complejas, el valor que se devuelve es:
* Operaciones “pre”: El valor nuevo de la variable afectada
* Operaciones “post”: El valor anterior de la variable afectada
ej.
x=1;
A = ++x; -> preincremento, es decir, A valdra 2, x valdra 2

x=1;
A = x++; -> postincremento, es decir, A valdra 1, x valdra 2

Las asignaciones compuestas devuelven el nuevo valor de la variable:
x=2; A=(x*=3)+1; -> x valdra 6 y A valdra 7