void signal( char * tipo_proceso,
int señal )
void signal(
CPROCESS * identificador, int señal )
void signal( char * tipo_proceso,
int señal, igual )
void signal_equal(
char * tipo_proceso, int señal )
Descripción:
Manda una señal a un proceso o varios. Esta función se utiliza principalmente (aunque no sólo) para destruir (matar) a un proceso desde otro, enviándole una señal s_kill.
Si desconoce a qué se hace referencia cuando se habla del proceso padre, hijo, hermano, un proceso huérfano, etc., entonces vea Jerarquías de procesos.
Si se llama a la función signal() con un parámetro de entrada "jugador", si existen procesos que se llamen "jugador1", "jugador2", etc. estos también serán objeto de la señal que se le manda a signal(), es decir si se escribe: signal("j") todos los procesos que su tipo contenga una 'j' serán objeto de calculo.
Si se llama a la función signal_equal() con un parámetro de entrada "jugador", si existen procesos que se llamen "jugador1", "jugador2", etc. estos también no serán objeto de la señal que se le manda a signal_equal(), es decir si se escribe: signal("j") todos los procesos que su tipo contenga una 'j' no serán objeto de calculo, sino todos los que solo se llamen 'j'. Esta función es equivalente a llamar "signal("j", señal, 1)" ya que el ultimo parámetro indica que han de ser iguales.
Si desconoce los términos vivo, muerto, dormido, etc., referidos a procesos, vea Estados de un proceso.
PROCESS( mi_proceso ) BEGIN // ... LOOP FRAME; END MAIN_PROGRAM_CDIV PRIVATE int id2; BEGIN_PROGRAM id2=new mi_proceso(); // ... signal(id2, s_kill); END_PROGRAM
Este programa crearía un proceso de tipo mi_proceso y después lo eliminaría con la sentencia signal(id2,s_kill) (id2 es una variable del programa principal que contiene el código identificador del proceso que se va a destruir).
Cualquier proceso puede enviar una señal a otro, siempre que disponga de su código identificador, ver:
Códigos identificadores de procesos
Formas de obtener el código identificador de un proceso
No obstante, hay otros tipos de señales que se le pueden enviar a un proceso, y son las siguientes:
s_kill - Orden de matar al proceso, el proceso ya no aparecerá en las siguientes imágenes del juego.
s_sleep - Orden de dormir al proceso, el proceso quedará paralizado sin ejecutar su código y sin visualizarse en pantalla (ni poder ser detectado por el resto de los procesos), como si se hubiera matado. Pero el proceso seguirá existiendo en la memoria del ordenador (ver s_wakeup).
s_freeze - Orden de congelar al proceso, el proceso quedará inmovilizado sin ejecutar su código, pero seguirá visualizándose en pantalla y pudiendo ser detectado (en las colisiones) por el resto de procesos. El proceso seguirá existiendo en la memoria del ordenador a pesar de no ejecutarse su código (ver s_wakeup).
s_wakeup - Orden de despertar al proceso, devuelve a su estado normal un proceso que ha sido dormido o congelado; a partir del momento en que reciba esta señal el proceso volverá a ejecutarse y visualizarse normalmente. No se puede devolver a su estado normal un proceso que ha sido eliminado (matado) pues ya ha dejado de existir en la memoria del ordenador.
Un proceso puede enviarse también estas señales a sí mismo, teniendo en cuenta que el código identificador de un proceso es siempre this (palabra reservada en el lenguaje para tal fin). La sentencia sería como la siguiente:
signal(this, señal)
Auto-eliminar un proceso de esta forma, enviándose una señal s_kill, no destruirá el proceso instantáneamente, sino en la próxima visualización (FRAME).
Todas las señales enviadas a procesos tendrán efecto justo antes de la próxima visualización del juego, es decir, en la próxima imagen (FRAME) del juego (no instantáneamente).
Además de estas cuatro señales existen otras cuatro que se corresponden directamente con las anteriores y son: s_kill_tree, s_sleep_tree, s_freeze_tree y s_wakeup_tree.
Estas señales se utilizan cuando se quieren enviar, no sólo al proceso indicado, sino, además, a todos los procesos que éste haya creado, es decir, si se envía una señal s_kill_tree a un proceso, se destruirá él y toda su descendencia (hijos, nietos, ...), todos los procesos que haya creado y los que hayan creado estos.
Una excepción a estas últimas cuatro señales es cuando existe un proceso huérfano, esto es, un proceso cuyo padre (el proceso que lo llamó) ya está muerto. Los procesos huérfanos no recibirán la señal cuando se les envíe a un proceso del cual son descendencia, pues al haber desaparecido su padre, éste no podrá transmitir la señal a los procesos que creó.
PROCESS( mi_proceso )
BEGIN
graph=100;
LOOP{
x=160+get_distx2d(angle, 140);
y=100+get_disty2d(angle, 80);
angle+=5000;
FRAME;
}
END
MAIN_PROGRAM_CDIV
PRIVATE
int id_text;
BEGIN_PROGRAM
set_gfx(GFX_AUTODETECT_WINDOWED);
set_mode(m320x200);
load_fpg("help/help.fpg");
put_screen(1, 1);
write(0, 0, 0, 0, "1 - crear el proceso");
write(0, 0, 10, 0, "2 - matar el proceso");
write(0, 0, 20, 0, "3 - dormir el proceso");
write(0, 0, 30, 0, "4 - congelar el proceso");
write(0, 0, 40, 0, "5 - despertar el proceso");
id_text=write(0, 0, 190, 0, "No hay proceso");
LOOP{
if (key(_1) && !son){
delete_text(id_text);
new mi_proceso();
id_text=write(0, 0, 190, 0, "Proceso vivo");
}
if (key(_2) && son){
delete_text(id_text);
signal(son, s_kill);
id_text=write(0, 0, 190, 0, "No hay proceso");
}
if (key(_3) && son){
delete_text(id_text);
signal(son, s_sleep);
id_text=write(0, 0, 190, 0, "Proceso dormido");
}
if (key(_4) && son){
delete_text(id_text);
signal(son, s_freeze);
id_text=write(0, 0, 190, 0, "Proceso congelado");
}
if (key(_5) && son){
delete_text(id_text);
signal(son, s_wakeup);
id_text=write(0, 0, 190, 0, "Proceso vivo");
}
FRAME;
}
END_PROGRAMEste programa creará con la tecla 1 un proceso (mi_proceso) que va dando vueltas a la pantalla; con las teclas 2 a 5 se le enviarán a dicho proceso diferentes señales utilizando esta función. El código identificador de mi_proceso está en la variable local son (hijo) del programa principal por defecto.
Cuando se crea un proceso, el sistema define la variable son del padre con el código identificador del hijo, y la variable father del hijo con el código identificador del padre.
signal(id_proceso, señal)
Descripción:
Esta segunda acepción de la función signal es similar a la anterior, con la excepción de que, en lugar de enviarle una señal a un proceso a partir de su código identificador.
Por ejemplo, si en un juego existen, o pueden existir, varios procesos de tipo enemigo y se quiere congelar a dichos procesos (sin congelar a su descendencia) se utilizará la siguiente sentencia:
Nota: Si se quieren eliminar todos los procesos y dejar únicamente al proceso actual, se puede utilizar la función let_me_alone(). Esta función envía una señal s_kill a todos los procesos, excepto al que ejecutó dicha función.
Ver: let_me_alone() - Códigos identificadores - Tipos de procesos