Declaración de un proceso

Un proceso se corresponde, normalmente, con un tipo de objeto del juego, como puede ser una nave, una explosión, un disparo, etc., y dentro del código del proceso se suele implementar un bucle dentro del cual se fijarán todos los valores necesarios de visualización de dicho objeto (gráfico, coordenadas, etc.) y después, mediante la sentencia FRAME, se dará la orden para visualizar el objeto con los atributos establecidos.

Los procesos tiene una serie de datos locales predefinidas las cuales pueden modificar muchos aspectos de su comportamiento.

Los procesos se ejecutan en paralelo, ejecutándose antes el proceso que tenga un mayor valor en su variable local priority.

- Proceso sin parámetros de entrada se declara con la palabra reservada:

PROCESS( nombre )
 Declaración de datos privados o públicos o protegidos
BEGIN
    sentencia ;
    ...
END

- Proceso con parámetros de entrada se declara con la palabra reservada:

PROCESS_INIT( nombre )( parámetros )
 BEGIN_INIT
  //Inicialización de las variables del proceso con los parámetros de entrada
 END_INIT
Declaración de datos privados o públicos o protegidos
BEGIN
    sentencia ;
    ...
END

- Proceso que hereda de una 
clase se declara con la palabra reservada: 
PROCESS_EXTEND( nombre ) PUBLIC_EXTEND clase AUTO_INIT_EXTEND( nombre )
 Declaración de datos privados o públicos o protegidos
BEGIN
    sentencia ;
    ...
END
PROCESS_EXTEND( "nombre_del_proceso" ) seguidamente el tipo de herencia
PUBLIC_EXTEND, PRIVATE_EXTEND o PROTECTED_EXTEND y el nombre de la clase
de la que vamos a heredar y como no hay parámetros tendremos que declarar
AUTO_INIT_EXTEND( "nombre_del_proceso" ) seguidamente se podrán declarar las
variables públicas PUBLIC o privadas PRIVATE que vamos a utilizar en
el proceso, ( ya que si las declaramos el cuerpo del proceso perderán su valor
al llamar a  FRAME ), y la declaración del cuerpo del proceso contenido en el
bloque BEGIN  ... END


- Proceso con parámetros que hereda de una 
clase se declara con la palabra reservada: 
PROCESS_EXTEND( nombre ) PUBLIC_EXTEND clase 
 
 INIT_EXTEND( parámetros )
 BEGIN_INIT
  //Inicialización de las variables del proceso con los parámetros de entrada
 END_INIT
Declaración de datos privados o públicos o protegidos
BEGIN
    sentencia ;
    ...
END

PROTOTIPO DE PROCESO: se le dice al compilador como va ha ser el 
proceso para luego programar su código. Se declaran normalmente al principio del 
programa pero se puede declarar en cualquier parte del programa, una vez 
declarada la estructura del procesos donde debería ir BEGIN ... END 
se sustituye por PROTOTYPE para luego poder declarar su código o cuerpo.
Después de declarar estos prototipos se pueden 
declarar más procesos, funciones, etc... Cuando queramos declarar el cuerpo de 
proceso donde realmente se ejecutan las instrucciones de funcionamiento 
tendremos que poner BEGIN_BODY( nombre_proceso ) ... // Sentencias ... 
END_BODY el nombre del proceso declarado en BEGIN_BODY() ha de 
coincidir exactamente con el de el prototipo.
PROCESS_INIT( nombre )( parámetros )
 BEGIN_INIT
  //Inicialización de las variables del proceso con los parámetros de entrada
 END_INIT
Declaración de datos privados o públicos o protegidos
PROTOTYPE


// Procesos, funciones, etc ...

BEGIN_BODY( nombre )
    sentencia ;
    ...
END_BODY
- Ejemplos de Programa y Procesos:
PROCESS_INIT( mi_proceso )(int _x, int _y)
BEGIN_INIT
  x = _x;
  y = _y;
END_INIT

PRIVATE
   int n;

BEGIN
    graph=1;
    for( n = 0; n < 100; n++){
        x=x+2;
        y=y+1;
        FRAME;
    }
END

MAIN_PROGRAM_CDIV
PRIVATE
    CPROCESS * id2;
BEGIN_PROGRAM
    id2 = new mi_proceso(160, 100)
    // ...
END_PROGRAM
Como se puede observar en este ejemplo, cuando se llama a un proceso éste devuelve su código identificador (que en el ejemplo se guarda en la variable PRIVATE del programa principal id2.
También se pueden declarar prototipos de procesos antes de declarar su código, así se pueden declarar varios procesos y su código cuando sea necesario, aquí pueden ver un ejemplo de un proceso prototipado:
// Prototipo del proceso
PROCESS_INIT( mi_proceso )(int _x, int _y)
 BEGIN_INIT
  x = _x;
  y = _y;
 END_INIT
PRIVATE
   int n;
PROTOTYPE

MAIN_PROGRAM_CDIV
 PRIVATE
    CPROCESS * id2;
BEGIN_PROGRAM
    id2 = new mi_proceso(160, 100)
    // ...
END_PROGRAM

// Código del proceso prototipado
BEGIN_BODY( mi_proceso )
    graph=1;
    for( n = 0; n < 100; n++){
        x=x+2;
        y=y+1;
        FRAME;
    }
END_BODY

En este ejemplo vemos como un proceso puede heredar de una clase y utilizar 
las variables de la clase heredada.
class enemigo {
 public:
  enemigo(){
   contador = 0;
  }

 int contador;
};

PROCESS_EXTEND( jugador ) PUBLIC_EXTEND enemigo AUTO_INIT_EXTEND(jugador)
BEGIN
 contador = 100;
 write_int(0,0,8,0, &contador);
 LOOP{
  contador++;
  FRAME;
 }
END

MAIN_PROGRAM_CDIV
BEGIN_PROGRAM

 set_gfx(GFX_AUTODETECT_WINDOWED);

 set_mode( 320, 200 );

 write(0,0,0,0, "Heredamos de una clase");

 new jugador();

 LOOP
  FRAME;
 
END_PROGRAM
Nota: En un proceso solamente se podrán utilizar las variables declaradas como globales, PUBLIC 
o PRIVATE o las heredadas de una clase, cualquier variable declarada dentro un proceso que no sea declarada de alguna de la formas anteriores perderá su valor al llamar a una sentencia tipo FRAME.
También existen los bloques de funciones que dotan de 
funcionalidad a los procesos.
Ver: Sintaxis - Los bloques de funciones 
- Datos locales de un proceso