MASPC 1/MASPC_1.iso/Demos/Demo DIV/DATA/HELP/HELP.DIV

Text File | 1997-12-01 | 787.6 KB | 21,475 lines

# ─────────────────────────────────────────────────────────────────

# Los saltos de línea simples son ignorados,
# los saltos de dos o más líneas se interpretan
# como saltos de párrafo.

# Los comentarios sólo pueden comenzar con un
# carácter '#' en la primera columna de una línea.

# Lista de comandos disponibles

# Texto en negrita:
#   {texto a resaltar}

# Definición de un término: (la línea anterior debe estar en blanco)
#   {.N,título}
#   texto ...

# Referencia a un término:
#   {#N,texto}

# Imagen: (N:código dentro de figuras.div (fpg), C:centrado 0, 1 o 2)
#   {+N,C}

# Final de la imagen (se debe indicar para todas las imágenes)
#   {-}

# Carácter '{' o '}':
#   {{} o {}}

# Linea separatoria:
#   {/}

# Salto de línea simple:
#   ·  (shift+3)

# Texto de lenguaje.div:
#   {@N}

# ─────────────────────────────────────────────────────────────────────────────
# Enlace informativo de que una referencia todavía no se ha definido
# ─────────────────────────────────────────────────────────────────────────────

{.0,Enlace del hipertexto inválido}
Ver: {#3,Indice} - {#4,Glosario} - {#1,Ayuda}{/}

Error: No hay ninguna página de ayuda asociada a este enlace.

# ─────────────────────────────────────────────────────────────────────────────
# Ayuda sobre como usar el sistema de ayuda
# ─────────────────────────────────────────────────────────────────────────────

{.1,Cómo usar el sistema de ayuda.}
Ver: {#3,Indice} - {#4,Glosario}{/}

Esta ayuda se maneja con el ratón, principalmente, si bien se pueden
usar también los cursores y las teclas de Re.Pág. y Av.Pág. cuando la ventana
esté seleccionada. Las ventanas están seleccionadas cuando su barra de título
aparece con letras blancas sobre fondo azul, mientras que si no están seleccionadas aparecen
con letras negras sobre fondo gris. Para seleccionar una ventana basta con
pulsar con el ratón sobre la misma.

A la derecha aparece una barra de desplazamiento con dos flechas en sus extremos,
pulsando con el ratón sobre ellas el texto de la ayuda se desplazará hacia arriba y hacia
abajo. También se puede pulsar sobre la propia barra de desplazamiento desplazándose,
en este caso, el texto de página en página.

Inmediatamente debajo de la barra de desplazamiento aparece un botón liso, sin
ningún dibujo, que sirve para modificar el tamaño de la ventana de ayuda; se puede
aumentar o disminuir el número de líneas que aparecen en la ventana de ayuda
manteniendo el ratón pulsado sobre este botón y moviendo, a la vez, el ratón
hacia arriba y hacia abajo.

Dentro de la ayuda pueden aparecen ilustraciones, texto y ejemplos.

{Las ilustraciones} pueden variar su color ligeramente según qué paleta de colores
esté activada en cada momento.

{El texto} aparece en tres colores diferentes, negro, {gris} y {#1,blanco}.
El texto principal de la ayuda aparece en color {negro}, en color {gris} aparecen
aquellos textos que se han querido resaltar por algún motivo especial, normalmente,
por ser información especialmente relevante, y en {blanco} irán los textos
que hacen referencia a otro término de la ayuda. Por su parte, el cursor aparece como una
mano al pasar sobre estos textos y si se pulsa con el ratón sobre ellos, se
visualizará la ayuda correspondiente al término sobre el que se ha pulsado.
{Los ejemplos} son programas o partes de programas que aparecen en la ayuda
para demostrar la forma de utilizar alguna de las capacidades
del lenguaje de programación. Todos ellos comienzan con una línea del tipo
'Programa ejemplo:' en color blanco; para extraer el ejemplo de la
ventana de ayuda basta con pulsar con el ratón sobre dicha línea.
Estos programas pueden ser ejecutados con la tecla {F10} y para
finalizar su ejecución se deben pulsar las teclas {ALT}+{X}.

{/}

{Importante:} Se puede volver siempre a la página anterior de ayuda pulsando la tecla
{Backspace} (la tecla de borrado situada sobre la tecla {Enter}).

# ─────────────────────────────────────────────────────────────────────────────
# Indice general
# ─────────────────────────────────────────────────────────────────────────────

{.3,Indice general.}
Ver: {#1290,Teclas} - {#1250,Menús} - {#1261,Dibujo} - {#1249,Lenguaje}{/}

{#1,Ayuda sobre la ayuda.}·

{#1300,Respuestas a preguntas comunes.}·

{Ayuda sobre los comandos de teclado.}

  {#1291,Comandos en el entorno gráfico}·
  {#1292,Comandos comunes en los juegos}·
  {#1293,Comandos en el trazador de programas}·
  {#1294,Comandos en el editor de programas}·
  {#1295,Comandos en el editor gráfico}·

{Ayuda sobre el sistema de menús.}

  {#1251,Menú de programas}·
  {#1252,Menú de edición}·
  {#1253,Menú de paletas}·
  {#1254,Menú de mapas}·
  {#1255,Menú de ficheros}·
  {#1256,Menú de fuentes}·
  {#1257,Menú de sonidos}·
  {#1258,Menú de sistema}·

  {#1259,Opción de ayuda}·
  {#1260,Trazador de programas}·

{Ayuda sobre el editor gráfico.}

  {#1262,Conceptos generales}·
  {#1263,Paletas de colores}·
  {#1264,Color transparente}·
  {#1265,Controles básicos}·
  {#1266,Iconos genéricos}·
  {#1267,Gamas de colores}·
  {#1268,Utilización de máscaras de color}·

  {#1270,Barras de punteado y lápiz}·
  {#1271,Barras para líneas y multilíneas}·
  {#1272,Barras para curvas y multicurvas}·
  {#1273,Barras de rectángulos y círculos}·
  {#1274,Barra de spray}·
  {#1275,Barra de relleno}·
  {#1276,Barra de edición de bloques}·
  {#1277,Barra de deshacer}·
  {#1278,Barra de texto}·
  {#1279,Barra de puntos de control}·

  {#1280,Edición de animaciones}·
  {#1281,Trucos y técnicas avanzadas de dibujo}·

{Ayuda sobre el lenguaje de programación.}

  {#4,Glosario de términos.}·
  {#1000,Sintaxis de un programa.}·
  {#1017,Relación de sentencias.}·
  {#1032,Lista de funciones.}·

  {#1202,Constantes predefinidas.}·
  {#1200,Datos globales predefinidos.}·
  {#1201,Datos locales predefinidos.}·

  {#1035,Expresiones aritméticas.}·
  {#1037,Condiciones lógicas.}·

  {#1176,Códigos del teclado.}·


# ─────────────────────────────────────────────────────────────────────────────
# Glosario de términos
# ─────────────────────────────────────────────────────────────────────────────

{.4,Glosario de términos.}
Ver: {#3,Indice} - {#1,Ayuda}{/}

{#1045,!}·
{#1046,!=}·
{#1047,"}·
{#1048,%}·
{#1049,%=}·
{#1050,&}·
{#1051,&&}·
{#1052,&=}·
{#1047,'}·
{#1053,(}·
{#1053,)}·
{#1054,*}·
{#1002,*/}·
{#1055,*=}·
{#1056,+}·
{#1057,++}·
{#1058,+=}·
{#1059,,}·
{#1060,-}·
{#1061,--}·
{#1062,-=}·
{#1063,->}·
{#1063,.}·
{#1064,..}·
{#1065,/}·
{#1002,/*}·
{#1002,//}·
{#1066,/=}·
{#1067,:}·
{#1068,;}·
{#1069,<}·
{#1070,<<}·
{#1071,<<=}·
{#1072,<=}·
{#1046,<>}·
{#1073,=}·
{#1072,=<}·
{#1074,==}·
{#1075,=>}·
{#1076,>}·
{#1075,>=}·
{#1077,>>}·
{#1078,>>=}·
{#1079,[}·
{#1079,]}·
{#1080,^}·
{#1081,^=}·
{#1082,^^}·
{#1083,|}·
{#1084,|=}·
{#1083,||}·
{#1176,_códigos de teclas}·
{#100,abs()}·
{#101,advance()}·
{#1161,all_text}·
{#1162,all_sound}·
{#1051,AND}·
{#1129,angle}·
{#1109,ascii}·
{#1086,BEGIN}·
{#1120,bigbro}·
{#1026,BREAK}·
{#1175,c_0 ... c_9}·
{#1169,c_m7}·
{#1167,c_screen}·
{#1168,c_scroll}·
{#1087,CASE}·
{#102,change_sound()}·
{#103,clear_screen()}·
{#1030,CLONE}·
{#1134,cnumber}·
{#104,collision()}·
{#1171,complete_dump}·
{#1174,complete_restore}·
{#1004,CONST}·
{#1027,CONTINUE}·
{#105,convert_palette()}·
{#1122,ctype}·
{#1031,DEBUG}·
{#1088,DEFAULT}·
{#106,define_region()}·
{#107,delete_text()}·
{#1114,dump_type}·
{#1089,DUP}·
{#1090,ELSE}·
{#1091,END}·
{#108,end_fli()}·
{#109,exit()}·
{#110,fade()}·
{#111,fade_off()}·
{#112,fade_on()}·
{#1107,fading}·
{#1152,false}·
{#1117,father}·
{#113,fget_angle()}·
{#114,fget_dist()}·
{#1131,file}·
{#1127,flags}·
{#1025,FOR}·
{#1029,FRAME}·
{#115,frame_fli()}·
{#1043,FROM}·
{#1164,g_height}·
{#1163,g_wide}·
{#1165,g_x_center}·
{#1166,g_y_center}·
{#116,get_angle()}·
{#117,get_dist()}·
{#118,get_distx()}·
{#119,get_disty()}·
{#120,get_id()}·
{#121,get_joy_button()}·
{#122,get_joy_position()}·
{#123,get_pixel()}·
{#124,get_point()}·
{#125,get_real_point()}·
{#1006,GLOBAL}·
{#1126,graph}·
{#126,graphic_info()}·
{#1133,height}·
{#1092,ID}·
{#1020,IF}·
{#1014,IMPORT}·
{#127,is_playing_cd()}·
{#1103,joy (STRUCT)}·
{#1111,joy_filter}·
{#1112,joy_status}·
{#128,key()}·
{#129,let_me_alone()}·
{#130,load()}·
{#131,load_fnt()}·
{#132,load_fpg()}·
{#174,load_map()}·
{#133,load_pal()}·
{#134,load_pcm()}·
{#1007,LOCAL}·
{#1024,LOOP}·
{#1150,m320x200 ... m1024x768}·
{#1102,m7 (STRUCT)}·
{#135,map_block_copy()}·
{#136,map_get_pixel()}·
{#137,map_put()}·
{#138,map_put_pixel()}·
{#139,map_xput()}·
{#1178,max_int}·
{#1115,max_process_time}·
{#1177,min_int}·
{#1048,MOD}·
{#1100,mouse (STRUCT)}·
{#140,move_scroll()}·
{#141,move_text()}·
{#142,near_angle()}·
{#1172,no_restore}·
{#1045,NOT}·
{#1085,OFFSET}·
{#1083,OR}·
{#143,out_region()}·
{#1170,partial_dump}·
{#1173,partial_restore}·
{#1179,pi}·
{#144,play_cd()}·
{#1079,POINTER}·
{#145,pow()}·
{#1121,priority}·
{#1008,PRIVATE}·
{#1016,PROCESS}·
{#1003,PROGRAM}·
{#146,put()}·
{#147,put_pixel()}·
{#148,put_screen()}·
{#149,rand()}·
{#150,rand_seed()}·
{#152,refresh_scroll()}·
{#1130,region}·
{#1023,REPEAT}·
{#1116,reserved}·
{#153,reset_fli()}·
{#175,reset_sound()}·
{#1135,resolution}·
{#1113,restore_type}·
{#1028,RETURN}·
{#154,roll_palette()}·
{#1156,s_freeze}·
{#1160,s_freeze_tree}·
{#1153,s_kill}·
{#1157,s_kill_tree}·
{#1155,s_sleep}·
{#1159,s_sleep_tree}·
{#1154,s_wakeup}·
{#1158,s_wakeup_tree}·
{#155,save()}·
{#1110,scan_code}·
{#1101,scroll (STRUCT)}·
{#156,set_fps()}·
{#157,set_mode()}·
{#178,set_volume()}·
{#1104,setup (STRUCT)}·
{#1093,SETUP_PROGRAM}·
{#1108,shift_status}·
{#158,signal()}·
{#1128,size}·
{#1094,SIZEOF()}·
{#1119,smallbro}·
{#1118,son}·
{#159,sound()}·
{#160,sqrt()}·
{#161,start_fli()}·
{#162,start_mode7()}·
{#163,start_scroll()}·
{#1095,STEP}·
{#164,stop_cd()}·
{#165,stop_mode7()}·
{#166,stop_scroll()}·
{#167,stop_sound()}·
{#1012,STRUCT}·
{#1021,SWITCH}·
{#168,system()}·
{#1106,text_z}·
{#1105,timer[]}·
{#1096,TO}·
{#1151,true}·
{#1042,TYPE}·
{#177,unload_fnt()}·
{#169,unload_fpg()}·
{#176,unload_map()}·
{#170,unload_pcm()}·
{#1097,UNTIL}·
{#1022,WHILE}·
{#171,write()}·
{#172,write_int()}·
{#1123,x}·
{#1132,xgraph}·
{#1082,XOR}·
{#173,xput()}·
{#1124,y}·
{#1125,z}·

# ─────────────────────────────────────────────────────────────────────────────
# Funciones
# ─────────────────────────────────────────────────────────────────────────────

{.100,abs()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{abs(}<expresión>{)}

{Retorna:}

El {valor absoluto} de la expresión.

{Descripción:}

Calcula el valor absoluto de la expresión pasada como parámetro, es decir,
si el resultado de la expresión es negativo lo cambiará de signo,
si es positivo lo dejará igual.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_abs;

GLOBAL
    valores[15];
    n;

BEGIN
    FROM n=0 TO 15;
        valores[n]=rand(-1000, 1000);
        write_int(0, 0, n*10,0, offset valores[n]);
    END
    write(0, 0, 192, 0, "Pulse [ESPACIO] para ejecutar la función abs()");
    LOOP
        IF (key(_space))
            FROM n=0 TO 15;

                valores[n] = abs(valores[n]); // Hallamos el valor absoluto

            END
        END
        FRAME;
    END
END
{-}

Este programa imprimirá en pantalla una lista de valores que pueden ser
positivos o negativos, cuando se pulse la barra espaciadora le aplicará
la función {abs()} a todos estos valores, dejándolos todos positivos.

{/}Ver: {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.101,advance()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{advance(}<distancia>{)}

{Descripción:}

Avanza el proceso en su ángulo (el que indique la variable local {#1129,angle})
tantos puntos como indique la {expresión} (distancia) pasada como parámetro.

La distancia puede ser también un número negativo, con lo cual el gráfico
del proceso avanzará (sus coordenadas {#1123,x} e {#1124,y}) en la dirección contraria
a su ángulo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_advance;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    graph=101;
    x=160;
    y=100;
    write(0, 0, 0, 0, "Use los cursores para cambiar la dirección.");
    LOOP
        IF (key(_right)) angle-=10000; END
        IF (key(_left)) angle+=10000; END

        advance(2); // Avanzamos dos puntos el proceso

        FRAME;
    END
END
{-}

Este ejemplo dibujará un triángulo en pantalla que avanzará en la dirección
especificada en la variable local predefinida {#1129,angle} utilizando esta función.

Se recuerda que el ángulo se especifica en milésimas de grado.

Se podrá modificar la variable {#1129,angle} usando las teclas de los cursores
(sumando y restando 10000, es decir, 10 grados).

{/}

Esta función equivale siempre a las dos siguientes sentencias:

  {x+=get_distx(angle,} <distancia>{);}·
  {y+=get_disty(angle,} <distancia>{);}·

Es decir, esta función únicamente modifica las coordenadas del proceso.
Cabe la posibilidad de utilizar las dos sentencias anteriores cuando se
quiera que el proceso avance en un ángulo diferente al que indica su variable
{#1129,angle}; esto resultará útil cuando se quiera que el gráfico del proceso
avance en una dirección sin rotarse.

Por ejemplo, para conseguir que un proceso avance 8 puntos en una dirección (que se
podría tener en una variable privada como {angle2}) pero rotado hacia
otra dirección, (la indicada en {#1129,angle}), se utilizarían las sentencias:

  {x+=get_distx(angle2, 8);}·
  {y+=get_disty(angle2, 8);}·

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#118,get_distx()} - {#119,get_disty()}

# ─────────────────────────────────────────────────────────────────────────────

{.102,change_sound()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{change_sound(}<canal>{,} <volumen>{,} <frecuencia>{)}

{Descripción:}

Para utilizar esta función es imprescindible tener una tarjeta de sonido
instalada en el ordenador compatible 100% con las tarjetas de la familia
{Sound Blaster} (tm) o {Gravis Ultrasound} (tm).

Esta función tiene sentido utilizarla sólo tras la función {#159,sound()}
que es la utilizada para emitir sonidos.

{Change_sound()} modifica un sonido que está sonando por uno de los {canales},
estableciendo nuevamente su {volumen} y su {frecuencia}.

El {canal} es el {código de canal} que devuelve la función {#159,sound()} cuando
es llamada; pueden sonar hasta 16 canales a la vez, con el mismo sonido o
con diferentes sonidos, por lo tanto, cada vez que se emite un sonido se
hará, posiblemente, por un canal diferente.

Cada {canal} tiene establecidos en todo momento su nivel de volumen y de
frecuencia.

El {volumen} es un valor entre {0} (volumen mínimo) y {512} (volumen máximo)
que determina la potencia con la que se escuchará el sonido de dicho canal.

La {frecuencia} es un valor que afecta a la velocidad a la que se oye el
sonido por el canal, es decir, controla lo grave o agudo que se emite el sonido.
Este valor oscila entre {0} (grave) y {512} (agudo).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_change_sound;

PRIVATE
    frecuencia=256;     // Valor medio (0..512)
    volumen=256;        // Valor medio (0..512)

    id_sonido;
    canal;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);

    id_sonido = load_pcm("help\help.pcm", 1);
    canal = sound(id_sonido, volumen, frecuencia);

    write(0, 0, 0, 0, "Presione derecha o izquierda para cambiar la frecuencia.");
    write_int(0, 0, 10, 0, offset frecuencia);
    write(0, 0, 20, 0, "Presione arriba o abajo para cambiar el volumen.");
    write_int(0, 0, 30, 0, offset volumen);
    LOOP

        // Cambia el sonido
        change_sound(canal, volumen, frecuencia);

        IF (key(_right)) frecuencia++; END
        IF (key(_left)) frecuencia--; END
        IF (key(_up)) volumen++; END
        IF (key(_down)) volumen--; END
        FRAME;
    END

END
{-}

En el ejemplo se carga y se emite un sonido (contenido en el archivo
{help.pcm}). Dentro del bucle principal del programa se cambia
la frecuencia y el volumen de este sonido con la función {change_sound()};
para modificar estos valores se utilizan las teclas de los cursores.

{/}Ver: {#134,load_pcm()} - {#159,sound()} - {#170,unload_pcm()} - {#1104,STRUCT setup}

# ─────────────────────────────────────────────────────────────────────────────

{.103,clear_screen()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{clear_screen()}

{Descripción:}

Borra el fondo de la pantalla, es decir, los gráficos que se hubieran puesto en ella con
las funciones {#146,put()}, {#173,xput()}, {#147,put_pixel()} y {#148,put_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_clear_screen;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write(0, 0, 0, 0, "Presione [ESPACIO] para que se borre la pantalla.");
    write(0, 0, 10, 0, "Presione [ENTER] para volver a visualizarla.");
    graph=100;
    x=160;
    y=100;
    LOOP
        IF (key (_space))

            clear_screen(); // Borra el gráfico de fondo de la pantalla

        END
        IF (key (_enter)) put_screen(0, 1); END
        FRAME;
    END
END
{-}

En el ejemplo se visualiza una pantalla de fondo con la función {#148,put_screen()}.
Al pulsar la barra espaciadora, se borra dicha pantalla.

Pulsando la tecla {Enter}, se vuelve a visualizar la pantalla de fondo.

Se puede observar cómo el gráfico del proceso (una bola que aparece en el
centro) no desaparece al utilizar la función {clear_screen()}, ya que
ésta únicamente borra el fondo de pantalla.

{/}Ver: {#146,put()} - {#173,xput()} - {#147,put_pixel()} - {#148,put_screen()}

# ─────────────────────────────────────────────────────────────────────────────

{.104,collision()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{collision(}<tipo de proceso>{)}

{Retorna:}

El {#1039,código identificador} de un proceso o {0}.

{Descripción:}

Ésta es la función del lenguaje {para detectar choques} entre gráficos.

Comprueba si el proceso actual (el que ejecutó esta función) colisiona con
uno del tipo indicado como parámetro. Es decir, comprueba si los gráficos
de ambos procesos están, al menos, parcialmente superpuestos.

En caso de producirse una colisión devolverá el {#1039,código identificador}
del proceso con el que está chocando el proceso actual. En caso contrario la
función devolverá siempre {0}.

Si el proceso actual colisiona con varios procesos del tipo que se ha
especificado, la función {collision()} devolverá el resto de los
identificadores en las sucesivas llamadas que se realicen a la misma.

Para obtener, de esta forma, todos los {#1039,códigos identificadores} de los procesos
que colisionan con el actual no se debe utilizar la sentencia {#1029,FRAME}
entre dos llamadas consecutivas a la sentencia {collision()}. En el caso de
ejecutar un proceso una sentencia {#1029,FRAME}, esta función volverá a
retornar todos los {#1039,códigos identificadores} de procesos colisionantes
desde el primero.

Algo similar sucede si se ejecuta una llamada a la función especificando un
tipo de proceso diferente; si tras esto se vuelven a detectar las colisiones
con el tipo anterior, esta función también volverá a retornar todos los
códigos desde el primero.

Cuando se quieren obtener los {#1039,códigos identificadores} de los procesos
de un tipo determinado aunque no se produzca ninguna colisión con
ellos, se debe llamar a la función {#120,get_id()}.

Si lo que se pretende es comprobar la cercanía entre dos procesos sin que
necesariamente colisionen sus gráficos, entonces se deberá emplear la
función {#117,get_dist()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_collision;

PRIVATE
    id2;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    graph=100;
    x=160;
    y=100;
    proceso_móvil(80, 50, 101);
    LOOP
        delete_text(all_text);
        write(0, 160, 0, 1, "Use los cursores para mover el triángulo");

        id2 = collision(TYPE proceso_móvil); // Se detecta la colisión

        IF (id2<>0)
            write(0, 160, 200, 7, "¡ DETECTADA COLISION !");
        END
        FRAME;
    END
END

PROCESS proceso_móvil(x, y, graph);

BEGIN
    LOOP
        IF (key(_right)) angle-=10000; END
        IF (key(_left)) angle+=10000; END
        IF (key(_up)) advance(4); END
        FRAME;
    END
END
{-}

En este ejemplo se visualiza una pelota en el centro de la pantalla
como gráfico del programa principal.
Luego se crea un proceso de nombre {proceso_móvil} con el dibujo de un
triángulo controlable con las teclas de los cursores.

El programa principal llamará a la función {collision()} para comprobar
si su gráfico (el círculo) colisiona con el gráfico del proceso de tipo {proceso_móvil}
(el triángulo). El resultado de la función se guarda en la variable privada
{id2} del programa principal; este valor será {0} cuando no se produzca la
colisión y el {#1039,código identificador} de {proceso_móvil} cuando sí.

Los códigos identificadores de los procesos son siempre números impares,
que en el lenguaje se evalúan como condiciones verdaderas (y los números
pares se corresponden con condiciones que resultan falsas), luego en el programa
anterior se podría haber cambiado la sentencia:

  {IF (id2<>0)} ... {END}

Por la siguiente:

  {IF (id2)} ... {END}

Para más información al respecto ver: {#1037,Definición de una condición.}

{/}

Cuando en el programa se esté visualizando el puntero del ratón (asignando
el código del gráfico correspondiente en la {#1100,estructura mouse}), es
posible ver si éste choca con el proceso actual utilizando esta función,
por ejemplo, de la siguiente forma:

  {IF (collision(TYPE mouse))}·
      // El proceso colisiona con el puntero del ratón·
  {END}·

Al detectarse la colisión con el puntero del ratón no se hará con la
totalidad del gráfico utilizado como puntero, sino únicamente con el
{#1136,punto de control} principal (el número 0) del mismo, denominado
usualmente como el "punto caliente" ({hotspot}) del ratón.

{/}

Esta función sirve para detectar colisiones entre gráficos de pantalla
o de una ventana de scroll.

No es posible utilizar esta función para detectar colisiones con
procesos que no tengan gráfico (un código válido asignado a su variable
{#1126,graph}) o entre gráficos de una ventana de modo-7 (con su variable
{#1122,ctype} asignada al valor {#1169,c_m7}).

Es, por tanto, {imprescindible} que tanto el proceso actual como el del tipo
que se especifica tengan definido un gráfico.

Para detectar colisiones entre gráficos de una ventana de modo-7 se debe
utilizar la función {#117,get_dist()} para detectar de esta forma cuándo
la distancia entre los dos procesos es menor a la que se estipule como
{distancia de choque}.

{/}Ver: {#120,get_id()} - {#117,get_dist()} - {#1042,Tipos de procesos} - {#1038,Formas de obtener el código identificador}

# ─────────────────────────────────────────────────────────────────────────────

{.105,convert_palette()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{convert_palette(}<fichero>{,} <gráfico>{,} <OFFSET nueva_paleta>{)}

{Descripción:}

Transforma el mapa de color del {<gráfico>} del {<fichero>} indicado.

El {<}{#1085,offset}{ nueva_paleta>} es la dirección dentro de la memoria del ordenador
de una tabla de 256 valores donde se indicará el nuevo orden de los colores del
gráfico.

Si la tabla con la nueva paleta fuera como se muestra a continuación:

  nueva_paleta[255]=0, 1, 2, 3, 4, ... , 254, 255;

el gráfico no sufriría ninguna transformación. Si, por ejemplo, en la posición
3 de la tabla anterior (nueva_paleta[3]) se pusiera un 16 (en lugar de un 3),
al llamar a esta función con el {#1085,offset} de dicha tabla, se sustituiría en el
gráfico el color 3 por el color 16.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

Si un proceso quisiera cambiar los colores de su propio gráfico, se debería
construir igualmente una tabla con el nuevo orden de los colores y, después,
llamar a la función con los parámetros:

  {convert_palette(file, graph, }<OFFSET nueva_paleta>{)}

A continuación se muestra un programa que cambia los colores de su gráfico
de esta forma utilizando sus variables locales predefinidas {#1131,file} y
{#1126,graph}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_convert_palette;

PRIVATE
    nueva_paleta[255];
    contador;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);

    FROM contador=1 TO 255;
        nueva_paleta[contador]=(contador+16) MOD 256;
    END

    graph=100;
    x=160;
    y=100;

    write (0, 160, 0, 1, "Pulse [ESPACIO] para cambiar los colores de la bola");
    LOOP
        IF (scan_code==_space)

            // Convertimos la paleta del gráfico número 100 (bola)
            convert_palette(file, graph, offset nueva_paleta);

        END
        FRAME;
    END
END
{-}

En primer lugar, {se crea una tabla con el nuevo orden de los colores}
de la paleta. El color número 0 (transparente) no se sustituirá por ninguno
(nueva_paleta[0] valdrá siempre 0) y el resto de los colores (del 1 al 255)
se sustituirán por el color que está 16 posiciones más arriba en la paleta
(el 1 por el 17, el 2 por el 18, etc.). Los últimos 16 colores se sustituirán
por los 16 primeros (al realizar la operación {MOD 256} se truncan los valores,
es decir, 256 pasará a 0, 257 a 1, etc.).

Después, dentro del bucle principal del programa se ejecutará la función
{convert_palette()} de modo que cambie los colores del gráfico del programa
(una bola) cada vez que se pulse la barra espaciadora.

{/}Ver: {#133,load_pal()} - {#154,roll_palette()}

# ─────────────────────────────────────────────────────────────────────────────

{.106,define_region()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{define_region(}<número de región>{,} <x>{,} <y>{,}<ancho> {,}<alto> {)}

{Descripción:}

Define una nueva región de visualización dentro de la pantalla (algo así
como una ventana). Las regiones son zonas rectangulares de la pantalla dentro
de las cuales se visualizarán unos determinados procesos, ventanas de scroll
o de modo-7.

El {número de región} debe ser entre 1 y 31. Se pueden definir hasta 31 regiones
diferentes de pantalla que después podrán asignarse a diferentes procesos
(fijando su variable local {#1130,region} al nuevo número) como su ventana de
visualización, o bien utilizarse como marco para una ventana de scroll o
de modo-7 indicándolo en el parámetro correspondiente de las funciones
{#163,start_scroll()} o {#162,start_mode7()}.

La {región número 0} no se debe redefinir, pues será siempre la pantalla
completa, una ventana en las coordenadas (0, 0) y del ancho y alto de la pantalla.
Ésta es la región en la que se visualizarán por defecto todos los procesos,
ya que su variable local {#1130,region} siempre vale 0 por defecto.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_define_region;

PRIVATE
    contador;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);

    define_region(1, 0, 0, 160, 200);   // Definimos la región 1
    define_region(2, 160, 0, 160, 200); // Definimos la región 2

    write(0, 0, 0, 0, "Región 1");
    write(0, 320, 0, 2, "Región 2");

    FROM contador=1 TO 20;
        proceso_móvil(rand(0, 319), rand(0, 159), rand(-8, 8), rand(-8, 8), rand(1, 2));
    END
END

PROCESS proceso_móvil(x, y, incremento_x, incremento_y, region);

BEGIN
    graph=100;
    LOOP
        IF (x<0 OR x>320) incremento_x=-incremento_x; END
        IF (y<0 OR y>200) incremento_y=-incremento_y; END
        x+=incremento_x;
        y+=incremento_y;
        FRAME;
    END
END
{-}

Primero se definen dos regiones como divisiones laterales de la pantalla.
Luego, se crean con un bucle 20 procesos de tipo {proceso_móvil} en coordenadas
y desplazamiento aleatorios, en una de las dos regiones.

Se puede observar en su ejecución cómo cada proceso se ve únicamente en
una de las dos mitades de la pantalla (sólo en su región).

{/}Ver: {#143,out_region()} - {#163,start_scroll()} - {#162,start_mode7()} - {#1130,Variable region}

# ─────────────────────────────────────────────────────────────────────────────

{.107,delete_text()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{delete_text(}<identificador del texto>{)}

{Descripción:}

Borra un texto definitivamente de la pantalla si se especifica como parámetro
el {identificador del texto}, que es un código numérico que devuelven las
funciones {#171,write()} y {#172,write_int()} cuando se les pide que escriban un texto.

Si se especifica como parámetro {#1161,all_text} se borrarán todos los textos
de pantalla.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_delete_text;

PRIVATE
    identificador_texto;

BEGIN
    write(0, 160, 10, 1, "Pulse [ENTER] para hacer aparecer el texto superior.");
    LOOP
        identificador_texto=write(0, 160, 0, 1, "Pulse [ESPACIO] para hacer desaparecer este texto.");
        WHILE (NOT key(_space))
            FRAME;
        END

        delete_text(identificador_texto); // Borramos el texto

        WHILE (NOT key(_enter))
            FRAME;
        END
    END
END
{-}

En el ejemplo anterior, se imprimen dos textos en pantalla. Cuando
se pulsa la barra espaciadora se borra uno de ellos con la función {delete_text()},
y cuando se pulsa la tecla Enter hacemos que vuelva a aparecer, imprimiéndolo otra vez
con la función {#171,write()}, la cual nos devuelve el identificador del texto.

{/}Ver: {#171,write()} - {#172,write_int()} - {#141,move_text()}

# ─────────────────────────────────────────────────────────────────────────────

{.108,end_fli()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{end_fli()}

{Descripción:}

Finaliza una animación {FLI/FLC} visualizada en pantalla y libera la memoria
del ordenador que estaba ocupando.

Las animaciones {FLI/FLC} se inician con la función {#161,start_fli()}.

Sólamente es posible tener una animación cargada en la memoria del
ordenador.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_end_fli;
BEGIN
    LOOP
        start_fli("help\help.fli", 0, 0);
        WHILE (frame_fli()<>0)
            FRAME;
        END

        end_fli(); // Descargamos la animacion de la memoria

    END
END
{-}

En primer lugar, en el ejemplo, se carga la animación con la función
{#161,start_fli()} y entonces se muestra la misma con {#115,frame_fli()}
hasta que acaba (cuando esta última función devuelve un 0). En ese
momento se descarga de memoria utilizando {end_fli()}.

El programa continúa repitiendo esta operación (de carga y descarga de la
animación {FLI/FLC}) indefinidamente.

No es necesario que la animación haya finalizado para poder descargarla
de memoria.

{/}Ver: {#161,start_fli()} - {#115,frame_fli()} - {#153,reset_fli()}

# ─────────────────────────────────────────────────────────────────────────────

{.109,exit()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{exit(}<mensaje>{,} <código de retorno>{)}

{Descripción:}

Termina el juego matando todos los procesos de forma inmediata y regresando
al sistema operativo (o al entorno DIV) con un {mensaje} y un {código numérico}
(el indicado en la expresión del segundo parámetro).

El mensaje es un texto entre comillas que aparecerá cuando finalice el juego
como mensaje de despedida para el jugador.

El {código de retorno} es válido para el uso de programas externos a
DIV Games Studio (como ficheros de proceso por lotes BAT), para determinar
la acción que se debe realizar tras ejecutarse el juego.

Cuando se utiliza la función {exit()} no es necesario haber descargado
previamente ningún recurso, como ficheros, mapas, sonidos, etc., ya que
el sistema finaliza de forma automática todos los recursos.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_exit;
BEGIN
    write(0, 160, 0, 1, "Pulsa [ESPACIO] para acabar el programa.");
    LOOP
        IF (key (_space))
            fade_off();

            exit("Gracias por usarme!", 0); // Salimos del programa

        END
        FRAME;
    END
END
{-}

En el ejemplo se imprime un mensaje y luego se espera a que se pulse la
barra espaciadora para salir del programa con la función {exit()}.

El uso de la función {#111,fade_off()} para apagar la pantalla no resulta
necesario.

{/}

Todos los programas terminarán su ejecución si se pulsa la combinación
de teclas {[ALT]+[X]} en cualquier momento; esto resulta similar a
forzar la ejecución de la función {exit()}, sólo que sin mensaje y con
el código de retorno 0.

{/}Ver: {#129,let_me_alone()} - {#111,fade_off()}

# ─────────────────────────────────────────────────────────────────────────────

{.110,fade()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fade(}<% red>{,} <% green>{,} <% blue>{,} <velocidad>{)}

{Descripción:}

Inicia un fundido de los colores de la paleta del juego hasta que se alcancen
los porcentajes de visualización (desde 0% hasta 200%) de las componentes
{red} (rojo), {green} (verde) y {blue} (azul) que se indican como parámetros.

El último parámetro indica la velocidad a la que se va a realizar el fundido
de colores, normalmente se define un número desde 1 (muy lentamente) hasta
10 (muy rápidamente).

Si se indica como velocidad un número mayor o igual que 64, el fundido se
realizará de forma instantánea.

El fundido se irá realizando gradualmente en las sucesivas visualizaciones
del juego (en los siguientes fotogramas).

Si se ponen las tres componentes a 0 se hará un fundido a negro, si se ponen
a 200 se hará un fundido a blanco, y si se ponen a 100 se recuperarán los
colores originales de la paleta del juego.

Un valor inferior a 100 en una componente apagará su color, mientras que un valor superior
a 100, saturará el color.

Se recuerda que el fundido no se realiza al ejecutarse la función {fade()},
sino en las siguientes sentencias {#1029,FRAME}. Mientras se está realizando
un fundido la variable global predefinida {#1107,fading} valdrá {cierto}
(un número impar que en este caso será 1) y cuando se termine el fundido
(se alcancen finalmente los valores de visualización de color establecidos),
esta variable pasará a valer {falso} (un numero par, el número 0).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_fade;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write (0, 0, 0, 0, "Pulsa [ESPACIO] para ir realizando los efectos.");
    LOOP
        IF (NOT fading AND key(_space))

            fade(rand(0, 200), rand(0, 200), rand(0, 200), 5);

        END
        FRAME;
    END
END
{-}

En el ejemplo se carga una pantalla como fondo y se imprime un mensaje;
después, cada vez que se pulse la barra espaciadora, si no se está
realizando un fundido ({IF (NOT fading ...}), se iniciará uno con la
función {fade()} con las tres componentes de color elegidas al azar
entre 0% y 200% (con la función {#149,rand()}) y a velocidad 5.

{/}Ver: {#1107,fading} - {#111,fade_off()} - {#112,fade_on()} - {#133,load_pal()}

# ─────────────────────────────────────────────────────────────────────────────

{.111,fade_off()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fade_off()}

{Descripción:}

Realiza un fundido de los colores de la pantalla a negro. Se detiene el juego
tal y como está hasta que la pantalla quede negra por completo. Realizar un
fundido a negro se denomina {apagar la pantalla}.

Para volver a encender la pantalla (deshacer el fundido a negro) se utiliza
la función {#112,fade_on()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_fade_off;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write (0, 0, 0, 0, "Pulsa [ESPACIO] para apagar y encender la pantalla.");
    LOOP
        WHILE (NOT key(_space))
            FRAME;
        END

        fade_off(); // Apagamos la pantalla

        fade_on();
    END
END
{-}

En el ejemplo se pone una pantalla de fondo y después se espera
a que se pulse la barra espaciadora para apagar y encender la pantalla.

La función {#110,fade()} puede realizar esta misma función sin detener
el programa o a distintas velocidades, además de poder realizar otros
efectos de paleta más avanzados.

{/}Ver: {#110,fade()} - {#112,fade_on()}

# ─────────────────────────────────────────────────────────────────────────────

{.112,fade_on()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fade_on()}

{Descripción:}

Realiza un fundido de los colores de pantalla hasta su situación natural.
En las sucesivas visualizaciones del juego (al llegar la sentencia {#1029,FRAME})
los colores irán recuperando su visibilidad hasta verse perfectamente.
A esta acción se la denomina {encender la pantalla}.

Para apagar la pantalla (hacer un fundido a negro) se utiliza
la función {#111,fade_off()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_fade_off;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write (0, 0, 0, 0, "Pulsa [ESPACIO] para apagar y encender la pantalla.");
    LOOP
        WHILE (NOT key(_space))
            FRAME;
        END
        fade_off();

        fade_on(); // Se enciende la pantalla

    END
END
{-}

En el primer ejemplo se pone una pantalla de fondo y después se espera a que
se pulse la barra espaciadora para apagar y encender la pantalla.

La función {#110,fade()} puede realizar esta misma función a distintas
velocidades, además de poder realizar otros efectos de paleta más avanzados.

{/}

Todos los juegos realizan de forma automática un {fade_on()} al comienzo
de la ejecución.

{/}Ver: {#110,fade()} - {#111,fade_off()}

# ─────────────────────────────────────────────────────────────────────────────

{.113,fget_angle()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fget_angle(}<x0>{,} <y0>{,} <x1>{,} <y1>{)}

{Retorna:}

El ángulo entre dos puntos.

{Descripción:}

Devuelve el ángulo que hay desde el {punto 0} (x0, y0) hasta el {punto 1}
(x1, y1).

Se recuerda que el ángulo se especifica en milésimas de grado. La función
devuelve siempre un valor entre{ -180000} y {180000} (un ángulo entre -180 y
180 grados).

Como coordenadas de ambos puntos (x0, y0, x1, y1) se puede especificar
cualquier expresión numérica válida.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_fget_angle;

PRIVATE
    coordenada_x0, coordenada_y0;
    coordenada_x1, coordenada_y1;
    resultado;
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    write(0, 0, 0, 0, "Coordenadas punto 1");
    write(0, 0, 10, 0, "X:");
    write_int(0, 20, 10, 0, offset coordenada_x0);
    write(0, 0, 20, 0, "Y:");
    write_int(0, 20, 20, 0, offset coordenada_y0);
    write(0, 0, 40, 0, "Coordenadas punto 2");
    write(0, 0, 50, 0, "X:");
    write_int(0, 20, 50, 0, offset coordenada_x1);
    write(0, 0, 60, 0, "Y:");
    write_int(0, 20, 60, 0, offset coordenada_y1);
    write(0, 0, 80, 0, "Angulo del punto 1 al punto 2:");
    write_int(0, 0, 90, 0, offset resultado);
    write(0, 0, 200, 6, "Pulsa [ESPACIO] para hallar otros dos puntos.");
    LOOP
        clear_screen();
        coordenada_x0=rand(0, 319);
        coordenada_y0=rand(0, 199);
        coordenada_x1=rand(0, 319);
        coordenada_y1=rand(0, 199);
        put(fichero1,200,coordenada_x0, coordenada_y0);
        put(fichero1,200,coordenada_x1, coordenada_y1);

        //Hallamos el ángulo entre los dos puntos
        resultado = fget_angle(coordenada_x0, coordenada_y0, coordenada_x1, coordenada_y1);

        scan_code=0;
        WHILE (scan_code<>_space)
            FRAME;
        END
    END
END
{-}

En el ejemplo, después de poner los mensajes necesarios, se hallan las
coordenadas {x} e {y} de dos puntos hallados al azar y se guardan en las
variables destinadas para ello, calculando con la función {fget_angle()}
el ángulo entre dichos puntos. Cada vez que se pulse la barra espaciadora
se repetirá el proceso.

La función {#116,get_angle()} se utiliza para obtener el {ángulo de un proceso
a otro}, en lugar de entre dos puntos.

La función {#114,fget_dist()} se utiliza para obtener la {distancia entre dos
puntos}, en lugar del ángulo.

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#116,get_angle()} - {#114,fget_dist()}

# ─────────────────────────────────────────────────────────────────────────────

{.114,fget_dist()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fget_dist(}<x0>{,} <y0>{,} <x1>{,} <y1>{)}

{Retorna:}

La distancia entre dos puntos.

{Descripción:}

Devuelve la distancia que hay desde el {punto 0} (x0, y0) hasta el {punto 1}
(x1, y1).

Como coordenadas de ambos puntos (x0, y0, x1, y1) se puede especificar
cualquier expresión numérica válida.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_fget_dist;

PRIVATE
    coordenada_x0, coordenada_y0;
    coordenada_x1, coordenada_y1;
    resultado;
    fichero1;

BEGIN

    fichero1=load_fpg("help\help.fpg");
    write(0, 0, 0, 0, "Coordenadas punto 1");
    write(0, 0, 10, 0, "X:");
    write_int(0, 20, 10, 0, offset coordenada_x0);
    write(0, 0, 20, 0, "Y:");
    write_int(0, 20, 20, 0, offset coordenada_y0);
    write(0, 0, 40, 0, "Coordenadas punto 2");
    write(0, 0, 50, 0, "X:");
    write_int(0, 20, 50, 0, offset coordenada_x1);
    write(0, 0, 60, 0, "Y:");
    write_int(0, 20, 60, 0, offset coordenada_y1);
    write(0, 0, 80, 0, "Distancia entre el punto 1 y el punto 2");
    write_int(0, 0, 90, 0, offset resultado);
    write(0, 0, 200, 6, "Pulsa [ESPACIO] para hallar otra distancia.");
    LOOP
        clear_screen();
        coordenada_x0=rand(0, 319);
        coordenada_y0=rand(0, 199);
        coordenada_x1=rand(0, 319);
        coordenada_y1=rand(0, 199);
        put(fichero1,200,coordenada_x0, coordenada_y0);
        put(fichero1,200,coordenada_x1, coordenada_y1);

        //Hallamos la distancia que hay entre los dos puntos
        resultado = fget_dist(coordenada_x0, coordenada_y0, coordenada_x1, coordenada_y1);

        scan_code=0;
        WHILE (scan_code<>_space)
            FRAME;
        END
    END
END
{-}

En el ejemplo, después de poner los mensajes necesarios se guardan las
coordenadas de dos puntos hallados aleatoriamente en las variables
definidas para tal efecto, obteniendo la distancia entre ellos con la
función {fget_dist()}. Cada vez que se pulse la barra espaciadora se
repetirá el proceso.

La función {#116,get_dist()} se utiliza para obtener la {distancia de un proceso
a otro}, en lugar de entre dos puntos.

La función {#114,fget_angle()} se utiliza para obtener el {ángulo entre dos
puntos}, en lugar de la distancia.

{/}

Esta función se puede utilizar para detectar choques entre procesos por
proximidad entre ellos, si bien suele utilizarse para ello la función
{#104,collision()} que detecta cuando dos procesos tienen sus gráficos
superpuestos.

Por ejemplo, con los procesos visualizados dentro de una ventana de modo-7
(ver {#162,start_mode7()}) no se puede utilizar la función {#104,collision()}
debiéndose obtener la distancia entre los procesos (normalmente con
{#116,get_dist()}) para comprobar si chocan (si su distancia es menor que
una determinada).

{/}Ver: {#117,get_dist} - {#113,fget_angle} - {#104,collision()}

# ─────────────────────────────────────────────────────────────────────────────

{.115,frame_fli()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{frame_fli()}

{Retorna:}

{Cierto} si la animación continúa y {falso} si ha terminado.

{Descripción:}

Muestra la siguiente imagen de una animación {FLI/FLC} iniciada con la función
{#161,start_fli()}. Esta función devuelve {0} si terminó ya la animación.

Durante la ejecución del programa, únicamente se podrá ejecutar una animación
{FLI/FLC} a la vez, es decir, no se podrán tener dos animaciones ejecutándose
al mismo tiempo.

La imagen de la animación se verá sólo en la siguiente imagen del juego
(cuando llegue la sentencia {#1029,FRAME}), por lo que si se realiza un
bucle, dentro del cual se llama a la función {frame_fli()} pero no a la
sentencia {#1029,FRAME}, no se visualizará la animación en pantalla.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_frame_fli;
BEGIN
    start_fli("help\help.fli", 0, 0);
    LOOP

        frame_fli(); // Mostramos la siguiente imagen

        FRAME;
    END
END
{-}

En el ejemplo, se carga la animación {FLI/FLC} y luego se ejecuta indefinidamente
con la función {frame_fli()}.

{/}Ver: {#161,start_fli()} - {#153,reset_fli()} - {#108,end_fli()}

# ─────────────────────────────────────────────────────────────────────────────

{.116,get_angle()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_angle(}<código identificador>{)}

{Retorna:}

El ángulo hacia otro proceso.

{Descripción:}

Devuelve el ángulo desde el proceso actual (el que llamó a esta función) hasta
el proceso cuyo {#1039,código identificador} se le pasa como parámetro.

Ver {#1038,formas de obtener el código identificador}, para más información.

Se recuerda que el ángulo se especifica en milésimas de grado. La función
devuelve siempre un valor entre{ -180000} y {180000} (un ángulo entre -180 y
180 grados).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_angle;

PRIVATE
    ángulo_resultante;
    identificador_proceso;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    graph=100;
    x=160;
    y=100;

    identificador_proceso = proceso_móvil(80, 50, 101);

    write(0, 160, 200, 7, "Use los cursores para mover el triángulo.");
    write(0, 0, 0, 0, "Angulo desde la bola hacia el triángulo:");
    write_int(0, 0, 10, 0, offset ángulo_resultante);
    LOOP

        // Hallamos el ángulo entre los dos procesos
        ángulo_resultante = get_angle(identificador_proceso);

        FRAME;
    END
END

PROCESS proceso_móvil(x, y, graph);
BEGIN
    LOOP
        IF (key(_right)) angle-=10000; END
        IF (key(_left)) angle+=10000; END
        IF (key(_up)) advance(4); END
        FRAME;
    END
END
{-}

Al inicio se pone el fondo de pantalla y el programa principal define
su gráfico como una bola situada en el centro de la pantalla.

Despúes, se crea un proceso del tipo {proceso_móvil} del cual se coge el
{#1039,código identificador}, que se puede controlar con
los cursores.

Dentro del bucle principal se calcula y muestra continuamente en pantalla
el ángulo entre los dos procesos.

La función {#113,fget_angle()} se utiliza para obtener el {ángulo entre dos
puntos}, en lugar de entre dos procesos. Si el {#1039,código identificador}
del proceso se tiene, por ejemplo, en una variable denominada {id2}, entonces
la llamada a la función:

    {get_angle(id2)}

Sería equivalente a:

    {fget_angle(x, y, id2.x, id2.y)}

Obtener el ángulo desde las coordenadas (x, y) del proceso actual, hasta las
coordenadas (x, y) del proceso cuyo {#1039,código identificador} es {id2}.

La función {#117,get_dist()} se utiliza para obtener la {distancia hasta otro
proceso}, en lugar del ángulo.

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#113,fget_angle()} - {#117,get_dist()}

# ─────────────────────────────────────────────────────────────────────────────

{.117,get_dist()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_dist(}<código identificador>{)}

{Retorna:}

La distancia hasta otro proceso.

{Descripción:}

Devuelve la distancia desde el proceso actual (el que llamó a esta función) hasta
el proceso cuyo {#1039,código identificador} se le pasa como parámetro.

Ver {#1038,formas de obtener el código identificador}, para más información.

Si el proceso ha definido su variable local {#1135,resolution} es importante
que el proceso hasta el que se quiere obtener la distancia la tenga definida
al mismo valor. Es decir, si ambos procesos manejan las coordenadas en
centésimas en lugar de unidades (con {#1135,resolution}=100), la distancia
entre ambos también se obtendrá en centésimas, pero si el valor de dicha
variable difiere en ambos procesos, el resultado de la función {get_dist()}
carecerá de sentido.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_dist;

PRIVATE
    distancia_resultante;
    identificador_proceso;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    graph=100;
    x=160;
    y=100;

    identificador_proceso = proceso_móvil(80, 50, 101);

    write(0, 160, 200, 7, "Use los cursores para mover el triángulo.");
    write(0, 0, 0, 0, "Distancia desde la bola hasta el triángulo:");
    write_int(0, 0, 10, 0, offset distancia_resultante);
    LOOP

        // Hallamos la distancia entre los dos procesos
        distancia_resultante = get_dist(identificador_proceso);

        FRAME;
    END
END

PROCESS proceso_móvil(x, y, graph)
BEGIN
    LOOP
        IF (key(_right)) angle-=10000; END
        IF (key(_left)) angle+=10000; END
        IF (key(_up)) advance(4); END
        FRAME;
    END
END
{-}

Al inicio se pone el fondo de pantalla y el programa principal define
su gráfico como una bola situada en el centro de la pantalla.

Despúes se crea un proceso del tipo {proceso_móvil} del cual se coge el
{#1039,código identificador}, que se puede controlar con
los cursores.

Dentro del bucle principal se calcula y muestra continuamente en pantalla
la distancia entre los dos procesos.

La función {#114,fget_dist()} se utiliza para obtener la {distancia entre dos
puntos}, en lugar de entre dos procesos. Si el {#1039,código identificador}
del proceso se tiene, por ejemplo, en una variable denominada {id2}, entonces
la llamada a la función:

    {get_dist(id2)}

Sería equivalente a:

    {fget_dist(x, y, id2.x, id2.y)}

Obtener la distancia desde las coordenadas (x, y) del proceso actual hasta las
coordenadas (x, y) del proceso cuyo {#1039,código identificador} es {id2}.

La función {#116,get_angle()} se utiliza para obtener el {ángulo hasta otro
proceso}, en lugar de la distancia.

{/}

Esta función se puede utilizar para detectar choques entre procesos por
proximidad entre ellos, aunque se suele utilizar para ello la función
{#104,collision()} que detecta cuándo dos procesos tienen sus gráficos
superpuestos.

Por ejemplo, con los procesos visualizados dentro de una ventana de modo-7
(ver {#162,start_mode7()}) no se puede utilizar la función {#104,collision()}
debiéndose obtener la distancia entre los procesos para comprobar si chocan
(si su distancia es menor que una determinada).

{/}Ver: {#114,fget_dist()} - {#116,get_angle()} - {#118,get_distx()} - {#119,get_disty()}

# ─────────────────────────────────────────────────────────────────────────────

{.118,get_distx()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_distx(}<ángulo>{,} <distancia>{)}

{Retorna:}

El desplazamiento horizontal del vector (ángulo, distancia).

{Descripción:}

Devuelve distancia horizontal (en el eje de la coordenada {x}) a partir del
ángulo y {distancia} (sobre ese ángulo) pasados como parámetros. Es decir,
devuelve la distancia que recorre en horizontal el vector formado por el
ángulo y {longitud} (distancia o módulo del vector) indicados.

Se recuerda que el ángulo se especifica en milésimas de grado y como
distancia se puede especificar cualquier expresión numérica válida.

La función utilizada para calcular la distancia vertical, en lugar de la
horizontal, es {#119,get_disty()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_distx;

GLOBAL
    distancia;
    distancia_horizontal;
    distancia_vertical;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 3);
    write(0, 160, 200, 7, "Utilice los cursores para mover el triángulo.");
    write(0, 0, 0, 0, "Distancia horizontal:");
    write_int(0, 0, 10, 0, offset distancia_horizontal);
    graph=101;
    LOOP
        IF (key(_up)) distancia+=2; END
        IF (key(_down)) distancia-=2; END
        IF (key(_right)) angle-=2000; END
        IF (key(_left)) angle+=2000; END

        // Calculamos la distancia horizontal
        distancia_horizontal = get_distx(angle, distancia);

        distancia_vertical = get_disty(angle, distancia);
        x=160+distancia_horizontal;
        y=100+distancia_vertical;
        FRAME;
    END
END
{-}

En el ejemplo se pone como fondo de la pantalla una gráfica circular,
sobre la que se manejará con los cursores un triángulo, modificando
su distancia y ángulo al centro de la gráfica.

El programa calcula la distancia horizontal y vertical para emplazar el
triángulo a partir de las coordenadas del centro de pantalla
(160, 100), mostrándose en todo momento la distancia horizontal en la esquina
superior izquierda.

{/}

Si se quiere avanzar las coordenadas del proceso una {distancia} en un
ángulo determinado, se pueden utilizar las siguientes sentencias:

  {x+=get_distx(}<ángulo>{,} <distancia>{);}·
  {y+=get_disty(}<ángulo>{,} <distancia>{);}·

Si el ángulo en el que se quiere mover el proceso es el que tiene en su
variable local {#1129,angle}, entonces esta misma operación se podría
realizar con la función {#101,advance()} de la siguiente forma:

  {advance(}<distancia>{);}

{/}

La función {get_distx()} equivale a calcular el {coseno} del ángulo y
multiplicarlo por la {distancia}.

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#119,get_disty()} - {#101,advance()}

# ─────────────────────────────────────────────────────────────────────────────

{.119,get_disty()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_disty(}<ángulo>{,} <distancia>{)}

{Retorna:}

El desplazamiento vertical del vector (ángulo, distancia).

{Descripción:}

Devuelve distancia vertical (eje de la coordenada {y}) a partir del ángulo y
{distancia} (sobre ese ángulo) pasados como parámetros. Es decir,
devuelve la distancia que recorre en vertical el vector formado por el
ángulo y {longitud} (distancia) indicados.

Se recuerda que el ángulo se especifica en milésimas de grado y como
distancia se puede especificar cualquier expresión numérica válida.

La función utilizada para calcular la distancia horizontal, en lugar de la
vertical, es {#119,get_distx()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_disty;

GLOBAL
    distancia;
    distancia_horizontal;
    distancia_vertical;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 3);
    write(0, 160, 200, 7, "Utilice los cursores para mover el triángulo.");
    write(0, 0, 0, 0, "Distancia vertical:");
    write_int(0, 0, 10, 0, offset distancia_vertical);
    graph=101;
    LOOP
        IF (key(_up)) distancia+=2; END
        IF (key(_down)) distancia-=2; END
        IF (key(_right)) angle-=2000; END
        IF (key(_left)) angle+=2000; END

        // Calculamos la distancia vertical
        distancia_vertical = get_disty(angle, distancia);

        distancia_horizontal = get_distx(angle, distancia);
        x=160+distancia_horizontal;
        y=100+distancia_vertical;
        FRAME;
    END
END
{-}

En el ejemplo se pone como fondo de la pantalla una gráfica circular,
sobre la que se manejará con los cursores un triángulo, modificando
su distancia y ángulo al centro de la gráfica.

El programa calcula la distancia horizontal y vertical para emplazar el
triángulo a partir de las coordenadas del centro de pantalla
(160, 100), mostrándose en todo momento la distancia vertical en la esquina
superior izquierda.

{/}

Si se quiere avanzar las coordenadas del proceso una {distancia} en un
ángulo determinado, se pueden utilizar las siguientes sentencias:

  {x+=get_distx(}<ángulo>{,} <distancia>{);}·
  {y+=get_disty(}<ángulo>{,} <distancia>{);}·

Si el ángulo en el que se quiere mover el proceso es el que tiene en su
variable local {#1129,angle}, entonces esta misma operación se podría
realizar con la función {#101,advance()} de la siguiente forma:

  {advance(}<distancia>{);}

{/}

La función {get_disty()} equivale a calcular el {seno} del ángulo y multiplicarlo
por la {distancia}, cambiando este resultado de signo, debido a que el
eje {Y} de pantalla avanza hacia abajo (de manera contraria a la función seno).

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#118,get_distx()} - {#101,advance()}

# ─────────────────────────────────────────────────────────────────────────────

{.120,get_id()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_id(}<tipo de proceso>{)}

{Retorna:}

El {#1039,código identificador} de un proceso o {0}.

{Descripción:}

Comprueba si hay procesos del tipo especificado activos. En caso afirmativo,
esta función devolverá el {#1039,código identificador} de uno de ellos y,
en el caso contrario, devolverá un 0.

Si existen varios procesos del tipo que se ha
especificado, la función {get_id()} devolverá el resto de los
identificadores en las sucesivas llamadas que se realicen a la misma.

Una vez se hayan devuelto todos los {#1039,códigos identificadores}, la función
devolverá 0, hasta que se vuelva a ejecutar una sentencia {#1029,FRAME}, momento
a partir del cual esta función devolverá, de nuevo, todos los códigos
identificadores de los procesos del tipo indicado.

Para obtener de esta forma todos los {#1039,códigos identificadores} de los
procesos no se debe utilizar la sentencia {#1029,FRAME}
entre dos llamadas consecutivas a la sentencia {get_id()}. En el caso de
ejecutar una sentencia {#1029,FRAME}, esta función volverá a
retornar todos los {#1039,códigos identificadores} de procesos desde el primero.

Algo similar sucede si se ejecuta una llamada a la función especificando un
tipo de proceso diferente; si tras esto se vuelven a pedir identificadores
del tipo de proceso anterior, esta función también los volverá a retornar todos
desde el primero.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_id;

PRIVATE
    identificador_proceso;
    contador;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    FROM contador=1 TO 20;
        proceso_móvil(rand(0, 319), rand(0, 199), 101);
    END
    LOOP
        FROM contador=1 TO 20;

            // Cogemos los identificadores de los procesos
            identificador_proceso = get_id(TYPE proceso_móvil);

            identificador_proceso.angle+=rand(-5000, 5000);
        END
        FRAME;
    END
END

PROCESS proceso_móvil(x, y, graph);
BEGIN
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo, después de cargar el fichero de gráficos y poner la pantalla
de fondo, se crean 20 procesos tipo {proceso_móvil} con sus posiciones
elegidas aleatoriamente y un triángulo como su gráfico.

Estos procesos únicamente ejecutarán sentencias {#1029,FRAME} dentro de
un bucle, para visualizarse.

Desde el programa principal se van cogiendo los identificadores de los procesos
tipo {proceso_móvil} con la función {get_id()} (guardándolos en la variable
{identificador_proceso}) y utilizándolos para modificarles el ángulo (su
variable local {#1129,angle}).

Al disponer del {#1039,código identificador} de un proceso se pueden
consultar o modificar sus variables locales (como {#1129,angle} en este ejemplo)
o bien enviar señales al proceso con la función {#158,signal()}.

{/}

La función {#104,collision()} sirve para obtener los {#1039,códigos identificadores}
de procesos de un tipo determinado que, además, colisionen (choquen) con el
proceso actual.

{/}Ver: {#1038,Formas de obtener el código identificador} - {#1042,Tipos de procesos} - {#1039,Códigos identificadores}

# ─────────────────────────────────────────────────────────────────────────────

{.121,get_joy_button()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_joy_button(}<número de botón>{)}

{Retorna:}

{Cierto} (1) si el botón está pulsado, {Falso} (0) si no lo está.

{Descripción:}

Esta función requiere como parámetro el número de botón del joystick
(de 0 a 3), y devuelve {cierto} (un valor numérico impar) si está pulsado en
ese momento.

Si el botón no está pulsado, la función devuelve {falso}
(un valor numérico par).

Algunos joystick únicamente tienen 2 botones; en este caso serán los botones
número 0 y 1. En ordenadores con dos joystick conectados, el segundo joystick
tendrá los botones número 2 y 3.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_joy_button;

PRIVATE
    contador;
    botones[3];

BEGIN
    write(0, 160, 200, 7," Pulse los botones del joystick.");
    write(0, 0, 0, 0, "Botones (0..3):");
    write_int(0, 100, 0, 0, offset botones[0]);
    write_int(0, 120, 0, 0, offset botones[1]);
    write_int(0, 140, 0, 0, offset botones[2]);
    write_int(0, 160, 0, 0, offset botones[3]);
    LOOP
        FROM contador=0 TO 3;

            // Cogemos el valor del botón del joystick
            botones[contador] = get_joy_button(contador);

        END
        FRAME;
    END
END
{-}

Se imprime un mensaje explicativo en la parte inferior y el estado
de los cuatro posibles botones en la parte superior; después, el programa
se queda dentro de un bucle actualizando continuamente el estado de los
cuatro botones con la función {get_joy_button()}.

{/}

Hay otras formas de utilizar el joystick. La más sencilla es utilizar
la estructura {#1103,joy}, ya que en ésta hay cuatro registros que
indican continuamente el estado de los botones del joystick.

{/}Ver: {#122,get_joy_position()} - {#1103,Estructura joy}

# ─────────────────────────────────────────────────────────────────────────────

{.122,get_joy_position()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_joy_position(}<número de eje>{)}

{Retorna:}

La posición del eje del joystick.

{Descripción:}

Esta función devuelve la coordenada en la que se encuentra el eje indicado
(con un número del {0} al {3}) del joystick analógico.

Eje {0} - Eje {X} principal.·
Eje {1} - Eje {Y} principal.·
Eje {2} - Eje {X} secundario.·
Eje {3} - Eje {Y} secundario.·

La coordenada del joystick puede variar en función del tipo de joystick y del
ordenador en el que se ejecute, aún así es un número que suele variar entre
{4} y {200}, aproximadamente.

Los ejes {principal} y {secundario} pueden estar integrados en un solo joystick,
en algunos casos (mandos de vuelo con un {hat}, {pedales}, etc.). En ordenadores
que tengan dos joystick conectados, el eje principal será el joystick 1 y el
secundario el 2.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_joy_position;

PRIVATE
    eje_joystick[3];
    contador;

BEGIN
    write (0, 160, 200, 7, "Mueva el joystick");
    write (0, 0, 0, 0, "Coordenada X principal.");
    write_int(0, 0, 10, 0, offset eje_joystick[0]);
    write (0, 0, 40, 0, "Coordenada Y principal.");
    write_int(0, 0, 50, 0, offset eje_joystick[1]);
    write (0, 0, 80, 0, "Coordenada X secundaria.");
    write_int(0, 0, 90, 0, offset eje_joystick[2]);
    write (0, 0, 120, 0, "Coordenada Y secundaria.");
    write_int(0, 0, 130, 0, offset eje_joystick[3]);
    LOOP
        FROM contador=0 TO 3;

            // Cogemos el valor de los ejes del joystick
            eje_joystick[contador] = get_joy_position(contador);

        END
        FRAME;
    END
END
{-}

Primero se imprimen los mensajes y, después, el programa
se queda dentro de un bucle actualizando de forma continua el estado de los
cuatro ejes con la función {get_joy_button()} (que, en este caso, se
guardan en la tabla privada {eje_joystick}).

{/}

Hay otras formas de utilizar el joystick. La más sencilla es utilizar
la estructura {#1103,joy} cuando no se requiera una lectura analógica
del joystick (sus coordenadas), es decir, cuando baste con saber si el
joystick está en el centro, a la derecha, abajo, etc.

{/}Ver: {#121,get_joy_button()} - {#1103,Estructura joy}

# ─────────────────────────────────────────────────────────────────────────────

{.123,get_pixel()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_pixel(}<x>{,} <y>{)}

{Retorna:}

El color del punto (0..255).

{Descripción:}

Devuelve el color que tiene el punto del {fondo de la pantalla}
que está en las coordenadas indicadas como parámetros.

El número devuelto es el orden dentro de la paleta de colores activa en el
programa, entre 0 y 255, ya que las paletas tienen 256 colores.

El punto se toma únicamente del dibujo de fondo de la pantalla, sin tener en
cuenta los gráficos de los procesos, textos, regiones de scroll, etc., es
decir, sólo se leerán los colores puestos por las funciones {#146,put()},
{#173,xput()}, {#147,put_pixel()} y {#148,put_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_pixel;

PRIVATE
    color_punto;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 2);
    mouse.graph=200;
    write (0, 0, 190, 0, "Color del punto del fondo de pantalla:");
    write_int(0, 256, 190, 0, offset color_punto);
    LOOP

        // Cogemos el color del punto del fondo de la pantalla
        color_punto = get_pixel(mouse.x, mouse.y);

        FRAME;
    END
END
{-}

En el ejemplo, se pone el fondo de pantalla con la función {#148,put_screen},
como una serie de cuadrículas de distintos colores y se asigna una cruz como
puntero del ratón.

Después se mostrará en la parte inferior de la pantalla el color que está
en la posición señalada con el ratón, leyendo éste con la función {get_pixel()}
en cada iteración del bucle principal del programa.

{/}Ver: {#147,put_pixel()} - {#136,map_get_pixel()} - {#138,map_put_pixel()} - {#124,get_point()}

# ─────────────────────────────────────────────────────────────────────────────

{.124,get_point()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_point(}<fichero>{,} <gráfico>{,} <número>{,} <OFFSET x>{,} <OFFSET y>{)}

{Retorna:}

La posición del punto de control (en las variables cuyo {#1085,offset} se
indica como los dos últimos parámetros).

{Descripción:}

Esta función devuelve donde se situó en un {gráfico} (del {fichero} indicado)
el punto de control cuyo {número} se indica como tercer parámetro.

Un {#1136,punto de control} es un punto que se puede definir en el
editor de gráficos (herramienta de dibujo), en la opción habilitada para
dicha función.

La función necesita la {dirección} (que se obtiene con el operador {#1085,offset})
en la memoria del ordenador {de dos variables} en las que devolverá la posición
{x} e {y} del punto de control.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_point;

GLOBAL
    fichero1;
    punto=1;
    x_punto;
    y_punto;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    put_screen(0, 4);
    graph=101;
    LOOP
        IF (fget_dist(x, y, x_punto, y_punto)<6)
            IF (punto++==50) punto=1; END
        END

        // Cogemos el punto de control
        get_point(fichero1, 4,punto, offset x_punto, offset y_punto);

        angle=fget_angle(x, y, x_punto, y_punto);
        advance(6);
        FRAME;
    END
END
{-}

En el ejemplo se pone como fondo un dibujo con un circuito que
recorre la pantalla; este dibujo (el gráfico {4} del fichero) tiene definidos
50 {#1136,puntos de control} (del 1 al 50) a lo largo del recorrido del circuito.

El proceso principal aparece como un triángulo que va recorriendo el circuito.

Esto se consigue teniendo en la variable {punto} el número del punto de control
al que se debe dirigir el triángulo, en un principio el punto número 1.

Las coordenadas de cada punto de control, obtenidas con la función {get_point()},
se guardan en las variables {x_punto} e {y_punto} y sirven para que el proceso
se dirija hacia esa posición con las funciones {#113,fget_angle()}
(para obtener en la variable {angle} el ángulo hacia el punto) y
{#101,advance()} (para avanzar 6 puntos en esa dirección).

Cuando se está cerca del punto de control, lo que se comprueba con la
función {#114,fget_dist()}, es si se incrementa el número de punto, para
dirigir el triángulo hacia el siguiente (cuando se haya alcanzado el punto
número 50, se volverá al 1).

{/}

Esta función devuelve las coordenadas exactas en las que fue colocado
ese punto de control dentro del gráfico, sin importar cómo esté dicho
gráfico ahora (escalado, rotado, etc.). Para poder obtener la posición
de un punto de control en un gráfico escalado, rotado, etc. y relativa
a las coordenadas de pantalla (y no del gráfico original) se debe
emplear la función {#125,get_real_point()}.

Es decir, esta última función devuelve dónde está en un momento determinado
un punto de control, y {get_point()} devuelve dónde fue emplazado originalmente.

{/}Ver: {#1136,Puntos de control} - {#125,get_real_point()} - {#123,get_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.125,get_real_point()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{get_real_point(}<número>{,} <OFFSET x>{,} <OFFSET y>{)}

{Retorna:}

Las coordenadas actuales del punto de control (en las variables cuyo
{#1085,offset} se indica como los dos últimos parámetros).

{Descripción:}

Esta función devuelve donde está en ese instante un punto de control
del gráfico del proceso actual en el sistema de coordenadas utilizado por
el propio proceso (ver variable local {#1122,ctype}), evaluando la ubicación
original del punto, las coordenadas actuales del proceso, su tamaño, ángulo,
etc.

Un {#1136,punto de control} es un punto que se puede definir en el
editor de gráficos (herramienta de dibujo), en la opción habilitada
para dicha función.

La función necesita la {dirección} (que se obtiene con el operador {#1085,offset})
en la memoria del ordenador {de dos variables} en las que devolverá la posición
{x} e {y} del punto de control.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_get_real_point;

PRIVATE
    punto;
    x_punto;
    y_punto;

BEGIN
    load_fpg("help\help.fpg");
    graph=4;
    x=160;
    y=100;
    LOOP
        FROM punto=1 TO 50;

            // Cogemos las coordenadas de donde está ahora el punto de control
            get_real_point(punto, offset x_punto, offset y_punto);

            proceso_marcador(x_punto, y_punto, 200);
        END
        angle+=1000;
        FRAME;
    END
END

PROCESS proceso_marcador(x, y, graph);
BEGIN
    FRAME;
END
{-}

En el ejemplo se define cómo gráfico del proceso principal un circuito que
recorre la pantalla. Este gráfico tiene definidos 50 {#1136,puntos de control}
(del 1 al 50).

El programa se queda en un bucle dentro del cual va rotando este gráfico
(sumándole un grado con la sentencia {angle+=1000;}) y creando 50 procesos
en forma de cruz, una en cada uno de los puntos de control del gráfico.

Se puede comprobar cómo la posición relativa de los puntos de control no
varía aunque el gráfico del circuito rote.

{/}

Esta función se suele utilizar para tener localizados algunos puntos
importantes de un gráfico. Por ejemplo, si se ha definido un proceso cuyo
gráfico es un hombre con una pistola que pueda escalarse, rotarse o realizar
diversas animaciones, podría definirse un punto de control en la punta
del cañón de la pistola para saber en cada momento de dónde deben salir
las balas en caso de que dispare.

Si el gráfico original estaba dentro de una región de scroll (ver
{#163,start_scroll()}) las coordenadas devueltas también serán relativas
a dicha región de scroll.

{/}

La función {#124,get_point()} devuelve dónde fue emplazado originalmente
un punto de control en el gráfico, en lugar de su posición actual,
como {get_real_point()}.

{/}Ver: {#1136,Puntos de control} - {#124,get_point()} - {#123,get_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.126,graphic_info()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{graphic_info(}<fichero>{,} <gráfico>{,} <información>{)}

{Retorna:}

La información solicitada sobre el gráfico.

{Descripción:}

Devuelve la información que se le solicita de un {gráfico} de un {fichero}.

Información:

{g_wide} - La función devolverá el {ancho original} de dicho gráfico si se pone
g_wide como tercer parámetro.

{g_height} - La función devolverá el {alto original} del gráfico.

{g_x_center} - La función devolverá la {coordenada x} del centro del gráfico.

{g_y_center} - La función devolverá la {coordenada y} del centro del gráfico.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_graphic_info;

PRIVATE
    fichero1;
    alto;
    ancho;
    x_centro;
    y_centro;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    put_screen(fichero1, 1);
    graph=100;
    x=160;
    y=100;

    // Cogemos la información sobre el alto del gráfico
    alto = graphic_info(fichero1, 100, g_height);

    // Cogemos la información sobre el ancho del gráfico
    ancho = graphic_info(fichero1, 100, g_wide);

    // Cogemos la información sobre la coordenada x del centro del gráfico
    x_centro = graphic_info(fichero1, 100, g_x_center);

    // Cogemos la información sobre la coordenada y del centro del gráfico
    y_centro = graphic_info(fichero1, 100, g_y_center);

    write(0, 0, 0, 0, "Altura del gráfico:");
    write_int(0, 0, 10, 0, offset alto);
    write(0, 0, 20, 0, "Ancho del gráfico:");
    write_int(0, 0, 30, 0, offset ancho);
    write(0, 0, 40, 0, "Centro horizontal del gráfico:");
    write_int(0, 0, 50, 0, offset x_centro);
    write(0, 0, 60, 0, "Centro vertical del gráfico:");
    write_int(0, 0, 70, 0, offset y_centro);
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo se solicita información sobre el gráfico número 100 del
fichero {help.fpg}, que es una bola de 32 puntos por 32 puntos y con el
centro en (16, 16).

Para obtener esta información será necesario llamar 4 veces a la función
{graphic_info()}, ya que cada vez devuelve un solo valor, en función
del tercer parámetro de llamada (<información>).

{/}Ver: {#1163,g_wide} - {#1164,g_height} - {#1165,g_x_center} - {#1166,g_y_center}

# ─────────────────────────────────────────────────────────────────────────────

{.127,is_playing_cd()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{is_playing_cd()}

{Retorna:}

{Cierto} (1) si está sonando el CD, o {falso} (0) si no está sonando.

{Descripción:}

Esta función sirve para poder determinar si el CD está tocando una canción.

Devuelve {Cierto} (un número impar) si el CD está tocando una canción, en
caso contrario devuelve {Falso} (un número par).

Su uso más generalizado es para poder tocar una canción indefinidamente
como se muestra en el siguiente ejemplo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_is_playing_cd;
BEGIN
    play_cd(1, 0);
    LOOP

        IF (NOT is_playing_cd()) // Comprueba si ya ha finalizado la canción

            play_cd(1, 0);
        END
        FRAME;
    END
END
{-}

El ejemplo anterior (para el cual se necesita tener un {Compact disc} de
música en el cargador de {CD-ROM}) utiliza la función {#144,play_cd()} para
hacer sonar la primera canción del disco.

Después, en un bucle, se comprueba si dicha canción ha terminado de sonar para
volver a lanzarla.

{/}

El volumen de reproducción de cd-audio se puede controlar con la
estructura {#1104,setup} y la función {#178,set_volume()}.

{/}Ver: {#144,play_cd()} - {#164,stop_cd()} - {#178,set_volume()} - {#1104,Estructura setup}

# ─────────────────────────────────────────────────────────────────────────────

{.128,key()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{key(}<código de tecla>{)}

{Retorna:}

{Cierto} (1) si la tecla está pulsada y {falso} (0) si no lo está.

{Descripción:}

Devuelve {cierto} (un número impar) si la tecla, indicada como parámetro,
está pulsada en ese momento; en caso contrario devuelve {falso} (un número
par).

Normalmente el parámetro de entrada será el nombre de la tecla con el
símbolo {_} (subrayado) delante; por ejemplo, para leer la tecla [{A}] se
debe llamar a la función como {key(_a)}.

Acceda a los {#1176,códigos de las teclas} para ver la lista completa de
códigos de teclado que pueden utilizarse como parámetro de la función {key()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_key;
BEGIN
    LOOP
        delete_text(all_text);

        IF (key(_space)) // Comprobamos si está pulsada la barra espaciadora

            write(0, 0, 0, 0, "Está pulsando la tecla [ESPACIO].");
        ELSE
            write(0, 0, 0, 0, "No está pulsando la tecla [ESPACIO].");
        END
        FRAME;
    END
END
{-}

En el ejemplo se imprime un mensaje u otro dependiendo de que la barra
espaciadora esté o no pulsada.

{/}

Hay tres variables globales predefinidas que también pueden utilizarse
para el control del teclado; éstas son:

{#1110,scan_code} - Código de la última tecla que se ha pulsado; éste
es un valor numérico que se corresponde directamente con las constantes
de {#1176,códigos de teclas} utilizadas como parámetros de la función {key()}.

{#1109,ascii} - Código ASCII de la última tecla pulsada.

{#1108,shift_status} - variable que indica un número en función de las
teclas especiales o de bloqueo (shift, alt, control, ...) que estén pulsadas
en dicho momento.

{/}Ver: {#1176,Códigos de teclas} - {#1110,scan_code} - {#1109,ascii} - {#1108,shift_status}

# ─────────────────────────────────────────────────────────────────────────────

{.129,let_me_alone()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{let_me_alone()}

{Descripción:}

Envía una señal {#1153,s_kill} a todos los procesos, excepto el que ejecutó
esta función, lo que eliminará a todos los procesos menos el actual.

Esta función se utiliza, generalmente, desde el proceso principal, cuando
ha finalizado una partida, para eliminar todos los procesos (disparos,
enemigos, etc.) que quedarán activos, y recuperar el control del programa.

Una llamada a {let_me_alone()} se podría sustituir siempre por una serie
de llamadas a la función {#158,signal()} con la señal {#1153,s_kill}, pero para
ello se deberían conocer los tipos de los procesos que se quieren
eliminar, o bien, sus {#1039,códigos identificadores}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_let_me_alone;
BEGIN
    load_fpg("help\help.fpg");
    proceso_nulo(160, 100, 100);
    write (0, 160, 0, 1, "Pulse [ESPACIO] para eliminar el proceso");
    WHILE (NOT key (_space))
        FRAME;
    END

    let_me_alone(); // Se elimina el resto de los procesos

    LOOP
        FRAME;
    END
END

PROCESS proceso_nulo(x, y, graph)
BEGIN
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo, después de crear un proceso de tipo {proceso_nulo}, se espera
a la pulsación de la barra espaciadora para utilizar la función {let_me_alone()}
la cual elimina todos los procesos que hubiera (menos el principal, que es el que
llamó a la función); en este caso se eliminará el proceso de tipo {proceso_nulo}.

{/}

Para poder comprobar los procesos que hay activos en un programa en un
determinado momento se debe acceder al trazador (o debugger) pulsando
la tecla [{F12}].

{/}

La función {#109,exit()} sirve para terminar un programa de forma inmediata,
retornando al sistema.

{/}Ver: {#109,exit()} - {#158,signal()}

# ─────────────────────────────────────────────────────────────────────────────

{.130,load()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load(}<nombre de archivo>{,} <OFFSET dato>{)}

{Descripción:}

Carga un bloque de datos de un archivo en el disco a la memoria del programa.

Para ello la función requiere el {nombre del archivo} y el desplazamiento
dentro de la memoria del ordenador de la variable, tabla o estructura
guardada en el disco (el desplazamiento del dato se puede obtener con
operador {#1085,OFFSET}).

Se debe especificar el desplazamiento del mismo dato que se especificó al
guardar el archivo con la función {#155,save()}.

Los nombres de archivo se pueden dar especificando una ruta de acceso, {que
debe ser la misma que la utilizada con la función} {#155,save()} para guardar
el archivo. No obstante {no es necesario} especificar una ruta.

Es importante que el archivo que se pretende cargar se haya creado
anteriormente, pues se producirá un error si se intenta cargar un archivo
que no existe (si bien éste puede ser ignorado y continuar la ejecución del
programa).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load;

PRIVATE
    tabla[9];
    contador;

BEGIN
    write (0, 0, 0, 0, "Pulse [ENTER] para borrar los datos.");
    write (0, 0, 10, 0, "Pulse [ESPACIO] para cargar los datos del disco");
    write (0, 0, 30, 0, "Valores actuales de los datos:");
    FROM contador=0 TO 9;
        tabla[contador]=rand(0, 100);
        write_int(0, 0, 40+(contador*10), 0, offset tabla[contador]);
    END
    save("help\help.dat", offset tabla, sizeof(tabla));
    LOOP
        IF (key(_enter))
            FROM contador=0 TO 9;
                tabla[contador]=0;
            END
        END
        IF (key(_space))

            load("help\help.dat", offset tabla); // Se cargan los datos del disco

        END
        FRAME;
    END
END
{-}

Al inicio del ejemplo se crea una tabla de 10 posiciones (del 0 al 9)
con valores aleatorios. Esta tabla se graba en el disco con la función
{#155,save()}.

Cuando se pulsa la tecla ENTER se borran los valores de la tabla (se ponen
a 0 las 10 posiciones).

Cuando se pulsa la barra espaciadora se cargan los valores de la tabla
del disco con la función {load()}.

{/}Ver: {#155,save()} - {#1094,sizeof()}

# ─────────────────────────────────────────────────────────────────────────────

{.131,load_fnt()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load_fnt(}<nombre de archivo>{)}

{Retorna:}

El {código de la fuente} cargada.

{Descripción:}

Carga un archivo con una nueva fuente de caracteres (*.FNT) del disco
(un "font" con un nuevo juego de caracteres gráficos).

La función devuelve el {código de fuente} que puede ser utilizado por
las funciones {#171,write()} y {#172,write_int()} para escribir un texto.

Se puede especificar la ruta de acceso al archivo con la fuente, no obstante,
si el archivo con la fuente de letra se ha generado en el directorio por
defecto (\FNT) no será necesario.

El archivo con la nueva fuente se tiene que haber creado con la paleta de
color del juego para que se visualice correctamente; en caso contrario
aparecerán los colores cambiados.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load_fnt;

PRIVATE
    fuente1;

BEGIN

    fuente1=load_fnt("help\help.fnt"); // Se carga la fuente para el texto

    write(0, 160, 0, 1, "Texto escrito con la fuente del sistema.");
    write(fuente1, 160, 10, 1, "FUENTE DEL ARCHIVO EN DISCO");
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo se carga una fuente con la función {load_fnt()}, y después se
escriben dos textos con fuentes diferentes. El primero con la fuente del
sistema y el segundo, con la fuente cargada del archivo {help.fnt}.

{/}

Para descargar de la memoria del ordenador la fuente cargada (liberando
el espacio ocupado en memoria por ésta) se debe utilizar la función
{#177,unload_fnt()}, pasando como parámetro el {código de fuente}.

{No es necesario} descargar la fuente con esta última función a no ser
que se necesite el espacio ocupado para cargar más gráficos o fuentes, ya
que el sistema liberará la fuente automáticamente al finalizar el programa.

{/}Ver: {#177,unload_fnt()} - {#171,write()} - {#171,write_int()} - {#133,load_pal()}

# ─────────────────────────────────────────────────────────────────────────────

{.132,load_fpg()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load_fpg(}<nombre de archivo>{)}

{Retorna:}

Retorna el {código del fichero} cargado.

{Descripción:}

Carga un archivo con un fichero (*.FPG) del disco. Se entiende por un
fichero, una librería (o colección) de gráficos.

Un archivo FPG con una librería de gráficos puede contener desde ningún
gráfico hasta 999 gráficos. Cada uno ellos incluidos en la librería
tendrá un código numérico, el {código de gráfico}, que es un número entre
{1} y {999} que se utiliza para identificar el gráfico dentro del fichero.

Es posible cargar tantos ficheros de gráficos como sea necesario, siempre que
quede memoria disponible (para cargar varios ficheros se debe llamar varias
veces a esta función).

La función devuelve el {código de fichero}, que puede ser utilizado por
múltiples funciones que requieren un gráfico, para lo cual se les debe
indicar el {código de fichero} en el que está el gráfico y el {código de
gráfico} dentro del fichero.

Se puede especificar la ruta de acceso al archivo con el fichero de gráficos,
no obstante, si el fichero está en el directorio por defecto (\FPG) no será
necesario.

{/}

Cuando se han cargado diferentes ficheros se debe tener en cuenta que si
estos tienen paletas diferentes, se debe activar cada una de ellas previamente
con la función {#133,load_pal()}, indicando el nombre del fichero (FPG) como
parámetro, antes de utilizar los gráficos del mismo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load_fpg;

PRIVATE
    fichero1;

BEGIN

    fichero1 = load_fpg("help\help.fpg"); // Se  carga el fichero de gráficos

    put_screen(fichero1, 1); // Utilizamos el gráfico 1 del fichero
    write(0, 160, 0, 1, "Fichero de gráficos cargado con éxito");
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo, se carga el fichero de gráficos que se va usar en el programa
con la función {load_fpg()} y, después, se utiliza el gráfico número 1 del
mismo para ponerlo como fondo en la pantalla (con la función {#148,put_screen()}).

{/}

La función {#169,unload_fpg()} permite liberar la memoria del ordenador utilizada
por el fichero de gráficos cuando ya no se va a utilizar más, y para ello
requiere también el {codigo de fichero} para saber qué fichero es el que se
quiere descargar de memoria.

{No es necesario descargar el fichero de memoria} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

{/}Ver: {#169,unload_fpg()} - {#174,load_map()} - {#133,load_pal()} - {#1131,file}

# ─────────────────────────────────────────────────────────────────────────────

{.133,load_pal()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load_pal(}<nombre de archivo>{)}

{Descripción:}

Carga una paleta de color de disco (de un archivo PAL, FPG, MAP o FNT) con
la definición de los {256 colores} que se visualizan en pantalla.

A partir de ese momento el juego se verá con la correspondencia de colores
que indica dicha paleta.

Si en el momento de cargar la paleta el programa tenía asignada ya otra
diferente, entonces se realizará un fundido de los colores de la pantalla
a negro para después ir introduciendo, en los siguientes fotogramas del
juego, la nueva paleta de color de forma gradual.

Se puede especificar la ruta de acceso al archivo con la paleta;
no obstante, si el fichero está en el directorio por defecto (que dependiendo del
tipo de archivo éste será: \PAL, \FPG, \MAP o \FNT) no será necesario.

El programa leerá la paleta automáticamente del primero de estos tipos
de archivos que se carguen en el programa, aunque no se utilice la función
{load_pal()}. Luego, esta función se utiliza cuando el programa usa
varias paletas diferentes para cambiar de una a otra.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load_pal;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write(0, 160, 0, 1, "Pulse [ESPACIO] para cargar una paleta diferente.");
    write(0, 160, 10, 1, "Pulse [ENTER] para cargar la paleta original.");
    LOOP
        IF (key(_space))

            load_pal("help\help.pal"); // Se carga una paleta de un fichero .pal

        END
        IF (key(_enter))

            load_pal("help\help.fpg");  // Se carga una paleta de un fichero .fpg

        END
        FRAME;
    END
END
{-}

En el ejemplo, al inicio se carga un fichero de gráficos, se pone un fondo
de pantalla y se imprimen los mensajes necesarios.

En el bucle principal del programa se carga una paleta diferente (de {help.pal})
cuando se pulsa la barra espaciadora y la paleta original (de {help.fpg})
al pulsar la tecla ENTER.

{/}

Una paleta no se puede descargar de la memoria del ordenador, ya que ésta
no ocupa espacio en la memoria.

{/}Ver: {#174,load_map()} - {#132,load_fpg()} - {#131,load_fnt()}

# ─────────────────────────────────────────────────────────────────────────────

{.134,load_pcm()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load_pcm(}<nombre de archivo>{,} <cíclico>{)}

{Retorna:}

El {código del sonido} cargado.

{Descripción:}

Carga un efecto de sonido de un archivo PCM del disco. Se debe indicar el
nombre del archivo con el efecto de sonido como primer parámetro y en
<cíclico>, como segundo parámetro, {1} si es un sonido que se debe tocar
repitiéndose indefinidamente, o {0} si debe sonar sólo una vez (cuando se
solicite con la función {#159,sound()}).

La función devuelve el {código del sonido} que debe ser utilizado por
la función {#159,sound()} para hacer que suene por un canal dicho sonido.

Se puede especificar la ruta de acceso al archivo con el sonido, no obstante,
si el sonido está en el directorio por defecto (\PCM) no será necesario.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load_pcm;

PRIVATE
    id_sonido;

BEGIN

    id_sonido = load_pcm("help\help.pcm", 0); // Carga un sonido del disco duro

    write(0, 160, 0, 1, "Presione [ESPACIO] para ejecutar el sonido.");
    LOOP
        IF (scan_code==_space)
            sound(id_sonido, 100, 256);
        END
        FRAME;
    END
END
{-}

En el ejemplo primeramente se carga un sonido con la función {load_pcm()}.
Luego, en el bucle principal, cada vez que se pulsa la barra espaciadora se
ejecuta dicho sonido con la función {#159,sound()}.

{/}

La función {#170,unload_pcm()} permite liberar la memoria del ordenador utilizada
por el sonido cuando ya no se va a utilizar más y, para ello,
requiere también el {codigo del sonido} para saber qué sonido es el que se
quiere descargar de memoria.

{No es necesario descargar el sonido de memoria} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

{/}Ver: {#170,unload_pcm()} - {#159,sound()} - {#102,change_sound()} - {#1104,Estructura setup}

# ─────────────────────────────────────────────────────────────────────────────

{.135,map_block_copy()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{map_block_copy(}<fichero>{,} <gráfico destino>{,} <x destino>{,} <y destino>{,}
                 <gráfico origen>{,} <x>{,} <y>{,} <ancho>{,} <alto>{)}

{Descripción:}

La función {map_block_copy()} permite transferir un bloque rectangular
de un gráfico a otro.

El gráfico del cual se toma la región rectangular se
denomina <gráfico origen> y el {gráfico destino} es en el que se copiará
dicho bloque, es decir, esta función permite copiar un trozo de un gráfico
(origen) a otro (destino). Los parámetros son, por orden, los siguientes:

{<fichero>} - Ambos gráficos deben provenir del mismo fichero de gráficos.
Como primer parámetro se debe especificar el {código del fichero} (ver
{#132,load_fpg()}). Los gráficos cargados con la función {#174,load_map()}
se utilizarán como si pertenecieran al primer fichero (el fichero con el
código 0).

{<gráfico destino>} - {código del gráfico} en el que se va a poner el bloque.

{<x destino>, <y destino>} - coordenadas ({x}, {y}) en las que se quiere poner
el bloque dentro del gráfico destino.

{<gráfico origen>} - {código del gráfico} del que se va a tomar el bloque.

{<x>, <y>} - coordenadas de {inicio} del bloque dentro del gráfico origen.

{<ancho>, <alto>} - {dimensiones} del bloque que se va a transferir.

Esta función modificará el gráfico indicado, pero sólo la copia del mismo
que se ha cargado en la memoria del ordenador. El gráfico original, que
está en el archivo {FPG} o {MAP} del disco, {permanecerá inalterado}.
Por ello si se quiere en un momento del juego recuperar el estado original
del gráfico se tiene que descargar de memoria (con {#169,unload_fpg()} o
{#176,unload_map()}) y después volverlo a cargar.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_map_block_copy;

PRIVATE
    x_destino, y_destino;
    x_origen, y_origen;
    ancho, alto;
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    graph=1;
    x=160;
    y=100;
    LOOP
        x_destino=rand(0, 320);
        y_destino=rand(0, 200);
        ancho=rand(1, 32);
        alto=rand(1, 32);
        x_origen=rand(0, 32-ancho);
        y_origen=rand(0, 32-alto);

        map_block_copy(fichero1, 1, x_destino, y_destino, 100, x_origen, y_origen, ancho, alto);

        FRAME;
        angle+=1000;
    END
END
{-}

En el ejemplo, después de cargar el fichero de gráficos y poner uno (
el gráfico número 1) el centro de pantalla va rotando contínuamente.
En el bucle principal, se va copiando el gráfico de una bola (el gráfico
número 100) dentro del gráfico destino (el número 1) en unas coordenadas
elegidas aleatoriamente.

{/}

Cuando se ponga un gráfico en otro que se esté utilizando como fondo
para una región de scroll, éste no aparecerá automáticamente en pantalla
a no ser que se utilice la función {#152,refresh_scroll()}.

{/}Ver: {#139,map_xput()} - {#137,map_put()} - {#138,map_put_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.136,map_get_pixel()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{map_get_pixel(}<fichero>{,} <gráfico>{,} <x>{,} <y>{)}

{Retorna:}

El color del punto (0..255).

{Descripción:}

Permite obtener, como valor de retorno de la función, el color de un punto
determinado de un gráfico. Para ello requiere el <código del fichero> en el
que se encuentra el gráfico, el <código del gráfico> dentro del fichero y
las coordenadas ({x}, {y}) del punto del gráfico cuyo color se quiere obtener.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_map_get_pixel;

PRIVATE
    fichero1;
    figura;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    put_screen(0, 7);
    mouse.graph=200;
    write(0, 0, 0, 0, "FIGURA:");
    write_int(0, 42, 0, 0, offset figura);
    LOOP

        // Cogemos el color del punto del mapa del bits
        figura = map_get_pixel(fichero1, 8, mouse.x, mouse.y);

        FRAME;
    END
END
{-}

En el ejemplo se pone como fondo de pantalla una imagen con 6 figuras
geométricas diferentes, todas ellas del mismo color, y el gráfico del
ratón se define como una pequeña cruz.

La imagen de fondo se corresponde directamente con otro gráfico, el
número 8 del fichero, el cual tiene las mismas figuras aunque cada una
de un color diferente (la primera de color 1, la segunda de color 2, etc.).

En el bucle principal se tomará un color de este segundo gráfico con la
función {map_get_pixel()}, de las coordenadas que indique el cursor del
ratón.

En la esquina superior izquierda de la pantalla el valor obtenido con
la función, que es un número del 1 al 6 que indica el número de figura.

{/}

Esta función se suele utilizar para la detección de zonas dentro de gráficos.
Esta técnica se denomina {mapas de durezas} y consiste en utilizar dos
gráficos diferentes, uno con el dibujo en sí y otro con las zonas a detectar
pintadas de diferentes colores.

Por ejemplo, en un juego de naves se podrían pintar en este {mapa de durezas}
las zonas que le quitan energía a la nave cuando pasa por ellas con un color
(por ejemplo, el color 32); después se obtendría el color del {mapa de durezas}
sobre el que está la nave, y si es 32, se le restaría energía.

Es decir, habría dos dibujos diferentes: uno en colores, que es el dibujo
de fondo por el que se mueve la nave en el juego (el visible), y otro,
el {mapa de durezas} que se utilizaría únicamente para obtener colores
de él con la función {map_get_pixel()} y, de esta forma, identificar la
zona del dibujo original sobre el que está la nave.

{/}Ver: {#123,get_pixel()} - {#138,map_put_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.137,map_put()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{map_put(}<fichero>{,} <gráfico destino>{,} <gráfico origen>{,} <x>{,} <y>{)}

{Descripción:}

Pone un gráfico en otro. El gráfico que se va a copiar se denomina
<gráfico origen> y el {gráfico destino} es en el que se copiará el origen,
es decir, esta función permite copiar un gráfico (origen) a otro (destino).

Ambos gráficos deben estar en el mismo fichero. Los parámetros son, por
orden, los siguientes:

{<fichero>} - {código del fichero} con la librería de gráficos que contiene
a ambos. Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{<gráfico destino>} - {código del gráfico} en el que se va a poner el otro.

{<gráfico origen>} - {código del gráfico} que va a ser copiado en el destino.

{<x>, <y>} - {coordenadas dentro del gráfico destino} donde se desea poner el
gráfico origen. En estas coordenadas es donde se situará el centro (o
{#1136,punto de control} número 0) del gráfico origen.

Esta función modificará el gráfico indicado, pero sólo la copia del mismo
que se ha cargado en la memoria del ordenador. El gráfico original, que
está en el archivo {FPG} o {MAP} del disco, {permanecerá inalterado}.
Por ello si se quiere en un momento del juego recuperar el estado original
del gráfico se tiene que descargar de memoria (con {#169,unload_fpg()} o
{#176,unload_map()}) y después volverlo a cargar.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_map_put;

PRIVATE
    x_destino;
    y_destino;
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    graph=1;
    x=160;
    y=100;
    LOOP
        x_destino=rand(0, 320);
        y_destino=rand(0, 200);

        map_put(fichero1, 1, 100, x_destino, y_destino);

        angle+=1000;
        FRAME;
    END
END
{-}

En el ejemplo se pone el gráfico número 1 en el centro de la pantalla.

En cada paso del bucle principal se gira este gráfico y se
pone, con la función {map_put()}, un gráfico número 100 (una bola) dentro
del gráfico 1 (el gráfico central).

{/}

La función {#139,map_xput()} es una versión un poco más compleja de la
función {map_put()}, pero con muchas más posibilidades, pues permite, además,
poner gráficos rotados, escalados, espejados y transparentes.

Para poner una parte de un gráfico en otro (en lugar de poner el gráfico
completo) se debe utilizar la función {#135,map_block_copy()}.

{/}

{Nota:} Cuando se utilice la función {map_put()} (o cualquier otra similar)
para modificar un gráfico que se está utilizando como fondo de una ventana
de {scroll}, puede que el gráfico puesto no aparezca de forma inmediata en
pantalla; para solventar este problema se debe utilizar la función
{#152,refresh_scroll()}.

{/}Ver: {#139,map_xput()} - {#138,map_put_pixel()} - {#152,refresh_scroll()} - {#135,map_block_copy()}

# ─────────────────────────────────────────────────────────────────────────────

{.138,map_put_pixel()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{map_put_pixel(}<fichero>{,} <gráfico>{,} <x>{,} <y>{,} <color>{)}

{Descripción:}

Permite modificar el color de un punto determinado de un gráfico.
Para ello requiere el <código del fichero> en el
que se encuentra el gráfico, el <código del gráfico> dentro del fichero y
las coordenadas ({x}, {y}) del punto cuyo <color> se quiere establecer.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

Esta función modificará el gráfico indicado, pero sólo la copia del mismo
que se ha cargado en la memoria del ordenador. El gráfico original, que
está en el archivo {FPG} o {MAP} del disco, {permanecerá inalterado}.
Por ello si se quiere en un momento del juego recuperar el estado original
del gráfico se tiene que descargar de memoria (con {#169,unload_fpg()} o
{#176,unload_map()}) y después volverlo a cargar.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_map_put_pixel;
PRIVATE
    fichero1;
    coord_x;
    coord_y;
    color;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    graph=5;
    x=160;
    y=100;
    size=180;
    LOOP
        coord_x=rand(0, 199);
        coord_y=rand(0, 199);
        color=rand(0, 15);

        // Se ponen puntos en el gráfico número 5 del fichero1
        map_put_pixel(fichero1, 5, coord_x, coord_y, color);

        angle+=2000;
        FRAME;
    END
END
{-}

En el ejemplo, se pone el gráfico número 5 en el centro de la pantalla
rotando contínuamente; este gráfico es un fondo completamente negro,
por ello inicialmente no se verá nada en pantalla.

Pero después, en cada paso del bucle se ponen en él puntos de un color
elegido al azar entre el 0 y el 15 (grises) en unas coordenadas
también elegidas al azar.

Estos puntos se ponen usando la función {map_put_pixel()}.

Se puede observar cómo parece que hay cada vez más puntos girando en
pantalla cuando, en realidad, lo único que gira es el gráfico número 5.

{/}

Para poner un gráfico completo en otro, y no sólo en un punto, se pueden
utilizar las funciones {#137,map_put()} o {#139,map_xput()}, y para poner
sólo una parte de un gráfico en otro se puede utilizar la función
{#135,map_block_copy()}.

{/}

{Nota:} Cuando se utilice la función {map_put_pixel()} para poner un punto
en un gráfico que se está utilizando como fondo de una ventana
de {scroll}, puede que el punto puesto no aparezca de forma inmediata en
pantalla; para solventar este problema se debe utilizar la función
{#152,refresh_scroll()}.

{/}Ver: {#137,map_put()} - {#139,map_xput()} - {#152,refresh_scroll()} - {#135,map_block_copy()}

# ─────────────────────────────────────────────────────────────────────────────

{.139,map_xput()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{map_xput(}<fichero>{,} <gráfico destino>{,} <gráfico origen>{,} <x>{,} <y>{,}
           <angle>{,} <size>{,} <flags>{)}

{Descripción:}

Versión extendida de la función {#137,map_put()}.

Pone un gráfico en otro. El gráfico que se va a copiar se denomina
<gráfico origen> y el {gráfico destino} es en el que se copiará el origen,
es decir, esta función permite copiar un gráfico (origen) a otro (destino).

Ambos gráficos deben estar en el mismo fichero. Los parámetros son, por
orden, los siguientes:

{<fichero>} - {código del fichero} con la librería de gráficos que contiene
a ambos. Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{<gráfico destino>} - {código del gráfico} en el que se va a poner el otro.

{<gráfico origen>} - {código del gráfico} que va a ser copiado en el destino.

{<x>, <y>} - coordenadas dentro del gráfico destino donde se desea poner el
gráfico origen. En estas coordenadas es donde se copiará el gráfico origen
a partir de su esquina superior izquierda.

{<angle>} - ángulo (en milésimas de grados) en el que se copiará el gráfico origen,
el ángulo normal es {0}.

{<size>} - tamaño (en porcentaje) en el que se copiará el gráfico original, el
tamaño normal es {100}.

{<flags>} - Indica los espejados y transparencias con los que se copiará el gráfico
original en el destino; los valores son:

 {0}-Gráfico normal.·
 {1}-Espejado horizontal.·
 {2}-Espejado vertical.·
 {3}-Espejado horizontal y vertical (180°).·
 {4}-Gráfico transparente.·
 {5}-Transparente y espejado horizontal.·
 {6}-Transparente y espejado vertical.·
 {7}-Transparente, espejado horizontal y vertical.·

Esta función modificará el gráfico indicado, pero sólo la copia del mismo
que se ha cargado en la memoria del ordenador. El gráfico original, que
está en el archivo {FPG} o {MAP} del disco, {permanecerá inalterado}.
Por ello, si se quiere en un momento del juego recuperar el estado original
del gráfico se tiene que descargar de memoria (con {#169,unload_fpg()} o
{#176,unload_map()}) y después volverlo a cargar.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_map_xput;
PRIVATE
    x_destino;
    y_destino;
    fichero1;
    ángulo1;
    tamaño1;
    banderas1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    graph=1;
    x=160;
    y=100;
    LOOP
        x_destino=rand(0, 319);
        y_destino=rand(0, 199);
        ángulo1=rand(-pi, pi);
        tamaño1=rand(10, 200);
        banderas1=rand(0, 7);

        map_xput(fichero1, 1, 101, x_destino, y_destino, ángulo1, tamaño1, banderas1);

        angle+=2000;
        FRAME;
    END
END
{-}

En el ejemplo, se pone el gráfico 1 en el centro de la pantalla rotando
contínuamente (este gráfico es un fondo decorativo en grises).

En cada paso del bucle se pondrá dentro de él otro gráfico con forma
de triángulo (con el número 100). Este gráfico se pondrá con coordenadas,
ángulo, tamaño y banderas (ver variable {#1127,flags}) elegidas
de forma aleatoria.

Se puede observar cómo en el gráfico de fondo van apareciendo contínuamente
triángulos de color marrón con diferentes efectos aplicados.

{/}

La función {map_xput()} es una versión un poco más compleja de la
función {#137,map_put()}, siendo ésta más fácil de utilizar cuando no se
requiera poner gráficos rotados, escalados, espejados y transparentes.

Para poner una parte de un gráfico en otro (en lugar de poner el gráfico
completo) se debe utilizar la función {#135,map_block_copy()}.

{/}

{Nota:} Cuando se utilice la función {map_xput()} (o cualquier otra similar)
para modificar un gráfico que se está utilizando como fondo de una ventana
de {scroll}, puede que el gráfico puesto no aparezca de forma inmediata en
pantalla; para solventar este problema se debe utilizar la función
{#152,refresh_scroll()}.

{/}Ver: {#137,map_put()} - {#138,map_put_pixel()} - {#152,refresh_scroll()} - {#135,map_block_copy()}

# ─────────────────────────────────────────────────────────────────────────────

{.140,move_scroll()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{move_scroll(}<número de scroll>{)}

{Descripción:}

Fuerza a mover un scroll automático de forma inmediata. Esta es una función
algo avanzada y por ello puede resultar difícil de comprender su propósito.

La función requiere como parámetro el <número de scroll> de 0 a 9 que se
indicó en la función {#163,start_scroll()} como primer parámetro cuando
se inició el scroll.

Esta función se utiliza cuando una región de scroll se controla
automáticamente, por haber definido el campo {camera} de la
{#1101,estructura scroll} correspondiente con el identificador de un
proceso.

El propósito es forzar a que se actualicen los valores ({x0}, {y0}, {x1} y {y1})
de dicha estructura; si no se utiliza esta función estos valores no se
actualizarán hasta la próxima imagen del juego.

Es decir, cuando un scroll se controla de forma automática y otro proceso
necesita conocer antes de la próxima imagen el valor de las coordenadas
de dicho scroll (normalmente para colocarse él en una posición acorde al
movimiento del fondo) se debe hacer esto:

{1} - Se inicia el scroll con {#163,start_scroll()}.

{2} - Se crea el proceso que se utilizará como cámara y se pone su
{#1039,código identificador} en el campo {camera} de la {#1101,estructura
scroll}.

{3} - A este proceso se le debe poner una prioridad muy alta, para que
se ejecute antes que el resto de los procesos (poniendo en su variable
local {#1121,priority} un valor entero positivo como, por ejemplo, 100).

{4} - Justo antes de la sentencia {#1029,FRAME} del bucle del proceso usado
como cámara se llamará a la función {move_scroll()}.

De esta forma se garantizará que este proceso se ejecute el primero y, justo
al finalizar, actualice los valores ({x0}, {y0}, {x1} y {y1}) de la
{#1101,estructura scroll}, de forma que el resto de los procesos puedan
utilizar estas variables ya actualizadas.

El uso más generalizado de esta función es cuando en una ventana de scroll
se quieren tener más de dos planos de fondo y, para ello, se crean una serie
de procesos que simulen un tercer o cuarto plano, situando sus coordenadas
en función de la posición exacta del scroll en cada imagen. A continuación
se muestra un programa que lo hace.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_move_scroll;

PRIVATE
    fichero1;
    contador;

BEGIN
    set_fps(100, 0);
    fichero1=load_fpg("help\help.fpg");
    start_scroll(0, fichero1, 103, 102, 0, 15);
    scroll.camera=id;
    priority=100;
    FROM contador=-2000 TO 2000 step 100;
        proceso_móvil(contador);
    END
    write(0, 160, 0, 1, "Utilice cursor derecha e izquierda para moverse");
    graph=101;
    ctype=c_scroll;
    LOOP
        if (key(_right))
            x+=2;
            flags=0;
        END
        if (key(_left))
            x-=2;
            flags=1;
        END

        move_scroll(0); // Actualiza la estructura scroll[]

        FRAME;
    END
END

PROCESS proceso_móvil(x_scroll)
BEGIN
    ctype=c_scroll;
    z=100;
    graph=104;
    LOOP
        x=x_scroll-scroll.x0;
        FRAME;
    END
END
{-}

Este ejemplo inicia un scroll a pantalla completa con dos planos y después
mueve un triángulo hacia la derecha e izquierda con los cursores; este
proceso será la cámara del scroll, centrándose la visión en el mismo de
forma automática (al poner {scroll.camera=}{#1092,id}{;}).

Pero, además, crea un total de 40 procesos (de -2000 hasta 2000, cada 100 puntos)
con el dibujo de una banda vertical de colores que se moverán como si fueran
un tercer plano de scroll (procesos de tipo {proceso_móvil}).

Para ello, es importante que su {z} sea superior al resto de los procesos
({z=100;}) y que la prioridad del proceso que controla la cámara sea mayor
({priority=100;}) y este último utilice la función {move_scroll()} antes
de cada imagen ({FRAME;}).

Los procesos que simula el tercer plano ({proceso_móvil}), sitúan su
coordenada {x} en función de la {x del scroll} y su posición original.

La diferencia es que si no se hubiera utilizado {move_scroll()}, al
utilizar los procesos la variable {scroll.x0} sin actualizar, se moverían
con un cierto retraso que restaría verosimilitud al juego.

{/}Ver: {#163,start_scroll()} - {#1101,Estructura scroll} - {#1121,priority} - {#1125,z}

# ─────────────────────────────────────────────────────────────────────────────

{.141,move_text()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{move_text(}<identificador del texto>{,} <x>{,} <y>{)}

{Descripción:}

Mueve un texto a otras coordenadas de pantalla. Se especifica como parámetro
el {identificador del texto} que es un código numérico que devuelve las
funciones {#171,write()} y {#172,write_int()} cuando se les pide que escriban
un texto, y las coordenadas ({x}, {y}) de pantalla a las que se debe mover el
texto.

El {código de centrado} especificado en el {#171,write()} o {#172,write_int()}
se mantendrá cuando se utilice esta función.

Las coordenadas especificadas son siempre relativas a la pantalla y pueden
estar dentro o fuera de la misma. Para modificar la {coordenada z de los
textos} (el plano de profundidad en el que aparecen) se debe utilizar la
variable global {#1106,text_z}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_move_text;

PRIVATE
    id_texto1;
    id_texto2;
    coord_x;
    coord_y;
    ángulo1;

BEGIN
    id_texto1=write(0, 160, 100, 4, "TEXTO EN MOVIMIENTO");
    id_texto2=write(0, 160, 100, 4, "MUEVA EL RATON");
    LOOP
        coord_x=160+get_distx(ángulo1, 100);
        coord_y=100+get_disty(ángulo1, 90);

        // Movemos los textos
        move_text(id_texto1, coord_x, coord_y);
        move_text(id_texto2, mouse.x, mouse.y);

        ángulo1+=1000;
        FRAME;
    END
END
{-}

En el ejemplo se imprimen dos texto con la función {#171,write()} en
el centro de la pantalla. Esta función nos devuelve los identificadores
de dichos textos, que se guardan en las variables {id_texto1} e {id_texto2}.

En cada paso de bucle, se mueve el primer el texto por una trayectoria
circular que se consigue incrementando un ángulo ({ángulo1}) y utilizando
las funciones {#118,get_distx()} y {#119,get_disty()}. El segundo texto
se situará en las coordenadas del puntero del ratón.

Ambos textos se mueven en cada imagen mediante la función {move_text()}.

{/}

Para borrar un texto definitivamente también se requiere el {identificador
del texto}, y se debe utilizar para ello la función {#107,delete_text()}.

{/}Ver: {#171,write()} - {#172,write_int()} - {#107,delete_text()}

# ─────────────────────────────────────────────────────────────────────────────

{.142,near_angle()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{near_angle(}<ángulo>{,} <ángulo final>{,} <incremento>{)}

{Retorna:}

Un nuevo ángulo más próximo al ángulo final.

{Descripción:}

Acerca un ángulo a otro en el incremento dado. La función devuelve el nuevo
ángulo.

Se utiliza cuando se quiere que un ángulo (<ángulo>) varíe gradualmente
hasta convertirse en otro (<ángulo final>); para ello, la función necesita
el ángulo original, el {ángulo final} y el {incremento} angular que se
le va a ir sumando o restando al ángulo original.

Se recuerda que todos los ángulos se especifican en milésimas de grado. El
{incremento} angular no es más que un ángulo pequeño, como pudiera ser un
grado ({1000}) o cinco ({5000}).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_near_angle;

PRIVATE
    ángulo2;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    mouse.graph=200;
    graph=101;
    write(0, 160, 200, 7, "Mueva el cursor del ratón");
    LOOP
        ángulo2=fget_angle(x, y, mouse.x, mouse.y);

        // Acerca el ángulo actual al final en 10 grados como máximo
        angle = near_angle(angle, ángulo2, 10000);

        advance(6);
        FRAME;
    END
END
{-}

En el ejemplo se define el cursor del ratón como una pequeña cruz que el
usuario puede mover.

El programa principal define su gráfico como un triángulo ({graph=101;})
que, en cada iteración del bucle, obtiene el ángulo hacia el cursor del
ratón con la función {#113,fget_angle()}; después modifica su ángulo
para que se acerque un máximo de 10 grados (10000) hacia el ángulo del
cursor, utilizando la función {near_angle()} y, por último, avanza 6 puntos
en esa dirección utilizando la función {#101,advance()}.

Se puede observar cómo el triángulo persigue contínuamente al cursor del
ratón sin realizar ningún giro brusco (de más de 10 grados).

{/}Ver: {#1044,Uso de ángulos en el lenguaje} - {#1129,angle} - {#116,get_angle()} - {#113,fget_angle()}

# ─────────────────────────────────────────────────────────────────────────────

{.143,out_region()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{out_region(}<código identificador>{,} <número de región>{)}

{Retorna:}

{Cierto} si el proceso está fuera de la región o {Falso} en caso contrario.

{Descripción:}

Esta función determina si un proceso está fuera de una región de pantalla,
para ello la función requiere el {#1039,código identificador} del proceso
y un número de región.

Las regiones de pantalla se pueden definir con la función {#106,define_region()}
y son, simplemente, zonas rectangulares de pantalla.

La región número {0} no se puede definir ya que será siempre la pantalla completa,
por lo tanto, si se especifica un {0} como segundo parámetro esta función determina
si un proceso está fuera de la pantalla (si no se ve).

En el caso de que el gráfico del proceso esté fuera de la región especificada
la función devuelve {Cierto} (un número impar); en cambio si el gráfico se ve,
aunque sea parcialmente, en dicha región, la función devuelve {Falso} (cualquier
número par).

El proceso cuyo {#1039,código identificador} se indica debe tener definido
correctamente su gráfico (normalmente en su variable {#1026,graph}) pues,
de lo contrario, el sistema advertirá un error ya que si el proceso
no tiene un gráfico, no se pueden calcular las dimensiones del mismo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_out_region;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    y=100;
    x=160;
    graph=101;
    LOOP
        advance(8);

        IF (out_region(id, 0)) // Se comprueba si se sale de pantalla

            x=160;
            y=100;
            angle=rand(-pi, pi);
        END
        FRAME;
    END
END
{-}

En el ejemplo se pone un gráfico de fondo y el programa principal
crea un gráfico en el centro de la pantalla con un ángulo aleatorio
y en forma de triángulo.

En cada paso del bucle el triángulo avanza y se comprueba si ha salido
de la pantalla (region 0) con la función {out_region()}. Si ha salido
de pantalla se pone otra vez en el centro con otro ángulo elegido
nuevamente al azar.

{/}Ver: {#106,define_region()} - {#1130,region} - {#1039,Codigos identificadores}

# ─────────────────────────────────────────────────────────────────────────────

{.144,play_cd()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{play_cd(}<número de pista>{,} <modo>{)}

{Descripción:}

Comienza a tocar una pista de cd-audio. Se debe indicar el número de pista (de
1 al número de canciones que tenga el cd) y el modo es como sigue:

{Modo.}

 {0} - Tocar la canción y pararse después.·
 {1} - Tocar esa canción y después las siguientes.·

{#9999,Programa ejemplo:}
PROGRAM ejemplo_play_cd;
BEGIN
    write(0, 160, 0, 1, "Pulse [ESPACIO] para poner el CD en marcha.");
    LOOP
        IF (scan_code==_space)

            play_cd(1, 1); // Se pone la 1ª canción y después las demás.

        END
        FRAME;
    END
END
{-}

El ejemplo anterior (para el cual se necesita tener un {Compact disc} de
música en el cargador de {CD-ROM}) se pone un mensaje informativo y en cada
iteración del bucle se comprueba si se pulsó la barra espaciadora para poner
la primera canción con la función {play_cd()}

{/}

Para conseguir que una canción suene indefinidamente, se debe implementar
un bucle utilizando la función {#127,is_playing_cd()} para determinar cuándo
ha acabado la canción.

El volumen de reproducción del cd-audio se puede controlar con la
estructura {#1104,setup} y la función {#178,set_volume()}.

{/}Ver: {#127,is_playing_cd()} - {#164,stop_cd()} - {#178,set_volume()} - {#1104,Estructura setup}

# ─────────────────────────────────────────────────────────────────────────────

{.145,pow()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{pow(}<expresión>{,} <expresión>{)}

{Retorna:}

La primera expresión {elevada} a la segunda.

{Descripción:}

Calcula el resultado de elevar la primera expresión a la segunda.

Por ejemplo, {pow(3, 2)} devolverá {9}, que es {3} elevado al cuadrado,
es decir, {3²}, o {3*3}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_pow;
GLOBAL
    valores[15];
    n;
BEGIN
    FROM n=0 TO 15;
        valores[n]=rand(-100, 100);
        write_int(0, 0, n*10, 0, offset valores[n]);
    END
    write(0, 0, 192, 0, "Pulse [ESPACIO] para elevar estos números al cuadrado");
    LOOP
        IF (scan_code==_space)
            FROM n=0 TO 15;

                valores[n] = pow(valores[n], 2); // Se eleva al cuadrado.

            END
        END
        FRAME;
    END
END
{-}

Este programa imprimirá en pantalla una lista de números aleatoriamente
escogidos entre -100 y 100. Cuando se pulse la barra espaciadora se elevarán
dichos número al cuadrado.

Se debe tener en cuenta que en el lenguaje {sólo se pueden manejar números
enteros dentro del rango} ({#1177,min_int} ... {#1178,max_int}) por lo que,
cuando el resultado de la función deba exceder dicho rango, {se
mostrarán resultados incorrectos}. En este caso, el sistema no advertirá de
ningún error, por lo que se deben extremar las precauciones.

{/}Ver: {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.146,put()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{put(}<fichero>{,} <gráfico>{,} <x>{,} <y>{)}

{Descripción:}

Pone un gráfico en el fondo de la pantalla. La función requiere el {código de
fichero} en el que está el gráfico, el {código del gráfico} dentro del mismo
fichero y las coordenadas ({x}, {y}) en las que se desea poner el gráfico.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

Si no se especificó el centro del gráfico (estableciendo su {#1136,punto de control}
número 0 desde la herramienta de dibujo), las coordenadas se referirán a la
posición de pantalla en la que se situará {el centro} del gráfico.

Los gráficos impresos de esta forma en el fondo de la pantalla estarán en la
visualización del juego {por debajo de todos los procesos, regiones de scroll,
textos, etc.}

Si se desea que un gráfico esté por encima de otros se debe {crear
como un nuevo proceso} y fijar su variable {#1125,z} con la prioridad de impresión
del mismo.

Para borrar el fondo de la pantalla se debe utilizar la función {#103,clear_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_put;

PRIVATE
    fichero1;
    coord_x;
    coord_y;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    LOOP
        coord_x=rand(0, 319);
        coord_y=rand(0, 199);

        put(fichero1, 100, coord_x, coord_y); // Se pone el gráfico 100.

        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero con los gráficos y en cada iteración
de bucle se pone el gráfico número 100 (una bola) con la función {put()} en
coordenadas aleatorias (elegidas al azar con la función {#149,rand()}).

{/}

Si el gráfico que se quiere poner es simplemente una pantalla de fondo,
resulta más sencillo utilizar la función {#148,put_screen()}, ya que ésta
no requiere las coordenadas de pantalla pues centrará el gráfico en la
misma de forma automática.

{/}

La función {#173,xput()} es una versión un poco más compleja de la
función {put()} pero con muchas más posibilidades, ya que permite, además,
poner gráficos rotados, escalados, espejados y transparentes.

Para poner un gráfico en otro (en lugar del fondo de la pantalla)
se deben utilizar las funciones {#137,map_put()} o {#139,map_xput()}.

{/}Ver: {#148,put_screen()} - {#173,xput()} - {#137,map_put()} - {#139,map_xput()} - {#147,put_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.147,put_pixel()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{put_pixel(}<x>{,} <y>{,} <color>{)}

{Descripción:}

Establece el {color} del punto situado en las coordenadas ({x}, {y})
del fondo de la pantalla. Es decir, pone un punto del color indicado en las
coordenadas indicadas.

Los puntos impresos con esta función en el fondo de la pantalla estarán en la
visualización del juego {por debajo de todos los procesos, regiones de scroll,
textos, etc.}

Si se desea visualizar un punto que esté por encima de otros gráficos se debe
crear un nuevo proceso y asignarle como gráfico el dibujo de un punto (en su
variable {#1126,graph}) y fijar su variable {z} con la prioridad de
impresión del mismo.

Para borrar el fondo de la pantalla se debe utilizar la función {#103,clear_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_put_pixel;

PRIVATE
    x_punto;
    y_punto;
    color;

BEGIN
    LOOP
        x_punto=rand(0, 319);
        y_punto=rand(0, 199);
        color=rand(0, 15);

        // Se ponen puntos en el fondo de la pantalla aleatoriamente
        put_pixel(x_punto, y_punto, color);

        FRAME;
    END
END
{-}

En el ejemplo, en cada paso del bucle se ponen puntos con la función
{put_pixel()} con coordenadas y color elegidos al azar con la función
{#149,rand()}.

{/}

Para leer el color que tiene un determinado punto del fondo de la pantalla
se debe utilizar la función {#123,get_pixel()}, que devolverá un número entre
0 y 255 correspondiente al orden del color dentro de la paleta.

Para poner un gráfico en pantalla, en lugar de un simple punto se debe
utilizar la función {#146,put()}.

También es posible establecer el color de un punto en un determinado gráfico
en lugar del fondo de la pantalla, lo que se puede hacer con {#138,map_put_pixel()}.

{/}Ver: {#123,get_pixel()} - {#146,put()} - {#138,map_put_pixel()} - {#136,map_get_pixel()}

# ─────────────────────────────────────────────────────────────────────────────

{.148,put_screen()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{put_screen(}<fichero>{,} <gráfico>{)}

{Descripción:}

Establece el fondo de la pantalla. La función requiere el {código de
fichero} en el que está el gráfico, y el propio {código del gráfico}
que se desea imprimir en el fondo de la pantalla dentro del fichero.

Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

La función no requiere ninguna coordenada como parámetro, pues si el gráfico
es de un tamaño (en puntos) diferente al de la pantalla simplemente se
imprimirá centrado en la misma.

Para borrar el fondo de la pantalla se debe utilizar la función {#103,clear_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_put_screen;

PRIVATE
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");

    put_screen(fichero1, 1); // Se pone el gráfico 1 como fondo.

    LOOP
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y se pone un gráfico
de fondo (que está metido en el fichero con el código de gráfico número 1)
con la función {#148,put_screen()}.

{/}

Si se quiere imprimir un gráfico en una parte concreta de la pantalla o un
gráfico {que no aparezca centrado}, se puede utilizar para ello la función
{#146,put()}. La función {#173,xput()} permite, además, imprimir gráficos
rotados, escalados, espejados y/o transparentes en cualquier región de
pantalla.

{/}Ver: {#146,put()} - {#173,xput()} - {#147,put_pixel()} - {#103,clear_screen()}

# ─────────────────────────────────────────────────────────────────────────────

{.149,rand()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{rand(}<valor mínimo>{,} <valor máximo>{)}

{Retorna:}

Un valor numérico aleatorio.

{Descripción:}

Devuelve un número aleatorio (escogido al azar) entre el {valor mínimo} y
el {valor máximo}, ambos incluidos.

Esta función se suele utilizar para establecer todos los parámetros que se
quiere que varíen en un juego de una partida a otra; por ejemplo, se pueden
inicializar las coordenadas de un enemigo con números aleatorios, para que
en cada partida pueda aparecer en una posición diferente.

Otra utilidad de esta función es cuando se quiere que una acción no suceda
siempre, sino que tenga una cierta probabilidad de suceder; esto se suele
implementar con una sentencia del tipo:

  {IF (rand(0, 100)<25)}·
     { // Acción ...}·
  {END}·

En este caso la {acción} se realizaría con un promedio del 25 por ciento de las
veces que se ejecutara la sentencia {#1020,IF}, ya que, al obtener un número
al azar entre 0 y 100, éste sólo sería un número menor que 25, aproximadamente
una cuarta parte de las ocasiones.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_rand;

PRIVATE
    tabla[15];
    contador;

BEGIN
    write (0, 0, 192, 0, "Pulse [ESPACIO] para hallar valores aleatorios.");
    FROM contador=0 TO 15;
        write_int(0, 0, contador*10, 0, offset tabla[contador]);
    END
    LOOP
        IF (scan_code==_space)
            FROM contador=0 TO 15;

                // Se eligen valores aleatorios entre -100 y 100
                tabla[contador] = rand(-100, 100);

            END
        END
        FRAME;
    END
END
{-}

En el ejemplo se crea una tabla con 16 datos (del 0 al 15). En cada
iteración del bucle principal se comprueba si se ha pulsado la barra
espaciadora, en cuyo caso se rellenan los 16 datos de la tabla con
valores aleatorios entre -100 y 100, elegidos con la función {rand()}.

{/}

Por defecto, en cada ejecución del programa los valores que devuelva la
función {rand()} serán completamente diferentes. Si se quiere que la
serie de números sea siempre una misma, se puede utilizar para ello la
función {#150,rand_seed()} especificando un número, tras el cual la
serie de números que devuelva la función {rand()} estará siempre
predeterminada.

{/}Ver: {#150,rand_seed()}

# ─────────────────────────────────────────────────────────────────────────────

{.150,rand_seed()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{rand_seed(}<valor numérico>{)}

{Descripción:}

Esta función establece una semilla para el generador de números aleatorios
(los números que genera la función {#149,rand()}).

Si se establece una semilla, que puede ser cualquier número entero dentro del
rango ({#1177,min_int} ... {#1178,max_int}), todos los números que genere
la función {#149,rand()} serán los mismos en cada ejecución del programa.
Es decir, tras establecerse una semilla de origen, la función {#149,rand()} devolverá
una serie de números predeterminada para dicha semilla.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_rand_seed;

PRIVATE
    tabla[15];
    contador;

BEGIN
    write (0, 0, 184, 0, "Pulse [ENTER] para introducir 1234 como semilla.");
    write (0, 0, 192, 0, "Pulse [ESPACIO] para hallar valores aleatorios.");
    FROM contador=0 TO 15;
        write_int(0, 0, contador*10, 0, offset tabla[contador]);
    END
    LOOP
        IF (scan_code==_space)
            FROM contador=0 TO 15;
                tabla[contador] = rand(-100, 100);
            END
        END
        IF (scan_code==_enter)

            rand_seed(1234); // Se introduce semilla para aleatorios.

        END
        FRAME;
    END
END
{-}

En el ejemplo se crea una tabla con 16 datos (del 0 al 15). En cada iteración
del bucle principal, cada vez que se pulse la barra espaciadora se rellenarán
los datos con valores aleatorios entre -100 y 100 (elegidos con la función
{#149,rand()}).

Y cuando se pulse la tecla ENTER, entonces se definirá la semilla de los
números aleatorios con la función {rand_seed()} como 1234.

Se puede observar cómo cada vez que se pulsa la tecla ENTER, luego, al pulsar
la barra espaciadora, siempre se obtiene la misma serie de números aleatorios
(17, 94, -38, ...). Para cada semilla posible; ésta serie será diferente.

{/}Ver: {#149,rand()}

# ─────────────────────────────────────────────────────────────────────────────

{.152,refresh_scroll()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{refresh_scroll(}<número de scroll>{)}

{Descripción:}

Esta función se utiliza cuando se ha modificado un gráfico con las funciones
{#137,map_put()}, {#139,map_xput()}, {#135,map_block_copy()} o {#138,map_put_pixel()} que
está siendo utilizado como {fondo de una región de scroll}, para actualizarlo.

La función requiere como parámetro el <número de scroll> que se especificó
al iniciar el scroll con la función {#163,start_scroll()}.

Cuando se modifica un gráfico que está siendo utilizado como fondo de un
scroll no se actualiza en pantalla automáticamente, sino que hay que llamar a esta
función para ello.

Una vez modificado el gráfico permanecerá así durante el resto de la
ejecución del programa, a no ser que se descargue el gráfico de memoria
(con {#169,unload_fpg()} o {#176,unload_map()}) y se vuelva a cargar, en
cuyo caso se recuperará el estado original del gráfico.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_refresh_scroll;

BEGIN
    load_fpg("help\help.fpg");
    start_scroll(0, 0, 103, 102, 0, 15);
    scroll.camera=id;
    write(0, 160, 192, 7, "Pulse [ENTER] para poner un gráfico en el scroll.");
    write(0, 160, 200, 7, "Pulse [ESPACIO] para actualizar scroll.");
    LOOP
        IF (scan_code==_enter)
           map_put(0, 103, 100, rand(16, 48), rand(16, 48));
        END
        IF (scan_code==_space)

            refresh_scroll(0); // Refrescamos el scroll 0.

        END
        x+=2;
        y+=1;
        FRAME;
    END
END
{-}

En el ejemplo se crea el scroll (número 0) como un scroll de dos planos:
el primero con el gráfico número 103 y el plano de fondo con el gráfico número 102.

Dentro del bucle principal se imprimirá una bola sobre el gráfico 103 (primer
plano del scroll) cuando se pulse la tecla ENTER. Pero éste no aparecerá
en pantalla a no ser que se espere a que el scroll entre poco a poco en
pantalla (con el gráfico 103 ya modificado), o bien se pulse la barra
espaciadora, en cuyo caso la llamada a la función {refresh_scroll()}
actualizará la ventana del scroll con el gráfico ya modificado.

Si en el ejemplo anterior se hubiera llamado a la función {refresh_scroll()}
justo a continuación de {#137,map_put()}, los gráficos impresos sobre el
primer plano aparecerían instantáneamente al pulsar la barra espaciadora.

En el ejemplo, cada vez que se imprime una bola aparecen muchas; esto es
debido a que el gráfico 103 utilizado como primer plano en el scroll
es un gráfico pequeño y se muestra varias veces, en mosaico, para rellenar
toda la zona de scroll.

{/}

{Nota:} Se puede observar que si el gráfico que se imprime está en unas
coordenadas fuera de pantalla, no será necesario llamar a esta función ya
que las partes del scroll que van entrando en pantalla se van refrescando
automáticamente.

{/}Ver: {#163,start_scroll()} - {#140,move_scroll()} - {#1101,Estructura scroll}

# ─────────────────────────────────────────────────────────────────────────────

{.153,reset_fli()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{reset_fli()}

{Descripción:}

Esta función {rebobina} hasta el principio una animación {FLI/FLC} que se
inició con la función {#161,start_fli()}.

Tras llamar a esta función, la animación se volverá a mostrar completa
desde el principio (para visualizar cada fotograma de la animación se debe
llamar a la función {#115,frame_fli()}).

La utilidad de esta función reside en poder parar una animación y, sin
descargarla ({#108,end_fli()}) y volverla a cargar, volver a repetirla
desde el principio.

Si una animación se quiere tocar indefinidamente, volviendo a empezar cuando
llegue al final, entonces {no es necesario utilizar esta función}, ya que
esto se hará de forma automática con {#115,frame_fli()}, si se sigue llamando
una vez haya terminado la animación.

Sólo es posible tener una animación a la vez, por lo que no es necesario
especificar ningún parámetro para esta función.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_reset_fli;
BEGIN
    start_fli("help\help.fli", 0, 0);
    write(0, 160, 0, 1, "Pulse [ESPACIO] para reiniciar la animación.");
    LOOP
        frame_fli();
        IF (scan_code==_space)

            reset_fli(); // Se inicializa la animación

        END
        FRAME;
    END
END
{-}

En el ejemplo se carga una animación con la función {#161,start_fli()} y
después se toca indefinidamente con la función {#115,frame_fli()}.

En el bucle se comprueba si se ha pulsado la barra espaciadora, y si está
pulsada se reinicializa con la función {reset_fli()}.

{/}Ver: {#161,start_fli()} - {#115,frame_fli()} - {#108,end_fli()}

# ─────────────────────────────────────────────────────────────────────────────

{.154,roll_palette()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{roll_palette(}<color inicial>{,} <número de colores>{,} <incremento>{)}

{Descripción:}

Rota una gama de colores de la paleta. Esta función sirve para crear efectos
de movimiento en gráficos estáticos, como el efecto del agua corriendo.

Para utilizar esta función se deben crear primero gráficos que utilicen
una gama de colores consecutivos de la paleta original, en un ciclo perpetuo,
por ejemplo, los colores del {0} al {15}, pintando algo con los colores
0, 1, 2, 3, ... , 14, 15, 0, 1, 2, ...

Después, hay que tener cuidado de que dichos colores no sean utilizados por
otros gráficos que vayan a aparecer en pantalla al mismo tiempo, si no se
quiere también el efecto en ellos.

El {incremento} (tercer parámetro) suele ser {1} para realizar la rotación
en un sentido y{ -1} para realizarla en el otro, pero se pueden utilizar otros
valores para realizar el ciclo de colores a más velocidad.

Para realizar un ciclo de los colores del {0} al {15} se especificaría {0}
como <color inicial> y {16} como <número de colores>.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_roll_palette;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 2);
    write(0, 160, 0, 1, "Pulse [ESPACIO] para rotar la paleta entera.");
    LOOP
        IF (scan_code==_space)

            roll_palette(0, 256, 1); // Se rotan los 256 colores.

        END
        FRAME;
    END
END
{-}

En el ejemplo se pone como fondo una pantalla multicolor y dentro del bucle
principal del programa se rotarán los 256 colores de la paleta cada vez que
se pulse la barra espaciadora.

{/}

Si se quiere determinar la paleta con la que se debe realizar el ciclo de
color, se debe cargar ésta de un archivo con la función {#133,load_pal()}.

{/}

Para realizar otros efectos de paleta, sin sustituir unos colores por otros
en ciclos, se debe utilizar la función {#110,fade()} que permite realizar
múltiples fundidos y saturaciones de color a diferentes velocidades.

Existen dos versiones simplificadas de esta última función que permiten
realizar un fundido a negro ({#111,fade_off()}) y deshacerlo ({#112,fade_on()}).

{/}Ver: {#133,load_pal()} - {#110,fade()} - {#111,fade_off()} - {#112,fade_on()}

# ─────────────────────────────────────────────────────────────────────────────

{.155,save()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{save(}<nombre de archivo>{,} <OFFSET dato>{,} <sizeof(dato)>{)}

{Descripción:}

Graba un bloque de datos desde la memoria del programa a un archivo en el disco
para recuperarlos después, cuando se requiera, con la función {#130,load()}.

Para ello, la función requiere el {nombre del archivo}, el desplazamiento dentro
de la memoria del ordenador de la variable, tabla o estructura guardada en
el disco (el desplazamiento del dato se obtiene con {#1085,OFFSET} {<nombre del dato>})
y el número de posiciones de memoria que ocupa dicho dato (lo que se puede obtener
con {#1094,sizeof}{(<nombre del dato>)}).

Es posible guardar varios datos (variables, tablas o estructuras) si estos
se han definido dentro de la misma sección ({#1006,GLOBAL}, {#1007,LOCAL}
o {#1008,PRIVATE}) y de forma consecutiva; en este caso se debe indicar
como {segundo parámetro} el {#1085,OFFSET} del primer dato, y como {tercer
parámetro} la suma de los {#1094,sizeof()} de todos los datos.

No es necesario especificar una ruta de acceso junto al nombre de archivo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load;

PRIVATE
    tabla[9];
    contador;

BEGIN
    write (0, 0, 0, 0, "Pulse [ENTER] para borrar los datos.");
    write (0, 0, 10, 0, "Pulse [ESPACIO] para cargar los datos del disco");
    write (0, 0, 30, 0, "Valores actuales de los datos:");
    FROM contador=0 TO 9;
        tabla[contador]=rand(0, 100);
        write_int(0, 0, 40+(contador*10), 0, offset tabla[contador]);
    END

    save("help\help.dat", offset tabla, sizeof(tabla)); // Se graba el archivo.

    LOOP
        IF (key(_enter))
            FROM contador=0 TO 9;
                tabla[contador]=0;
            END
        END
        IF (key(_space))
            load("help\help.dat", offset tabla);
        END
        FRAME;
    END
END
{-}

Al inicio del ejemplo se crea una tabla de 10 posiciones (del 0 al 9)
con valores aleatorios. Esta tabla se graba en el disco con la función
{save()}.

Cuando se pulsa la tecla ENTER se borran los valores de la tabla (se ponen
a 0 las 10 posiciones).

Cuando se pulsa la barra espaciadora se cargan los valores de la tabla
del disco con la función {#130,load()}.

{/}

Para grabar en el mismo archivo {tabla[9]} y la variable {contador} se
debería haber llamado a la función {save()} de la siguiente forma:

  {save("help\help.dat", offset tabla, sizeof(tabla)+sizeof(contador));}

No variando la instrucción de carga ({load("help\help.dat", offset tabla);}), ya
que ésta no requiere el número de datos.

El valor devuelto por {#1094,sizeof()} para cualquier variable (como {contador})
será siempre 1, y para una tabla el número de posiciones de la misma, luego
la sentencia de grabación podría ponerse como (teniendo en cuenta que se
van a grabar 11 datos, 10 de la tabla y 1 de la variable):

  {save("help\help.dat", offset tabla, 11);

{/}Ver: {#130,load()} - {#1085,OFFSET} - {#1094,sizeof()}

# ─────────────────────────────────────────────────────────────────────────────

{.156,set_fps()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{set_fps(}<nº de imágenes por segundo>{,} <nº de saltos permitidos>{)}

{Descripción:}

Esta función es la que regula la velocidad a la que van los juegos; define
el número de imágenes por segundo que se mostrarán del juego (el número de
fotogramas por segundo).

Por defecto la visualización se regulará a 18 imágenes por segundo, lo cual
quiere decir que si un proceso se mueve un punto por cada imagen ({FRAME}),
éste se moverá en pantalla a una velocidad de 18 puntos por segundo.

Esta función puede fijar el número de imágenes por segundo ({FPS}, Frames
Per Second) desde {4} como mínimo hasta {200} como máximo; en general no
son necesarias más de 24 imágenes por segundo para conseguir un movimiento
fluido y suave.

El segundo parámetro, {número máximo de saltos permitidos}, se refiere a cómo
es preferible que se comporte el programa cuando se ejecute en un ordenador
que sea lo suficientemente rápido como para calcular el número de imágenes
por segundo que se solicita. Funciona como se muestra a continuación.

{Número de saltos permitidos.}

{0} - El juego irá a menos velocidad cuando se ejecute en un ordenador demasiado
lento, es decir, se mostrarán las imágenes por segundo que a ese ordenador
le de tiempo a calcular.

{1} - Si el ordenador no puede calcular todas las imágenes, se le permite que
de vez en cuando omita alguna imagen para intentar mantener la velocidad
relativa del juego. El juego se verá un poco más brusco, pero más rápido.

{2 o más} - Se permite al juego que salte tantas imágenes consecutivas como
se indica en este parámetro con tal de mantener la velocidad relativa original
del juego. Por ejemplo, si se fija el número de saltos a {4} y en el juego un
proceso se desplazaba de un punto en un punto, en un ordenador muy lento se
podría llegar a desplazar de hasta 4 puntos en 4 puntos.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_set_fps;

PRIVATE
    imágenes=24;
    saltos=4;

BEGIN
    load_fpg("help\help.fpg");
    graph=1;
    x=160;
    y=100;
    write(0, 0, 0, 0, "Imágenes por segundo: Arriba(+) / Abajo(-)");
    write_int(0, 0, 10, 0, offset imágenes);
    write(0, 0, 20, 0, "Saltos permitidos: Derecha(+) / Izquierda(-)");
    write_int(0, 0, 30, 0, offset saltos);
    write(0, 160, 200, 7, "Utilice los CURSORES para cambiar los valores.");
    LOOP

        // Se elige el número imagenes por segundo
        set_fps(imágenes, saltos);

        IF (key(_up) AND imágenes<200) imágenes++; END
        IF (key(_down) AND imágenes>4) imágenes--; END
        IF (key(_right) AND saltos<20) saltos++; END
        IF (key(_left) AND saltos>0) saltos--; END
        angle+=4000;
        FRAME;
    END
END
{-}

En el ejemplo se imprimen los mensajes necesarios y el proceso
principal crea un gráfico en el centro de la pantalla rotando
indefinidamente.

En cada paso del bucle se detectan las teclas del cursor, se cambia
el número de imágenes por segundo ({imágenes}) con {arriba/abajo} y
el máximo número de saltos permitidos ({saltos}) con {derecha/izquierda}.

Al comienzo de cada iteración del bucle se establece la velocidad según
los valores de ambas variables, con la función {set_fps()}.

{/}Ver: {#1029,FRAME} - {#1115,max_process_time} -{#157,set_mode()}

# ─────────────────────────────────────────────────────────────────────────────

{.157,set_mode()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{set_mode(}<nuevo modo de vídeo>{)}

{Descripción:}

Fija un nuevo modo de vídeo para la ejecución del juego. Los modos de vídeo
soportados que se pueden especificar como parámetro son:

  {m320x200}  - VGA estándar·
  {m320x240}  - Modo X·
  {m320x400}  - Modo X·
  {m360x240}  - Modo X·
  {m360x360}  - Modo X·
  {m376x282}  - Modo X·
  {m640x400}  - SVGA VESA·
  {m640x480}  - SVGA VESA·
  {m800x600}  - SVGA VESA·
  {m1024x768} - SVGA VESA·

Al realizarse un cambio de modo de vídeo en el programa se realizará
automáticamente un fundido a negro (de la paleta de colores del programa) y
en las siguientes visualizaciones del juego se irá restaurando gradualmente
la paleta de colores, es decir, {set_mode()} realiza siempre un {#111,fade_off()}
justo antes de cambiar el modo de vídeo y un {#112,fade_on()} justo después
de haberlo cambiado.

Por defecto todos los programas comienzan con el modo de 320 por 200 puntos
activado ({set_mode(m320x200)}).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_set_mode;

PRIVATE
    modos[]=
        m320x200, m320x240, m320x400, m360x240, m360x360,
        m376x282, m640x400, m640x480, m800x600, m1024x768;
    modovideo=0;

BEGIN
    load_fpg("help\help.fpg");
    write (0, 0, 0, 0, "Pulse [ESPACIO] para cambiar el modo de vídeo");
    LOOP
        IF (scan_code==_space)
            modovideo=modovideo+1;
            IF (modovideo==10) modovideo=0; END

            set_mode(modos[modovideo]);

        END
        FRAME;
    END
END
{-}

En el ejemplo se pone un fondo de pantalla y un texto explicativo.

En la iteración del bucle principal, si se pulsa la barra espaciadora, se
activará un nuevo modo de vídeo con la función {set_mode()}.

{/}

{Importante:} Al utilizar la función {set_mode()} se eliminarán todas las ventanas de
scroll y de modo 7 que estuvieran activas en el juego y todos los procesos
que se estuvieran visualizando en ellas.

{/}Ver: {#156,set_fps()} - {#1115,max_process_time} - {#1150,Constantes m320x200 ... m1024x768}

# ─────────────────────────────────────────────────────────────────────────────

{.158,signal()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{signal(}<id>{,} <señal>{)}

{Descripción:}

Manda una señal a un proceso (un objeto del juego). Esta función se utiliza
principalmente (aunque no sólo) para destruir (matar) a un proceso desde otro, enviándole una
señal {#1153,s_kill}.

Si desconoce a qué se hace referencia cuando se habla del proceso padre, hijo,
{hermano}, un proceso {huérfano}, etc., entonces vea {#1041,Jerarquías de procesos}.

Si desconoce los términos vivo, {muerto}, {dormido}, etc., referidos a
procesos, vea {#1040,Estados de un proceso}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE id2;
BEGIN
    id2=mi_proceso();
    // ...
    signal(id2, s_kill);
END
PROCESS mi_proceso()
BEGIN
    // ...
    LOOP
        FRAME;
    END
END
{-}

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 {#1039,código identificador} del proceso que se va a destruir).

Cualquier proceso puede enviar una señal a otro, siempre que disponga de su
{#1039,código identificador}, ver:

  {#1039,Códigos identificadores de procesos}·
  {#1038,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:

{#1153,s_kill} - Orden de {matar} al proceso, el proceso ya no aparecerá en las
siguientes imágenes del juego.

{#1155,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}).

{#1156,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}).

{#1154,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 {#1039,código identificador} de un proceso es siempre {#1092,ID} (palabra
reservada en el lenguaje para tal fin). La sentencia sería como la siguiente:

{signal(}{#1092,id}{,} <señal>{)}

Auto-eliminar un proceso de esta forma, enviándose una señal {#1153,s_kill}, no
destruirá el proceso instantáneamente, sino en la próxima visualización
({#1029,FRAME}). Para eliminar un proceso de forma inmediata se
puede utilizar la sentencia {#1028,RETURN}.

{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 ({#1029,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: {#1157,s_kill_tree}, {#1158,s_sleep_tree},
{#1160,s_freeze_tree} y {#1159,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 {#1157,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ó.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_signal;
PRIVATE
    id_text;
BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 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) AND NOT son)
            delete_text(id_text);
            mi_proceso();
            id_text=write(0, 0, 190, 0, "Proceso vivo");
        END
        IF (key(_2) AND son)
            delete_text(id_text);
            signal(son, s_kill);
            id_text=write(0, 0, 190, 0, "No hay proceso");
        END
        IF (key(_3) AND son)
            delete_text(id_text);
            signal(son, s_sleep);
            id_text=write(0, 0, 190, 0, "Proceso dormido");
        END
        IF (key(_4) AND son)
            delete_text(id_text);
            signal(son, s_freeze);
            id_text=write(0, 0, 190, 0, "Proceso congelado");
        END
        IF (key(_5) AND son)
            delete_text(id_text);
            signal(son, s_wakeup);
            id_text=write(0, 0, 190, 0, "Proceso vivo");
        END
        FRAME;
    END
END

PROCESS mi_proceso()
BEGIN
    graph=100;
    LOOP
        x=160+get_distx(angle, 140);
        y=100+get_disty(angle, 80);
        angle+=5000;
        FRAME;
    END
END
{-}

Este 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 {#1039,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 {#1118,son} del padre con el
{#1039,código identificador} del hijo, y la variable {#1117,father} del hijo con el código
identificador del padre.

{/}

{signal(}{#1042,TYPE} <nombre de 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 {#1039,código identificador}, permite enviar una señal {a todos los procesos
de un tipo determinado} o a ellos y su descendencia si se utilizan las
señales como {s_kill_tree} (ver: {#1042,Tipos de procesos}).

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:

  {signal(TYPE enemigo, s_freeze);}

Como se puede observar para enviar una señal a un proceso en concreto se
necesita su {#1039,código identificador} y para destruir a un grupo de procesos,
que estos sean todos del mismo tipo, que se trate de un proceso y su
descendencia, o bien conocer todos sus identificadores (para enviarles la
señal uno a uno).

Se puede enviar una señal a un tipo de procesos aun cuando no exista
ningún proceso de ese tipo ejecutándose en el juego. Pero si se envía una
señal a un proceso que ya ha muerto, con su {#1039,código identificador} (primera
acepción de la sentencia {signal}), se corre el riesgo de que dicho
{#1039,código identificador} ahora sea usado por otro proceso, siendo éste el que
reciba la señal. Esto es si, por ejemplo, se pretende matar a un proceso que ya
está muerto, cabe la posibilidad de que se esté matando a otro.

{/}

{Nota:} Si se quieren eliminar todos los procesos y dejar únicamente al proceso
actual, se puede utilizar la función {#129,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: {#129,let_me_alone()} - {#1039,Códigos identificadores} - {#1042,Tipos de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.159,sound()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{sound(}<código del sonido>{,} <volumen>{,} <frecuencia>{)}

{Retorna:}

El {número de canal} por el que se reproduce el sonido.

{Descripción:}

Hace sonar el efecto cuyo {código de sonido} se especifica como primer parámetro.
Primero, el sonido se debe haber cargado de un archivo PCM con la función {#134,load_pcm()}
que es la que devuelve el {código de sonido} correspondiente a dicho efecto.

Como segundo parámetro se debe especificar el {volumen} al que se desea reproducir
el sonido, siendo {0} el volumen mínimo y {256} el volumen máximo.

Como tercer parámetro se especificará la {frecuencia} (velocidad) a la que se
desea reproducir el sonido, siendo {256} la frecuencia estándar que reproducirá
el sonido original; a valores menores el sonido se reproducirá más grave, mientras qu a valores
mayores de frecuencia, más agudo.

La función devuelve el {número de canal} que puede ser utilizado por las funciones
{#167,stop_sound()} para detener el sonido y {#102,change_sound()} para modificar su volumen o
su frecuencia.

Existen un total de 16 canales de sonido, pudiendo sonar hasta 16 sonidos
simultáneamente.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_sound;

PRIVATE
    volumen=128;        // Valor medio (0..256)
    frecuencia=256;     // Valor medio (0..512)
    id_sonido, canal;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write(0, 0, 0, 0, "Volumen: Arriba(+) / Abajo(-)");
    write_int(0, 0, 10, 0, offset volumen);
    write(0, 0, 20, 0, "Frecuencia: Derecha(+) / Izquierda(-)");
    write_int(0, 0, 30, 0, offset frecuencia);
    write(0, 160, 180, 1, "Pulse [ESPACIO] para emitir el el sonido.");
    write(0, 160, 190, 1, "Utilice los cursores para cambiar los valores.");

    id_sonido = load_pcm("help\help.pcm", 0);

    LOOP
        IF (scan_code==_space)

            // Hace que suene
            canal = sound(id_sonido, volumen, frecuencia);

        END
        IF (key(_up) AND volumen<256) volumen++; END
        IF (key(_down) AND volumen>0) volumen--; END
        IF (key(_right) AND frecuencia<512) frecuencia++; END
        IF (key(_left) AND frecuencia>0) frecuencia--; END
        FRAME;
    END
END
{-}

En el ejemplo se pone una pantalla de fondo y un texto explicativo,
y se carga un sonido con la función {#134,load_pcm()}; ésta devuelve el
{identificador del sonido}, que se guarda en la variable {id_sonido}.

En el bucle principal, a cada pulsación de la barra espaciadora, se
emitirá el sonido con la función {sound()} con los parámetros definidos
en las variables {volumen} y {frecuencia}.

Con las teclas de los cursores se podrán manipular estos valores para
comprender así mejor su funcionamiento.

El {número de canal} devuelto por {sound()}, que se guarda en la variable
{canal}, se podría haber utilizado para modificar el sonido con {#102,change_sound()}
o pararlo con {#167,stop_sound()}.

{/}Ver: {#134,load_pcm()} - {#170,unload_pcm()} - {#102,change_sound()} - {#167,stop_sound()}

# ─────────────────────────────────────────────────────────────────────────────

{.160,sqrt()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{sqrt(}<expresión>{)}

{Retorna:}

La raíz cuadrada entera de la expresión.

{Descripción:}

Calcula la raíz cuadrada de la expresión pasada como parámetro, {truncada a
un número entero}.

Por ejemplo, {sqrt(10)} devolverá como resultado {3} y no {3.1623} que es
el valor real (aproximado) de la raíz cuadrada de diez.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_sqrt;

GLOBAL
    valores[15];
    n;

BEGIN
    FROM n=0 to 15;
        valores[n]=rand(0, 100000);
        write_int(0, 0, n*10, 0, offset valores[n]);
    END
    write(0, 0, 192, 0, "Pulse [ESPACIO] para calcular su raíz cuadrada");
    LOOP
        IF (scan_code==_space)
            FROM n=0 TO 15;

                valores[n] = sqrt(valores[n]);

            END
        END
        FRAME;
    END
END
{-}

Este programa imprimirá en pantalla una lista de valores aleatoriamente
seleccionados; cuando se pulse la barra espaciadora le aplicará
la función {sqrt()} a todos estos valores, calculando su raíz cuadrada.

{/}Ver: {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.161,start_fli()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{start_fli(}<nombre de archivo>{,} <x>{,} <y>{)}

{Retorna:}

Número de imágenes de la animación.

{Descripción:}

Inicia una animación {FLI/FLC} contenida en el {archivo} especificado, en las
coordenadas ({x}, {y}) (se debe especificar la coordenada superior izquierda
de la ventana de visualización).

En el <nombre de archivo> se puede especificar la ruta de acceso, no siendo
ésta necesaria si el archivo se encuentra en el directorio de DIV Games
Studio o en un subdirectorio cuyo nombre coincida con la extensión del
archivo (por ejemplo, "fli\anima.fli").

La animación debe coger por completo en pantalla, es decir, si la animación
ocupa toda la pantalla, se debe fijar primero el modo de vídeo con la función
{#157,set_mode()} y después iniciar con {start_fli()} la animación en las
coordenadas (0, 0).

La función devuelve, a título informativo, el número de fotogramas de los
que consta la animación completa.

El sistema activará automáticamente las paletas de color que pudiera tener
la animación {FLI/FLC}, lo que puede presentar problemas en la representanción
de otros gráficos o fuentes del programa, si éstos hubieran sido dibujados con
una paleta diferente.

Si se pretenden combinar otros gráficos con la animación en pantalla, ésta
debe tener una única paleta de color (lo que se suele denominar "{palette low FLI/FLC}")
y los gráficos se deben haber dibujado con esa misma paleta.

Una vez iniciada la animación se irán mostrando los fotogramas de la misma
con respectivas llamadas a {#115,frame_fli()}.

{Sólo es posible tener una animación activa en cada momento}, por lo que después
de haberse iniciado una animación con {start_fli()} y haberse visualizado con
{#115,frame_fli()}, se debe finalizar ésta con la función {#108,end_fli()} antes
de iniciar otra animación diferente.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_start_fli;
BEGIN

    start_fli("help\help.fli", 0, 0); // Se inicia una animación.

    LOOP
        frame_fli();
        FRAME;
    END
END
{-}

En el ejemplo se inicia la animación contenida en el archivo {help\help.fli} con
la función {start_fli()} en las coordenadas (0, 0) y se ejecuta esta animación
indefinidamente.

{/}

La función {#115,frame_fli()} utilizada para mostrar cada fotograma devolverá
0 cuando la animación haya finalizado, por lo que para mostrar la animación
una sola vez se debería haber hecho:

{#9999,Programa ejemplo:}
PROGRAM ejemplo_start_fli;

PRIVATE
    valor;

BEGIN
    start_fli("help\help.fli", 0, 0);
    REPEAT
        valor=frame_fli();
        FRAME;
    UNTIL (valor==0);
    end_fli();
END
{-}

La función {#153,reset_fli()} permite {rebobinar} la animación, para que
la función {#115,frame_fli()} continúe ejecutándola desde el principio.

{/}Ver: {#108,end_fli()} - {#153,reset_fli()} - {#115,frame_fli()}

# ─────────────────────────────────────────────────────────────────────────────

{.162,start_mode7()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{start_mode7(}<número de m7>{,} <fichero>{,} <gráfico>{,} <gráfico exterior>{,}
              <número de región>{,} <altura del horizonte>{)}

{Descripción:}

Ésta es una función avanzada que requiere que el usuario tenga cierta
soltura para poder utilizarla.

Crea una ventana de visualización de un modo-7, es decir, visualiza un gráfico
{tridimensionalmente} en un plano abatido; para conseguir este efecto se llamará
a esta función con los siguientes parámetros:

{<número de m7>} - Se pueden crear hasta 10 ventanas de modo-7 en pantalla,
con los número del {0} al {9}; si únicamente se quiere crear una, lo mejor
es definir la número {0}. Este número será necesario posteriormente para
modificar los parámetros de la ventana, pues el sistema necesitará saber
cuál de las {10} posibles ventanas de modo-7 se quiere alterar.

{<fichero>} - Los gráficos que se pretendan abatir en la ventana deben estar
en un fichero cuyo {código de fichero} se debe especificar aquí, como
segundo parámetro de la función. Los gráficos cargados con la función
{#174,load_map()} se utilizarán como si pertenecieran al primer fichero (el
fichero con el código 0).

{<gráfico>} - El tercer parámetro debe ser el {código del gráfico} principal
que se va a abatir en la ventana y debe pertenecer al fichero anteriormente
indicado.

{<gráfico exterior>} - Aquí se puede indicar un {0} si no se quiere que se
vea ningún gráfico más allá del gráfico abatido en la perspectiva, o bien un {código
de gráfico} del mismo fichero que se mostrará en la perspectiva más allá
del {gráfico principal}, hasta alcanzar el horizonte. Este gráfico debe
ser de un ancho y alto potencia de dos, no mayor de {8192} (estas potencias
de dos son: 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096 y 8192),
por ejemplo, podría ser un gráfico de 64 puntos de ancho por 32 de alto; este
gráfico se mostrará también abatido.

{<número de región>} - Aquí se indicará la región rectangular de pantalla
en la que se va a mostrar el modo-7. Si se indica {0} como número de región,
se mostrará en toda la pantalla. El resto de regiones se deben definir
previamente con la función {#106,define_región()} (una {región} no es más
que una zona rectangular de la pantalla).

{<altura del horizonte>} - Como último parámetro se indicará a cuántos puntos
desde la parte superior de la ventana se quiere situar la línea del horizonte.
Si la cámara se sitúa por encima del plano abatido, entonces no se mostrará
nada por encima de la línea del horizonte (ese hueco se suele rellenar con
otra ventana de scroll o de modo-7); en cambio si la camara se sitúa por debajo
del plano, entonces no se mostrará nada por debajo de la línea del horizonte.

{/}

{Además de la llamada a la función se deben inicializar algunos valores de
la} {#1102,estructura global m7} {para el correcto funcionamiento de la ventana}.
Ésta es una estructura de 10 registros (uno para cada posible ventana de modo-7)
y cada registro tiene los siguientes campos:

  {camera}   - {#1039,Código identificador} de la cámara·
  {height}   - Altura de la cámara·
  {distance} - Distancia de la cámara·
  {horizon}  - Altura del horizonte·
  {focus}    - Focal de visión·
  {z}        - Plano de profundidad·
  {color}    - Color del exterior·

{Importante:} El campo {camera} es {imprescindible} inicializarlo para que
se active la ventana de modo 7 ya que, sin este campo, la ventana no puede determinar
desde dónde se debe {ver} el plano abatido.

La cámara se situará en el plano abatido a la distancia ({distance}) indicada
del proceso cuyo {#1039,código identificador} se haya puesto en {camera}, y
mirando en su mismo ángulo (el que indique su variable local {#1129,angle}).
La altura a la que se sitúa la cámara respecto al suelo será la indicada en el
campo {height}.

Ver la ayuda sobre la {#1102,estructura m7} para más información sobre
estos campos, o para saber cómo acceder a ellos.

{/}

{#9999,Programa ejemplo:}
PROGRAM ejemplo_start_mode7;

PRIVATE
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");

    start_mode7(0, fichero1, 4, 0, 0, 64);

    m7.height = 64;
    m7.distance = 32;
    m7.color = 162;
    m7.camera = id;

    write(0, 160, 0, 1, "Utilice los cursores para moverse");
    LOOP
        IF (key(_right)) angle-=8000; END
        IF (key(_left)) angle+=8000; END
        IF (key(_up)) advance(6); END
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y entonces se crea un modo 7
tridimensional con la función {start_mode7()}. A esta última se le pasan
los siguientes parámetros:

{0} - Número de ventana de modo 7 (la primera, puesto que sólo se creará
una ventana de esta clase).

{fichero1} - Código del fichero del que se deben tomar los gráficos; este
es el código del archivo {help.fpg} que se cargó con la función {#132,load_fpg()}.

{4} - Código del gráfico principal a abatir dentro del modo 7; para ver
este gráfico se debe cargar el fichero con el {Menú de ficheros} y así poder
observar cuál es el gráfico con {código 4}.

{0} - Código de gráfico secundario, con un 0 se indica que no habrá gráfico
secundario (exterior) en el modo 7, luego el exterior se visualizará del
color que indique la variable {m7[0].color}. Para observar el efecto de poner
un {gráfico exterior} se puede cambiar este parámetro, por ejemplo, por un
{100} (que es el código de una bola marrón de 32 por 32 puntos en el fichero
{help.fpg}).

{0} - Número de región de la pantalla en la que se debe {colocar} el modo 7;
con 0 se indica que se debe colocar en la pantalla entera.

{64} - Altura del horizonte, con este último parámetro se indica que la línea
del horizonte se situará a 64 puntos del inicio superior de la ventana.

Tras llamar a la función {start_mode7()} el programa define los siguientes
valores de la {#1102,estructura global m7}:

{m7.height=64;} - Para indicar que la cámara se debe situar a 64 puntos sobre
el suelo.

{m7.distance=32;} - Para indicar que la cámara se debe situar 32 puntos por
detrás del proceso cámara.

{m7.color=162;} - Para indicar que el exterior se debe visualizar del color
número 162 de la paleta.

{m7.camera=}{#1092,id}{;} - Para indicar que el proceso cámara será el proceso actual.

La cámara se situará 32 puntos por detrás del proceso principal, a 64 puntos
de altura y mirando en el ángulo que indique la variable {#1129,angle} del
mismo.

Tras estas inicializaciones el programa ejemplo se quedará en un bucle que
simplemente controla con los cursores el ángulo ({#1129,angle}) del proceso
principal, que será el ángulo de la cámara y, cuando se pulse la tecla {cursor
arriba}, se llamará a la función {#101,advance()} para que el proceso principal
avance 6 puntos (y por consiguiente la cámara del modo 7).

{/}{Cómo visualizar gráficos de procesos sobre el modo 7.}{/}

Para crear un proceso cuyo gráfico se visualice en el modo 7, se debe
definir su variable local {#1122,ctype} como {#1169,c_m7} ({tipo de coordenada}
como {coordenada de modo 7}), lo que se hará con la siguiente sentencia:

  {ctype=c_m7;}

Una vez hecho esto el proceso se visualizará en el modo 7 con su gráfico ({#1126,graph})
escalado acorde a la distancia a la que esté. El proceso únicamente debe
modificar sus variables {#1123,x} e {#1124,y} para moverse por el plano abatido.

{/}

{Cuando un proceso pertenezca al modo-7 (se haya asignado el valor c_m7 a su
variable local} {#1122,ctype}{):}

  - Sus variables {#1123,x} e {#1124,y} estarán referidas al punto del gráfico
principal abatido sobre el cual se situará el gráfico del proceso.

  - Su variable {#1125,z} perderá su efecto, ya que los gráficos aparecerán
ordenados por estricto orden de profundidad. Esta variable valdrá únicamente
para indicar prioridades de impresión en gráficos que se sitúen, exactamente,
en la misma profundidad del plano.

  - El proceso será eliminado automáticamente cuando se elimine la ventana
de modo 7 a la que pertenece el proceso, con la función {#165,stop_mode7()},
o cuando se cambie el modo de vídeo con la función {#157,set_mode()}, ya que
al hacerlo se eliminarán también las ventanas de modo 7.

{/}

Si hubiera varias ventanas de {modo 7} el proceso se visualizaría por defecto
en todas, si únicamente se tuviera que visualizar el algunas de ellas, se debería
definir su variable local {#1134,cnumber}. Por ejemplo, si hubiera 6 ventanas
de modo 7 (de la número 0 a la 5) y se quisiera que un proceso se visualizara
únicamente en las ventanas 0 y 2, se debería incluir en el mismo la siguiente
sentencia:

  {cnumber=c_0+c_2;}

{/}

Para que un proceso tenga varios gráficos (varias vistas), dependiendo
del ángulo desde el que se le mire, se debe definir su gráfico con la
variable local {#1132,xgraph} (en lugar de la variable {#1126,graph}).
Para definir esta variable primero se debe crear una tabla (de cualquier
nombre) indicando en primer lugar el {número de vistas} del gráfico y después
los {códigos de los gráficos} para estas vistas, comenzando por el {ángulo
0} y en sentido contrario a las agujas del reloj. Por ejemplo:

  {GLOBAL}·
    {vistas_coche[]=4, 100, 101, 102, 103;}·

La tabla {vistas_coche} definiría 4 vistas: el gráfico 100 para ángulos
próximos a 0 grados, el gráfico 101 para ángulos próximos a 90 grados,
el 102 para ángulos próximos a 180 grados, etc.

Y después en el código del proceso se debería inicializar la variable
{#1132,xgraph} con la siguiente sentencia:

  {xgraph=OFFSET vistas_coche;}

Para poder observar un ejemplo de lo aquí expuesto, lo mejor es examinar
alguno de los juegos ejemplo de DIV Games Studio que utilizan esta técnica,
por lo que se remite al lector directamente a los comentarios de estos
programas (por ejemplo véase el ejemplo {Speed for dummies}).

{/}Ver: {#165,stop_mode7()} - {#1102,Estructura m7}

# ─────────────────────────────────────────────────────────────────────────────

{.163,start_scroll()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{start_scroll(}<número de scroll>{,} <fichero>{,} <gráfico>{,} <gráfico fondo>{,}
               <número de región>{,} <indicador de bloqueo>{)}

{Descripción:}

Esta es una función de cierta complejidad, que requiere que el usuario tenga
cierta soltura (haya realizado algún programa antes) para poder utilizarla.

Crea una ventana de scroll, en la que se realizará una panorámica sobre
un gráfico de fondo (el decorado del juego). Es decir, utilizando como fondo
del juego un gráfico más grande que la ventana de visualización, se podrá
mostrar una parte del mismo e ir desplazándolo en cualquier dirección.

Para conseguir este efecto se llamará a esta función con los siguientes
parámetros:

{<número de scroll>} - Se pueden crear hasta 10 ventanas de scroll en pantalla,
con los números del {0} al {9}; si sólo se quiere crear una, lo mejor
es definir la número {0}. Este número será necesario posteriormente para
modificar los parámetros de la ventana, pues el sistema necesitará saber
cuál de las {10} posibles ventanas de scroll se quiere alterar.

{<fichero>} - Los gráficos que se pretendan mostrar como fondo o decorado
en dicha ventana deben estar en un fichero cuyo {código de fichero} se debe
especificar aquí, como segundo parámetro de la función. Los gráficos cargados
con la función {#174,load_map()} se utilizarán como si pertenecieran al
primer fichero (el fichero con el código 0).

{<gráfico>} - El tercer parámetro debe ser el {código del gráfico} principal
que se va a mostrar como fondo en la ventana y debe pertenecer al fichero anteriormente
indicado. Este gráfico suele ser el decorado principal del juego sobre el que
se va a desarrollar la acción, un gráfico más grande que la ventana de visualización,
que se irá desplazando en una o varias direcciones y sobre el que se situarán
los gráficos del juego.

La ventana de scroll se situará inicialmente con el {#1136,punto de control}
número {0} de este gráfico en la esquina superior izquierda, cuando se haya
definido este punto en el {editor gráfico}.

{<gráfico fondo>} - Aquí se indicará un {0} si se quiere un solo plano de
scroll (un solo gráfico de fondo), o bien otro {código de gráfico} si se
quiere que éste aparezca como segundo plano de scroll (a mayor profundidad),
detrás del plano principal. Para que se vea este plano de fondo es
imprescindible que el {gráfico principal} (primer plano) tenga partes
dibujadas con el color número 0 de la paleta, pues estas zonas transparentes
serán las que permitirán ver a través de ellas el {gráfico de fondo}.

{<número de región>} - Aquí se indicará la región rectangular de pantalla
en la que se va a mostrar el scroll, si se indica {0} como número de región,
se mostrará en toda la pantalla. El resto de regiones se deben definir
previamente con la función {#106,define_region()} (una {región} no es más
que una zona rectangular de la pantalla).

{<indicador de bloqueo>} - Aquí se indicará un valor que define si cada uno
de los dos planos de scroll es cíclico en horizontal y vertical. Por ejemplo,
un plano es cíclico en horizontal cuando al salirse del dibujo por la derecha
aparece el dibujo por la izquierda. Para componer este valor se deben sumar
las siguientes cantidades:

 { + 1} - Si el primer plano es cíclico horizontalmente.·
 { + 2} - Si el primer plano es cíclico verticalmente.·
 { + 4} - Si el segundo plano es cíclico horizontalmente.·
 { + 8} - Si el segundo plano es cíclico verticalmente.·

Es decir, {0} si ninguno de los dos planos debe ser cíclico, {15} ({1}+{2}+{4}+{8})
si ambos planos deben ser cíclicos en ambos ejes, {12} ({4}+{8}) si únicamente
debe ser cíclico el segundo plano, etc.

Cuando un gráfico (principal o de fondo) sea más pequeño que la ventana de visualización,
el sistema forzará a que su plano de scroll sea cíclico pues, en caso contrario,
no se podría rellenar la ventana de scroll por completo, sin repetir {cíclicamente}
el gráfico (en mosaico).

{/}

{Además de la llamada a la función se deben inicializar algunos valores de
la} {#1101,estructura global scroll} {para el correcto funcionamiento de la ventana}.
Ésta es una estructura de 10 registros (uno para cada posible ventana de scroll)
y cada registro tiene los siguientes campos:

  {x0, y0}  - Coordenadas del primer plano·
  {x1, y1}  - Coordenadas del segundo plano·
  {z}       - Plano de profundidad·
  {camera}  - {#1039,Código identificador} de la cámara·
  {ratio}   - Velocidad relativa del segundo plano·
  {speed}   - Velocidad máxima del primer plano·
  {region1} - Primera región de pantalla·
  {region2} - Segunda región de pantalla·

Hay dos formas de programar el movimiento de las ventanas de scroll:

- Manualmente, modificando en cada imagen del juego los campos {x0}, {y0},
{x1} e {y1} de esta estructura (las coordenadas de los planos de scroll).

- Automáticamente, para lo que se necesita el {#1038,código identificador}
de un proceso en el campo {camera} de esta estructura. Siendo a partir de
entonces el sistema el encargado de realizar en la ventana de scroll un
seguimiento al gráfico de este proceso.

Ver la ayuda sobre la {#1101,estructura scroll} para más información sobre
estos campos, o para saber cómo acceder a ellos.

{/}

{#9999,Ejemplo de scroll AUTOMATICO:}
PROGRAM ejemplo_start_scroll;

PRIVATE
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");

    start_scroll(0, fichero1, 103, 102, 0, 15);

    scroll.camera=id;

    ctype=c_scroll;
    graph=100;
    write(0, 160, 0, 1, "Utilice los cursores para moverse");
    LOOP
        IF (key(_right)) x+=2; END
        IF (key(_left)) x-=2; END
        IF (key(_down)) y+=2; END
        IF (key(_up)) y-=2; END
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y entonces se crea una ventana
de scroll con la función {start_scroll()}. A esta última se le pasan
los siguientes parámetros:

{0} - Número de ventana de scroll (la primera, puesto que sólo se creará
una ventana de esta clase).

{fichero1} - Código del fichero del que se deben tomar los gráficos; este
es el código del archivo {help.fpg} que se cargó con la función {#132,load_fpg()}.

{103} - Código del gráfico principal (primer plano) del scroll, para ver
este gráfico se debe cargar el fichero con el {Menú de ficheros} y así poder
observar cuál es el gráfico con {código 103}.

{102} - Código de gráfico secundario (segundo plano, de fondo); éste es el
gráfico que se mostrará en la ventana de scroll {detrás} del gráfico principal.

{0} - Número de región de la pantalla en la que se debe {colocar} el scroll;
con 0 se indica que se debe colocar en la pantalla entera.

{15} - Indicador de bloqueo, con 15 (1+2+4+8) se indica que tanto el primer
plano como el segundo serán cíclicos en ambos ejes (horizontal y vertical).

Tras llamar a la función {start_scroll()} el programa define el campo {camera}
de la {#1101,estructura scroll}, asignándole el {#1039,código identificador}
del proceso principal (con la sentencia {scroll.camera=}{#1092,id}{;}); con esto se convierte
el scroll en {automático} siguiendo a partir de ese momento al gráfico del proceso
principal.

El programa continúa definiendo su {tipo de coordenada} como {coordenada de
scroll} (con la sentencia {ctype=c_scroll;}), definiendo su gráfico como
el número 100, que es una bola marrón (con {graph=100;}), imprimiendo un mensaje
y después permanecerá en un bucle en el que se pueden variar las coordenadas
de este proceso (las variables {#1123,x} e {#1124,y}) con las teclas de los
cursores.

{/}

{#9999,Ejemplo de scroll MANUAL:}
PROGRAM ejemplo_start_scroll;

PRIVATE
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");

    start_scroll(0, fichero1, 103, 102, 0, 15);

    write(0, 160, 0, 1, "Utilice los cursores desplazar el scroll");
    LOOP
        IF (key(_right))
            scroll.x0+=2;
            scroll.x1+=1;
        END
        IF (key(_left))
            scroll.x0-=2;
            scroll.x1-=1;
        END
        IF (key(_down))
            scroll.y0+=2;
            scroll.y1+=1;
        END
        IF (key(_up))
            scroll.y0-=2;
            scroll.y1-=1;
        END
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y entonces se crea una ventana
de scroll con la función {start_scroll()}. A esta última se le pasan
exactamente los mismos parámetros que en el ejemplo anterior.

Tras esto, el programa permanecerá en un bucle dentro del cual; al detectarse
las teclas de los cursores se variarán los campos {x0}, {y0}, {x1} e {y1} de
la {#1101,estructura global scroll}, los cuales definen las coordenadas de
los dos planos del scroll ({x0}, {y0} son las del primer plano y {x1}, {y1}
las del segundo).

Se puede observar la diferencia entre ambos métodos; este último, al no
haber inicializado el campo {camera} de la estrucutra, podrá manipular
directamente las coordenadas de ambos planos.

{/}{Cómo visualizar gráficos de procesos sobre el scroll.}{/}

Para crear un proceso cuyo gráfico se visualice en la ventana de scroll, se debe
definir su variable local {#1122,ctype} como {#1168,c_scroll} ({tipo de coordenada}
como {coordenada de scroll}), lo que se hará con la siguiente sentencia:

  {ctype=c_scroll;}

Una vez hecho esto, el proceso se visualizará en el scroll con su gráfico
(definido en la variable local {#1126,graph}). El proceso únicamente debe
modificar sus variables {#1123,x} e {#1124,y} para moverse por el scroll.

{/}

{Cuando un proceso pertenezca al scroll (se haya asignado el valor c_scroll a su
variable local} {#1122,ctype}{):}

  - Sus variables {#1123,x} e {#1124,y} estarán referidas al punto del gráfico
del primer plano sobre el cual se situará el gráfico del proceso.

  - Su variable {#1125,z} ahora será relativa a las {variables z} de los
procesos que también pertenezcan a la misma ventana de scroll. Es decir,
cada vez que se pinte una ventana de scroll, se pintarán justo a continuación
todos los gráficos que pertenecen a la misma (ordenados por su {z}), y
después se seguirán pintando los procesos que {no pertenecen a dicha ventana
de scroll}.

  - El proceso será eliminado automáticamente cuando se elimine la ventana
de scroll a la que pertenece el proceso, con la función {#166,stop_scroll()}.
O cuando se cambie el modo de vídeo con la función {#157,set_mode()}, ya que
al hacerlo se eliminarán también las ventanas de scroll.

{/}

Si hubiera varias ventanas de {scroll} el proceso si visualizaría por defecto
en todas; si únicamente se debiera visualizar el algunas de ellas, se debería
definir su variable local {#1134,cnumber}. Por ejemplo, si hubiera 6 ventanas
de scroll (de la número 0 a la 5) y se quisiera que un proceso se visualizara
únicamente en las ventanas 0 y 2, se debería incluir en el mismo la siguiente
sentencia:

  {cnumber=c_0+c_2;}

Para poder observar un ejemplo de lo aquí expuesto, lo mejor es examinar
alguno de los juegos ejemplo de DIV Games Studio que utilizan esta técnica,
por lo que se remite al lector directamente a los comentarios de estos
programas (por ejemplo véase el ejemplo {Helioball}).

{/}Ver: {#166,stop_scroll()} - {#152,refresh_scroll()} - {#140,move_scroll()} - {#1101,Estructura scroll}

# ─────────────────────────────────────────────────────────────────────────────

{.164,stop_cd()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{stop_cd()}

{Descripción:}

Detiene la reproducción CD-Audio, parando la canción que estuviese sonando.
Las canciones se reproducen con la función {#144,play_cd()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_stop_cd;
BEGIN
    write(0, 160, 0, 1, "Pulse [ENTER] para poner en marcha el CD.");
    write(0, 160, 10, 1, "Pulse [ESPACIO] para parar el CD.");
    LOOP
        IF (scan_code==_space)

            stop_cd(); // Para el CD

        END
        IF (scan_code==_enter)
            play_cd(2, 0);
        END
        FRAME;
    END
END
{-}

En el ejemplo se ponen los mensajes necesarios. En cada paso del
bucle, si se pulsa la barra espaciadora, se parará el CD con la función
{stop_cd()}.

Si se pulsa la tecla Enter se pondrá en marcha el CD con la función
{#144,play_cd()}.

El volumen de reproducción de cd-audio se puede controlar con la
estructura {#1104,setup} y la función {#178,set_volume()}.

{/}Ver: {#144,play_cd()} - {#127,is_play_cd()} - {#178,set_volume()} - {#1104,Estructura setup}

# ─────────────────────────────────────────────────────────────────────────────

{.165,stop_mode7()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{stop_mode7(}<número de m7>{)}

{Descripción:}

Elimina la ventana de modo 7 cuyo número (del 0 al 9) se pasa como parámetro.
Este <número de m7> es el que se indicó como primer parámetro en la función
{#162,start_mode7()}, es necesario debido a que pueden haber hasta 10 ventanas
diferentes de modo 7, y el sistema necesita saber cuál de ellas se está
finalizando.

Al eliminar una ventana de modo 7, morirán automáticamente todos los procesos
que pertenezcan en exclusiva a dicha ventana, es decir, todos los procesos que
tengan su variable {#1122,ctype} con el valor {#1169,c_m7} y no se estén
visualizando en ninguna otra ventana de modo 7.

{Importante:} Al cambiar de modo de vídeo con la función {#157,set_mode()}
todas las ventanas de modo 7 (y sus procesos) serán igualmente eliminadas,
no siendo en este caso necesario usar esta función ({stop_mode7()}).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_stop_mode7;
BEGIN
    load_fpg("help\help.fpg");
    write(0, 160, 0, 1, "Pulse [ENTER] para poner modo 7.");
    write(0, 160, 10, 1, "Pulse [ESPACIO] para quitar modo 7.");
    write(0, 160, 190, 1, "Utilice el ratón para moverse por el modo 7.");
    angle=90000;
    LOOP
        IF (scan_code==_space)

            stop_mode7(0); // Se quita el modo 7

        END
        IF (scan_code==_enter)
            start_mode7(0, 0, 4, 0, 0, 64);
            m7.camera=id;
        END
        x=mouse.x;
        y=mouse.y;
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y se muestran las instrucciones
del programa en pantalla, tras lo cual las coordenadas del proceso principal,
que servirá de cámara del modo 7, serán controladas con el ratón (mediante
las sentencias {x=mouse.x;} y {y=mouse.y}).

Cuando se pulse la tecla ENTER se creará una ventana de modo 7 con un gráfico
de un circuito abatido, controlada por el proceso principal.

Al pulsarse la barra espaciadora se invocará a la función {stop_mode7()},
eliminando esta la ventana de visualización en modo 7.

{/}

Crear una ventana de modo 7 es un procedimiento algo avanzado y requiere
iniciar varios parámetros, como en este caso la cámara, algunos de ellos
requeridos por la función {#162,start_mode7()} y otros contenidos en la
estructura global {#1102,m7} (como la variable {m7.camera} utilizada en el
ejemplo).

{/}Ver: {#162,start_mode7()} - {#1102,Estructura m7}

# ─────────────────────────────────────────────────────────────────────────────

{.166,stop_scroll()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{stop_scroll(}<número de scroll>{)}

{Descripción:}

Elimina la ventana de scroll cuyo número (del 0 al 9) se pasa como parámetro.
Este <número de scroll> es el que se indicó como primer parámetro en la función
{#163,start_scroll()} y es necesario debido a que puede haber hasta 10 ventanas
diferentes de scroll, y el sistema necesita saber cuál de ellas se está
finalizando.

Al eliminar una ventana de scroll morirán, automáticamente, todos los procesos
que pertenezcan en exclusiva a dicha ventana, es decir, todos los procesos que
tengan su variable {#1122,ctype} con el valor {#1168,c_scroll} y no se estén
visualizando en ninguna otra ventana de scroll.

{Importante:} Al cambiar de modo de vídeo con la función {#157,set_mode()}
todas las ventanas de scroll (y sus procesos) serán igualmente eliminadas,
no siendo en este caso necesario usar esta función ({stop_scroll()}).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_stop_scroll;
BEGIN
    load_fpg("help\help.fpg");
    write(0, 160, 0, 1, "Pulse [ENTER] para activar la ventana de scroll.");
    write(0, 160, 10, 1, "Pulse [ESPACIO] para finalizar el scroll.");
    LOOP
        IF (scan_code==_space)

            stop_scroll(0); // Se quita el scroll.

        END
        IF (scan_code==_enter)
            start_scroll(0, 0, 103, 102, 0, 15);
        END
        scroll.x0+=1;
        scroll.y0+=1;
        scroll.x1-=1;
        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero de gráficos y se muestran las instrucciones
del programa en pantalla.

Cuando se pulse la tecla ENTER se creará una ventana de scroll y al pulsarse
la barra espaciadora se invocará a la función {stop_scroll()}, eliminando
ésta la ventana de visualización del scroll.

Dentro del bucle principal se acceden a las coordenadas del scroll contenidas
en la {#1101,estructura global scroll} para desplazar manualmente la ventana
de scroll ({scroll.x0+=1; ...}).

{/}

Crear una ventana de scroll es un procedimiento algo avanzado y requiere
iniciar varios parámetros, algunos de ellos requeridos por la función
{#163,start_scroll()} y otros contenidos en la {#1101,estructura global scroll}
(como la variable {scroll.x0} utilizada en el ejemplo).

{/}Ver: {#163,start_scroll()} - {#1101,Estructura scroll}

# ─────────────────────────────────────────────────────────────────────────────

{.167,stop_sound()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{stop_sound(}<número de canal>{)}

{Descripción:}

Para el sonido que esté sonando por el canal pasado como parámetro.

El <número de canal> requerido es el valor que retorna la función
{#159,sound()} cuando se inicia la reproducción de un efecto de sonido.

Existen un total de 16 canales de sonido, pudiendo sonar hasta 16 sonidos
simultáneamente.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_stop_sound;

PRIVATE
    id_sonido;
    canal;
    sonando=FALSE;

BEGIN
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    write(0, 160, 0, 1, "Pulse [ESPACIO] para iniciar la reproducción.");
    write(0, 160, 10, 1, "Pulse [ENTER] para detener el canal de sonido.");
    id_sonido = load_pcm("help\help.pcm", 1);
    LOOP
        IF (scan_code==_space AND NOT sonando)
            canal = sound(id_sonido, 128, 256);
            sonando=TRUE;
        END
        IF (scan_code==_enter)

            stop_sound(canal); // Se para el sonido

            sonando=FALSE;
        END
        FRAME;
    END
END
{-}

En el ejemplo se pone un gráfico de fondo y los mensajes necesarios, a la
vez que se carga el efecto de sonido contenido en el archivo {help.pcm} con
la función {#134,load_pcm()}, que devuelve el identificador del sonido
que se guarda en la variable {id_sonido}. Se puede ver que en este ejemplo
se pasa a esta función un {1} como segundo parámetro; esto es para indicar
que el efecto de sonido cargado debe repetirse indefinidamente cada vez
que sea iniciado (esto se hace para resaltar el efecto de la función
{stop_sound()}.

En cada paso del bucle se comprueba si se pulsa la barra espaciadora, en
cuyo caso se iniciará la reproducción del efecto de sonido con {#159,sound()},
que devolverá el número de canal que se guardará en la variable {canal}.

Si se pulsa la tecla ENTER el sonido será parado con la función {stop_sound()}.

{/}

Para parar gradualmente un sonido, bajando su volumen poco a poco, se deben
realizar varias llamadas a la función {#102,change_sound()} para ir
decrementando ligeramente el volumen del canal hasta que éste llegue a 0;
entonces se puede llamar a la función {stop_sound()} para detener definitivamente
el efecto de sonido.

{/}Ver: {#159,sound()} - {#102,change_sound()} - {#134,load_pcm()} - {#170,unload_pcm()}

# ─────────────────────────────────────────────────────────────────────────────

{.168,system()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{system(}<"comando externo">{)}

{Descripción:}

Ejecuta el comando de sistema operativo que se pasa como parámetro.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_system;
BEGIN
    write(0, 160, 0, 1, "Presione [ESPACIO] para hacer un DIR.");
    LOOP
        IF (scan_code==_space)

            system("dir"); // Se ejecuta un comando del MS-DOS.

        END
        FRAME;
    END
END
{-}

En el ejemplo, tras imprimir un texto, se entra dentro del bucle principal
en el que se ejecutará el comando {DIR} del sistema operativo MS-DOS cada
vez que se pulse la barra espaciadora.

{/}

Una utilidad que puede tener este comando es, por ejemplo, borrar algún
archivo temporal que se haya creado en el programa, invocando el comando
del sistema {DEL <}nombre de archivo{>}.

{/}

{Nota:} El sistema puede bloquearse según qué comandos se ejecuten, debiendo
reinicializar el ordenador en estos casos; no se ofrece ningún tipo de
garantía en cuanto al funcionamiento de esta función, debido a las múltiples
incompatibilidades que se pueden presentar entre los comandos externos y
el gestor de procesos interno de DIV Games Studio.

{/}

{system("COMMAND.COM")}

{Descripción:}

Ejecuta una sesión del sistema operativo MS-DOS desde del propio programa.
Al teclear EXIT desde la misma, se retornará al programa en el punto en el que
se ejecutó esta sentencia.

{/}Ver: {#109,exit()}

# ─────────────────────────────────────────────────────────────────────────────

{.169,unload_fpg()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{unload_fpg(}<código del fichero>{)}

{Descripción:}

Descarga de memoria el fichero de gráficos cuyo código se pasa como parámetro.
Este <código de fichero> es el valor que retorna la función {#132,load_fpg()}
cuando se carga un nuevo fichero de gráficos en la memoria.

Tras descargarse un fichero de gráficos {se deben extremar las precauciones}
para no continuar utilizando en el programa ningún gráfico que estuviera en
dicho fichero. En cuyo caso el programa correría el riesgo de bloquearse.

{No es necesario descargar el fichero de memoria} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

Por lo tanto, un fichero se debe descargar de memoria únicamente cuando ya no se
vaya a utilizar durante un tiempo determinado y se quiera liberar el espacio
ocupado en la memoria del ordenador para cargar otros recursos (otros ficheros
de gráficos, sonidos, fuentes, etc.).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_unload_fpg;

PRIVATE
    fichero1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    put_screen(fichero1, 1);
    write(0, 160, 0, 1, "Pulse [ENTER] para descargar el fichero y terminar");
    REPEAT
        FRAME;
    UNTIL (key(_enter));

    unload_fpg(fichero1); // Se descarga el fichero.

END
{-}

El ejemplo carga el fichero de gráficos contenido en el archivo {help.fpg}
con la función {#132,load_fpg()}, guardando el {código del fichero} en la
variable privada {fichero1}.

El programa permanecerá en un bucle hasta que se pulse la tecla ENTER,
momento en el cual se descargará el fichero de memoria con {unload_fpg()}
y terminará el programa.

{/}

Los gráficos cargardos individualmente con la función {#174,load_map()} no se
descargarán cuando se descargue el fichero número 0 (con código 0), aunque
éstos se utilicen como si pertenecieran al mismo, sino que se deberán descargar
utilizando la función {#176,unload_map()}.

{/}Ver: {#132,load_fpg()} - {#174,load_map()} - {#176,unload_map()}

# ─────────────────────────────────────────────────────────────────────────────

{.170,unload_pcm()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{unload_pcm(}<código del sonido>{)}

{Descripción:}

Descarga de memoria el sonido cuyo código se pasa como parámetro.
Este <código de sonido> es el valor que retorna la función {#132,load_pcm()}
cuando se carga un nuevo efecto de sonido en la memoria.

Tras descargarse un efecto de sonido {se deben extremar las precauciones}
para no continuar utilizando en el programa dicho efecto (su código) para
las funciones {#159,sound()} o {unload_pcm()}. En cuyo caso el programa
correría el riesgo de bloquearse.

{No es necesario descargar el sonido de memoria} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

Por lo tanto, un sonido se debe descargar de memoria únicamente cuando ya no se
vaya a utilizar durante un tiempo determinado y se quiera liberar el espacio
ocupado en la memoria del ordenador para cargar otros recursos (otros ficheros
de gráficos, sonidos, fuentes, etc.), lo que tendrá sentido únicamente con
efectos de sonido de cierta longitud, es decir, que sean lo suficientemente
grandes como para que merezca la pena liberar el espacio que ocupan.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_unload_pcm;

PRIVATE
    sonido1;

BEGIN
    sonido1=load_pcm("help\help.pcm",0);
    write(0, 160, 0, 1, "Pulse [ENTER] para descargar el sonido y terminar");
    REPEAT
        FRAME;
    UNTIL (key(_enter));

    unload_pcm(sonido1); // Se descarga el fichero.

END
{-}

El ejemplo carga el efecto de sonido contenido en el archivo {help.pcm}
con la función {#134,load_pcm()}, guardando el {código del sonido} en la
variable privada {sonido1}.

El programa permanecerá en un bucle hasta que se pulse la tecla ENTER,
momento en el cual se descargará el fichero de memoria con {unload_pcm()}
y terminará el programa.

{/}

Para parar un efecto de sonido, pero seguir manteniéndolo en memoria para
cuando se quiera hacer sonar de nuevo, se debe utilizar la función {#167,stop_sound()}.

{/}Ver: {#134,load_pcm()} - {#159,sound()} - {#102,change_sound()} - {#167,stop_sound()}

# ─────────────────────────────────────────────────────────────────────────────

{.171,write()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{write(}<fuente>{,} <x>{,} <y>{,} <código de centrado>{,} <texto>{)}

{Retorna:}

El código identificador del texto que se ha escrito.

{Descripción:}

Esta función es la utilizada para mostrar un texto alfanumérico en pantalla;
para ello requiere los siguientes parámetros:

{<fuente>} - El {código de la fuente} o {tipo de letra} que se va a utilizar.
Aquí se debe poner un 0 cuando se quiera utilizar la fuente del sistema
(fuente de color blanco, pequeña, de 6 por 8 puntos), o bien el {código de
fuente} devuelto por la función {#131,load_fnt()} cuando se carga una nuevo
fuente en el programa.

{<x>}, {<y>} - Las coordenadas relativas a pantalla en las que se va a
imprimir el texto, primero en el eje horizontal y después en el vertical.

{<código de centrado>} - Es un código que determina la posición del texto
que se especifica en las coordenadas anteriores. Sus valores son:

  {0}-Arriba izquierda {1}-Arriba {2}-Arriba derecha·
  {3}-Izquierda        {4}-Centro {5}-Derecha·
  {6}-Abajo izquierda  {7}-Abajo  {8}-Abajo derecha·

Por ejemplo, si se escribe un texto en las coordenadas 160, 0 y con el
código de centrado 1 (Arriba), entonces se centrará el texto en la columna
160 y se imprimirá de la línea 0 hacia abajo. O si se quiere un texto en la
esquina superior izquierda, se debe imprimir en las coordenadas 0, 0 y con
código de centrado 0 (Arriba izquierda).

{<texto>} - Como último parámetro se especificará texto a escribir como un
literal, es decir, un texto entre comillas (Ver los
{#1047,símbolos delimitadores de literales}).

{/}

El texto impreso permanecerá en pantalla hasta que se borre con la función
{#107,delete_text()}, que requiere como parámetro el {código identificador}
que devuelve {write()}.

Para imprimir el valor numérico de una variable (como pudiera ser la
puntuación del jugador) se debe utilizar función {#172,write_int()}.

Los textos permanecerán inalterados en pantalla aunque se impriman gráficos
en la misma o pasen gráficos de procesos por delante o por detrás de los
mismos.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_write;

PRIVATE
    fuente1;

BEGIN
    fuente1 = load_fnt("help\help.fnt");

    write(0, 160, 100, 4, "Texto de ejemplo con la fuente del sistema.");
    write(fuente1, 0, 0, 0, "ARRIBA IZQUIERDA");
    write(fuente1, 320, 200, 8, "ABAJO DERECHA");

    LOOP
        FRAME;
    END
END
{-}

En el ejemplo anterior se carga la fuente contenida en el archivo {help.fnt}
con la función {#131,load_fnt()} (cuyo código de fuente se guarda en la
variable {fuente1}), y después se escriben tres textos:

El primero con la fuente del sistema (0), situándose en las coordenadas 160, 100
(centro de la pantalla) el {centro} del texto (código de centrado 4).

El segundo con la fuente cargada (cuyo {identificador de fuente} se tiene
almacenado en la variable {fuente1}), situándose en las coordenadas 0, 0 la
esquina superior izquierda del texto (código de centrado 0).

Y, por último, el tercer texto, también con la fuente cargada, situándose
en las coordenadas 320, 200 la esquina inferior derecha del texto (código de
centrado 8).

Tras esto el programa se quedará esperando indefinidamente dentro de un
bucle.

{/}

El plano de profundidad en el que aparecen los textos escritos se controla
mediante la variable global {#1106,text_z}, que sirve para regular qué
gráficos se deben ver por encima de los textos y cuáles por debajo.

Los textos podrán, luego, moverse hasta otra posición si es necesario
utilizando la función {#141,move_text()}, que también requiere como
parámetro el {código identificador} que devuelve {write()}.

{/}

Cuando se utilicen fuentes cargadas de {archivos FNT} debe estar activada
la paleta de colores que se ha utilizado para generar dichas fuentes (ver
{#133,load_pal()}) pues, de lo contrario, los colores pueden aparecer
cambiados, visualizándose el texto incorrectamente.

{/}Ver: {#172,write_int()} - {#141,move_text()} - {#107,delete_text()} - {#131,load_fnt()} - {#1106,text_z}

# ─────────────────────────────────────────────────────────────────────────────

{.172,write_int()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{write_int(}<fuente>{,} <x>{,} <y>{,} <código de centrado>{,} <OFFSET variable>{)}

{Retorna:}

El código identificador del texto que se ha escrito.

{Descripción:}

Esta función es la utilizada para visualizar el valor numérico de una variable;
para ello requiere los siguientes parámetros:

{<fuente>} - El {código de la fuente} o {tipo de letra} que se va a utilizar.
Aquí se debe poner un 0 cuando se quiera utilizar la fuente del sistema
(fuente de color blanco, pequeña, de 6 por 8 puntos), o bien el {código de
fuente} devuelto por la función {#131,load_fnt()} cuando se carga una nuevo
fuente en el programa.

{<x>}, {<y>} - Las coordenadas relativas a pantalla en las que se va a
imprimir el valor numérico, primero en el eje horizontal y después en el vertical.

{<código de centrado>} - Es un código que determina la posición del valor numérico
que se especifica en las coordenadas anteriores. Sus valores son:

  {0}-Arriba izquierda {1}-Arriba {2}-Arriba derecha·
  {3}-Izquierda        {4}-Centro {5}-Derecha·
  {6}-Abajo izquierda  {7}-Abajo  {8}-Abajo derecha·

Por ejemplo, si se escribe un valor numérico en las coordenadas 160, 0 y con el
código de centrado 1 (Arriba), entonces se centrará el valor numérico en la columna
160 y se imprimirá de la línea 0 hacia abajo. O si se quiere un valor numérico en la
esquina superior izquierda, se debe imprimir en las coordenadas 0, 0 y con
código de centrado 0 (Arriba izquierda).

{<OFFSET variable>} - Como último parámetro se debe especificar el
desplazamiento dentro de la memoria del ordenador de la variable cuyo valor
se quiere visualizar (el desplazamiento del dato se obtiene con el
operador {#1085,OFFSET}).

{/}

El valor numérico impreso permanecerá en pantalla hasta que se borre con la función
{#107,delete_text()}, que requiere como parámetro el {código identificador}
que devuelve {write_int()}.

{Importante:} Durante el tiempo que aparezca el valor de la variable en
pantalla, éste se irá actualizando automáticamente cada vez que se modifique
la variable, no siendo necesarias nuevas llamadas a {write_int()}.

Para imprimir un texto alfanumérico de cualquier tipo (un texto fijo)
se debe utilizar la función {#171,write()}.

Los textos permanecerán inalterados en pantalla aunque se impriman gráficos
en la misma o pasen gráficos de procesos por delante o por detrás de ellos.


{#9999,Programa ejemplo:}
PROGRAM ejemplo_write_int;

PRIVATE
    variable;

BEGIN
    write(0, 160, 190, 1, "Pulse [ESPACIO] para cambiar el valor de la variable.");

    write_int(0, 160, 100, 4, OFFSET variable); // Se imprime una variable.

    LOOP
        IF (scan_code==_space) variable=rand(-100, 100); END
        FRAME;
    END
END
{-}

En el ejemplo se imprime un texto usando {#171,write()} y el valor de una
variable con la función {write_int()}. A esta última función se le pasan los siguientes
parámetros:

  {0} - Como {fuente} (0 es la fuente del sistema).·
  {0, 10} - Como coordenadas de pantalla.·
  {0} - Como código de centrado (Arriba/Izquierda).·
  {OFFSET variable} - Como el desplazamiento en memoria de la variable.·

A cada paso del bucle, si se pulsa la barra espaciadora, se cambia el valor
de la variable asignándole uno elegido aleatoriamente, al azar, con la
función {#149,rand()}.

{/}

El plano de profundidad en el que aparecen los textos escritos se controla
mediante la variable global {#1106,text_z}, que sirve para regular qué
gráficos se deben ver por encima de los textos y cuáles por debajo.

Los textos podrán luego moverse hasta otra posición si es necesario
utilizando la función {#141,move_text()}, que también requiere como
parámetro el {código identificador} que devuelve {write_int()}.

{/}

Cuando se utilicen fuentes cargadas de {archivos FNT} debe estar activada
la paleta de colores que se ha utilizado para generar dichas fuentes (ver
{#133,load_pal()}) pues, de lo contrario, los colores pueden aparecer
cambiados, visualizándose el texto incorrectamente.

{/}

{Advertencia:}

No es posible imprimir una expresión, como se muestra a continuación:

  {write_int(0, 0, 0, 0, offset variable + 1);}

Para imprimir el valor de la variable más 1, es decir, si se quisiera
imprimir este valor, se debería sumar 1 a la variable o crear otra
variable y asignarle a ésta el valor de la variable original más 1, por
ejemplo:

  {variable2 = variable + 1;}·
  {write_int(0, 0, 0, 0, offset variable2);}·

En este caso se debería tener en cuenta que habría que actualizar el
valor de {variable2} al menos una vez por cada imagen (por cada
{#1029,FRAME}) del juego, ya que al cambiar {variable} no se actualizaría
automáticamente el valor de {variable2} a no ser que se ejecutara
nuevamente la sentencia {variable2 = variable + 1;}.

{/}Ver: {#171,write()} - {#141,move_text()} - {#107,delete_text()} - {#131,load_fnt()} - {#1106,text_z}

# ─────────────────────────────────────────────────────────────────────────────

{.173,xput()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{xput(}<fichero>{,} <gráfico>{,} <x>{,} <y>{,} <angle>{,} <size>{,} <flags>{,} <region>{)}

{Descripción:}

Versión avanzada de la función {#146,put()} para poner un gráfico en el fondo
de la pantalla. Esta función requiere, por orden, los siguientes parámetros:

{<fichero>} - {código del fichero} con la librería de gráficos que contiene
a ambos. Los gráficos cargados con la función {#174,load_map()} se utilizarán como
si pertenecieran al primer fichero (el fichero con el código 0).

{<gráfico>} - {código del gráfico} dentro del fichero que se va a imprimir
en pantalla.

{<x>, <y>} - coordenadas relativas a pantalla donde se desea poner el gráfico.
Estas coordenadas se refieren a donde se situará el centro del gráfico (o el {#1136,punto
de control} número 0, en caso de estar definido).

{<angle>} - ángulo (en milésimas de grados) en el que se imprimirá el gráfico;
el ángulo normal es {0}.

{<size>} - tamaño (en porcentaje) en el que se imprimirá el gráfico; el
tamaño normal es {100}.

{<flags>} - Indica los espejados y transparencias con los que se imprimirá el
gráfico; los posibles valores son:

 {0}-Gráfico normal.·
 {1}-Espejado horizontal.·
 {2}-Espejado vertical.·
 {3}-Espejado horizontal y vertical (180°).·
 {4}-Gráfico transparente.·
 {5}-Transparente y espejado horizontal.·
 {6}-Transparente y espejado vertical.·
 {7}-Transparente, espejado horizontal y vertical.·

{<región>} - Número de región (ventana dentro de la pantalla) en la que
se debe imprimir el gráfico; normalmente este valor será {0} para poder
imprimir el gráfico en cualquier posición de la pantalla. Para definir
una región se debe utilizar la función {#106,define_region()}.

{/}

Los gráficos impresos de esta forma en el fondo de la pantalla estarán en la
visualización del juego {por debajo de todos los procesos, regiones de scroll,
textos, etc.}

Si se desea que un gráfico esté por encima de otros se debe {crear
como un nuevo proceso} y fijar su variable {#1125,z} con la prioridad
de impresión del mismo.

Para borrar el fondo de la pantalla se debe utilizar la función {#103,clear_screen()}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_put;

PRIVATE
    fichero1;
    coord_x;
    coord_y;
    ángulo1;
    tamaño1;
    flags1;

BEGIN
    fichero1=load_fpg("help\help.fpg");
    LOOP
        coord_x=rand(0, 319);
        coord_y=rand(0, 199);
        ángulo1=rand(-pi, pi);
        tamaño1=rand(10, 200);
        flags1=rand(0, 7);

        // Se pone el gráfico 101
        xput(fichero1, 101, coord_x, coord_y, ángulo1, tamaño1, flags1, 0);

        FRAME;
    END
END
{-}

En el ejemplo se carga el fichero con los gráficos y en cada iteración
de bucle se pone el gráfico número 101 (un triángulo) con la función {xput()} en
coordenadas aleatorias (elegidas al azar con la función {#149,rand()}),
con un ángulo y un tamaño también aleatorio, con el valor de {flags} aleatorio y
en la región número 0 (pantalla completa).

{/}

La función {#146,put()} es una versión simplificada de la
función {xput()} de utilidad cuando no se quiera rotar, escalar, espejar
o imprimir con transparencias el gráfico.

Para poner un gráfico en otro (en lugar del fondo de la pantalla)
se deben utilizar las funciones {#137,map_put()} o {#139,map_xput()}.

{/}

Si el gráfico que se quiere poner es simplemente una pantalla de fondo,
resulta más sencillo utilizar la función {#148,put_screen()}, ya que ésta
no requiere las coordenadas de pantalla, pues centrará el gráfico en la
misma de forma automática.

{/}Ver: {#146,put()} - {#137,map_put()} - {#139,map_xput()} - {#148,put_screen()}

# ─────────────────────────────────────────────────────────────────────────────

{.174,load_map()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{load_map(}<nombre de archivo>{)}

{Retorna:}

El {código del gráfico} cargado.

{Descripción:}

Carga un {archivo MAP} con un gráfico en la memoria del ordenador. La
función requiere el nombre del archivo como parámetro, entre comillas.

Se devuelve como valor de retorno el {código del gráfico}, que es un valor
numérico que debe especificarse para utilizar el gráfico, en la variable
{#1126,graph} o, en general, en todas las funciones que requieran un {código
de gráfico} entre sus parámetros.

Es posible cargar tantos gráficos como sea necesario; cada vez que se
cargue uno la función devolverá el código que le corresponde (el primer
gráfico cargado tendrá el código {1000}, el siguiente el {1001}, etc.)

Se puede especificar la ruta de acceso al archivo con el fichero de gráficos,
no obstante, si el fichero está en el directorio por defecto (\MAP) no será
necesario.

{/}

{Importante:}

Cuando se requiera dentro de una función el {código de fichero} al que
pertenece dicho gráfico, se debe indicar el código {0} (que es el código
del primer {fichero FPG} que se cargue en el programa).

{/}

Cuando se han cargado diferentes gráficos se debe tener en cuenta que si
éstos tienen paletas diferentes, se debe activar cada una de ellas previamente
con la función {#133,load_pal()}, indicando el nombre del fichero (MAP) como
parámetro, antes de utilizar el gráfico.

No se pueden utilizar simultáneamente gráficos creados con distintas paletas.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_load_map;

PRIVATE
    mapa1;

BEGIN

    mapa1 = load_map("help\help.map"); // Se carga un fichero de mapa gráfico.

    put_screen(0, mapa1);
    LOOP
        FRAME;
    END
END
{-}

En el ejemplo se carga un mapa gráfico con la función {load_map()} guardando
el {código del gráfico} que retorna en la variable privada {mapa1}.

Este código se usa posteriormente como parámetro de la función {#148,put_screen()}
para poner el gráfico en el fondo de pantalla.

{/}

La función {#176,unload_map()} permite liberar la memoria del ordenador utilizada
por el gráfico cuando ya no se va a utilizar más durante un tiempo, y para ello
requiere también el {codigo del gráfico} para saber qué gráfico es el que se
quiere descargar de memoria.

{No es necesario descargar el gráfico de memoria} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

{/}

Para cargar varios gráficos de golpe en un programa, éstos deben estar incluidos
dentro de un fichero de gráficos (FPG) y cargarse con la función {#132,load_fpg()}.

{/}Ver: {#176,unload_map()} - {#132,load_fpg()} - {#133,load_pal()} - {#1126,graph}

# ─────────────────────────────────────────────────────────────────────────────

{.175,reset_sound()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{reset_sound(}{)}

{Descripción:}

{#1032,Función} avanzada, únicamente para usuarios muy experimentados. Reinicializa
el sistema de sonido.

Esta función sirve para activar unos nuevos parámetros del hardware de sonido.

Se deben establecer los siguientes valores de la {#1104,estructura global setup}:

    {setup.card}·
    {setup.port}·
    {setup.irq}·
    {setup.dma}·
    {setup.dma2}·

Esta función se utiliza generalmente dentro de los programas de configuración
del sistema de sonido (ver {#1093,setup_program}).

{/}

Para activar el resto de los valores de la estructura setup, los referentes
al volumen del mezclador ({mixer}), se debe invocar a la función
{#178,set_volume()}. Los valores para establecer el volumen son:

    {setup.master}·
    {setup.sound_fx}·
    {setup.cd_audio}·

{/}Ver: {#178,set_volume()} - {#1104,Estructura setup} - {#1093,setup_program}

# ─────────────────────────────────────────────────────────────────────────────

{.176,unload_map()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{unload_map(}<código del gráfico>{)}

{Descripción:}

Descarga de memoria el gráfico cuyo código se pasa como parámetro.
Este <código de gráfico> es el valor que retorna la función {#174,load_map()}
al cargar un nuevo gráfico contenido en un {archivo MAP} en la memoria del
ordenador.

Tras descargarse un gráfico {se deben extremar las precauciones}
para no continuar utilizando en el programa dicho gráfico, en cuyo caso el
programa correría el riesgo de bloquearse.

{No es necesario descargar el gráfico} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

Luego, un gráfico solamente debe descargarse de memoria cuando ya no se
vaya a utilizar durante un tiempo determinado y se quiera liberar el espacio
ocupado en la memoria del ordenador para cargar otros recursos (otros ficheros
de gráficos, sonidos, fuentes, etc.), lo que tendrá sentido únicamente con
gráficos de un cierto tamaño, es decir, que sean lo suficientemente
grandes como para sea rentable liberar el espacio que ocupan.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_unload_map;

PRIVATE
    mapa1;

BEGIN
    mapa1=load_map("help\help.map");
    put_screen(0, mapa1);
    write(0, 160, 0, 1, "Pulse [ENTER] para descargar el gráfico y terminar");
    REPEAT
        FRAME;
    UNTIL (key(_enter));

    unload_map(mapa1); // Se descarga el gráfico.

END
{-}

En el ejemplo se carga un mapa gráfico con la función {#174,load_map()} guardando
el {código del gráfico} que retorna en la variable privada {mapa1}.

Este código se usa, posteriormente, como parámetro de la función {#148,put_screen()}
para poner el gráfico en el fondo de pantalla.

Entonces el programa imprimirá un mensaje y esperará en un bucle hasta que
se pulse la tecla ENTER, momento en el cual se descargará el gráfico
utilizando la función {unload_map()}.

{/}

Los gráficos cargados individualmente con la función {#174,load_map()} no se
descargarán cuando se descargue el fichero número 0 (con código 0) con la
función {#169,unload_fpg()}, aunque estos gráficos se utilicen como si
pertenecieran al mismo.

{/}Ver: {#174,load_map()} - {#169,unload_fpg()}

# ─────────────────────────────────────────────────────────────────────────────

{.177,unload_fnt()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{unload_fnt(}<código de la fuente>{)}

{Descripción:}

Descarga de memoria la {fuente} (el {tipo de letra} o el {juego de caracteres
gráficos}) cuyo código se pasa como parámetro.

Este <código de fuente> es el valor que retorna la función {#131,load_fnt()}
al cargar una nueva fuente de letras contenida en un {archivo FNT} en
la memoria del ordenador.

Tras descargarse una fuente {se deben extremar las precauciones}
para no continuar utilizando en el programa dicha fuente; si se hiciera así, se correría el
riesgo de que el programa pudiera bloquearse.

{No es necesario descargar la fuente} antes de finalizar el
programa, ya que el sistema lo hará de forma automática.

Después, se debe descargar una fuente de memoria únicamente cuando ya no se
vaya a utilizar durante un tiempo determinado y se quiera liberar el espacio
ocupado en la memoria del ordenador para cargar otros recursos (otros ficheros
de gráficos, sonidos, fuentes, etc.).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_unload_fnt;

PRIVATE
    fuente1;

BEGIN
    fuente1=load_fnt("help\help.fnt");
    write(fuente1, 160, 0, 1, "FUENTE DEL ARCHIVO EN DISCO");
    write(0, 160, 190, 1, "Pulse [ENTER] para descargar la fuente y terminar");
    REPEAT
        FRAME;
    UNTIL (key(_enter));

    unload_fnt(fuente1); // Se descarga la fuente
END
{-}

En el ejemplo se carga la fuente contenida en el archivo {help.fnt} con la
función {#131,load_fnt()} guardando el {código de fuente} que retorna en
la variable privada {fuente1}.

Este código se usa posteriormente como parámetro de la función {#171,write()}
para poner un texto en pantalla con dicha fuente.

Entonces el programa esperará en un bucle hasta que se pulse la tecla ENTER,
momento en el cual se descargará la fuente utilizando la función {unload_fnt()},
con lo que se terminará el programa.

{/}

La fuente número 0, (la fuente del sistema que tiene 0 como código de fuente),
{no se puede descargar}.

{/}Ver: {#131,load_fnt()} - {#171,write()} - {#172,write_int()}

# ─────────────────────────────────────────────────────────────────────────────

{.178,set_volume()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{set_volume(}{)}

{Descripción:}

{#1032,Función} avanzada, sólo para usuarios muy experimentados.
Ajusta los diferentes controles de volumen gestionados por el mezclador
({mixer}) del sistema de sonido.

Se deben establecer los siguientes valores de la {#1104,estructura global
setup} para poder ajustar el volumen:

    {setup.master}   - Volumen general·
    {setup.sound_fx} - Volumen de los efectos de sonido·
    {setup.cd_audio} - Volumen de la música de cd-audio·

Esta función se utiliza generalmente dentro de los programas de configuración
del sistema de sonido (ver {#1093,setup_program}), o bien en el resto de los
programas, normalmente para fijar el volumen de la música de CD-Audio.

{/}

Para activar el resto de los valores de la estructura setup (los referentes
a parámetros de la tarjeta de sonido), se debe invocar a la función {#175,reset_sound()} con
los siguientes valores de la estructura definidos:

    {setup.card}·
    {setup.port}·
    {setup.irq}·
    {setup.dma}·
    {setup.dma2}·

{/}Ver: {#175,reset_sound()} - {#1104,Estructura setup} - {#1093,setup_program}

# ─────────────────────────────────────────────────────────────────────────────
# Información extendida sobre los mensajes de error del compilador
# ─────────────────────────────────────────────────────────────────────────────

{.500,Memoria insuficiente.}

No se dispone de {memoria suficiente} para compilar el programa.

# ─────────────────────────────────────────────────────────────────────────────

{.501,No se encontro ltobj.def}

El archivo <LTLEX.DEF> no se ha encontrado en el directorio de DIV; este
archivo resulta imprescindible para la compilación de los programas.

Recupere el archivo original si dispone de una copia, en caso contrario
deberá volver a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.502,Archivo ltlex.def erróneo.}

Los cambios efectuados en el archivo <LTLEX.DEF> {no son válidos}; recupere
el archivo original si dispone de una copia, en caso contrario deberá volver
a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.503,Archivo ltlex.def erróneo.}

Se han definido {demasiados símbolos} en el archivo <LTLEX.DEF>; recupere
el archivo original si dispone de una copia, en caso contrario deberá volver
a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.504,Archivo ltlex.def erróneo.}

Se ha definido un {símbolo no válido} en el archivo <LTLEX.DEF>; recupere
el archivo original si dispone de una copia, si no deberá volver
a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.506,No se encontro ltobj.def}

El archivo <LTOBJ.DEF> no se ha encontrado en el directorio de DIV; este
archivo resulta imprescindible para la compilación de los programas.

Recupere el archivo original si dispone de una copia, en caso contrario
deberá volver a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.507,Archivo ltobj.def erróneo.}

Los cambios efectuados en el archivo <LTOBJ.DEF> {no són válidos}; por ello, tendrá que recuperar
el archivo original si dispone de una copia, en caso contrario deberá volver
a instalar la aplicación.

# ─────────────────────────────────────────────────────────────────────────────

{.510,Carácter no reconocido.}

Se encontró en el programa un carácter que no forma parte de ningún símbolo
del lenguaje y que, además, {no es válido} para construir un nuevo nombre.

Si se trata de un {#1002,comentario} debe indicarlo correctamente con un símbolo
// al comienzo de los comentarios de una línea, o los símbolos /* y */ para
indicar el inicio y fin, respectivamente, de comentarios que ocupen más de una
línea.

En caso de que se pretenda construir un {#1001,nombre} debe sustituir dicho
carácter por otro dentro de los que se permiten en el lenguaje.

{/}Ver: {#1000,Sintaxis} - {#1002,Comentarios}

# ─────────────────────────────────────────────────────────────────────────────

{.511,Literal sin cerrar.}

Los literales son los {textos entre comillas}. En la posición indicada del
programa comienza un literal y no se cierra.

Todos los literales deben cerrarse en la misma línea en la que comenzaron, no
pudiéndose definir literales de más de una línea.

Los literales pueden comenzar y terminar con el carácter [{#1047,'}] o bien con el
carácter [{#1047,"}] (pero deben comenzar y terminar con el mismo). Si se quiere
incluir el carácter [{#1047,"}] en un literal se puede hacer de dos formas;
supóngase que se quiere definir un literal que contenga el texto: a"B"c

 - Duplicar el carácter: "a""B""c"

 - Definirlo con la comilla simple: 'a"B"c'

Lo mismo sucede con el carácter [{#1047,'}], que se puede incluir en un literal
si se duplica, o bien si el literal se delimita con el carácter [{#1047,"}].

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.512,Símbolo no reconocido.}

En la posición indicada del programa se encuentra un símbolo no perteneciente
al lenguaje; revise los símbolos que hay disponibles en el lenguaje para
construir correctamente la expresión.

Probablemente se trate de un error tipográfico; revise la sintaxis.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.520,Esperando [PROGRAM]}

Todos los programas deben comenzar con la palabra reservada {PROGRAM} seguida
del nombre del programa; antes de dicha palabra sólo pueden aparecer
{#1002,comentarios} (textos explicativos precedidos del símbolo // o entre
los símbolos /* y */).

Compruebe si ha escrito la palabra correctamente, ya que no se diferencia entre mayúsculas
y minúsculas, por lo que son válidas {PROGRAM}, {program}, {Program}, ...

{#9999,Ejemplo:}
// -------------------
// Listado de mi juego
// -------------------

PROGRAM mi_juego;
BEGIN
    LOOP
        FRAME;
    END
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1002,Comentarios} - {#1003,Cabecera de programa}

# ─────────────────────────────────────────────────────────────────────────────

{.521,Esperando el nombre del programa.}

Tras la palabra reservada {PROGRAM} se espera que venga el nombre del programa.

{#9999,Ejemplo:}
PROGRAM nombre_del_programa;
BEGIN
    //...
END
{-}

El nombre de este programa es {nombre_del_programa}.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1003,Cabecera de programa}

# ─────────────────────────────────────────────────────────────────────────────

{.522,El nombre no es nuevo.}

Como nombre de la estructura se ha utilizado uno que ya estaba
relacionado con otro objeto anteriormente definido. Puede tratarse de un nombre,
de una constante, una variable, una tabla, una estructura, un proceso o una función del programa.

También puede que se haya pretendido utilizar el mismo nombre dentro del
programa para identificar dos objetos diferentes, o bien {que se
haya utilizado un nombre predefinido para otro uso dentro del lenguaje}.
En dicho caso, se puede acceder al glosario para ver a qué objeto se refiere
dicho nombre.

De todas formas, {debe sustituir dicho nombre por otro similar}.

{#9999,Ejemplo:}
PROGRAM nombre_del_programa;
GLOBAL
    posicion=0;
    STRUCT posicion[9] // Error: El nombre no es nuevo.
        x, y;
    END
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.523,Esperando [=]}

Para definir una tabla se suele indicar entre corchetes la longitud de la
misma; en caso de no especificar entre los corchetes el número de elementos
de la tabla se espera que a continuación se inicialice para que el compilador
pueda determinar su longitud.

Se ha encontrado una tabla sin longitud definida, por lo que el compilador
esperaba que, tras cerrarse los corchetes ({#1079,[]}), viniera el símbolo
{#1073,=} precediendo a la inicialización de la tabla.

Indique la longitud de la tabla entre los corchetes, o asígnele valores
a las diferentes posiciones de la tabla.

Cuando una tabla no se inicializa todas sus posiciones serán incializadas
a cero.

{#9999,Ejemplo:}
PROGRAM nombre_del_programa;
GLOBAL
    tabla1[3];
    tabla2[]=2, 4, 6, 8;
    tabla3[]; // Error: Esperando [=].
BEGIN
    //...
END
{-}

En el ejemplo se han definido dos tablas de cuatro posiciones (0..3), tabla1
inicializada a (0, 0, 0, 0) y tabla2 inicializada a (2, 4, 6, 8).

{/}Ver: {#1000,Sintaxis} - {#1011,Declaracion de tabla}

# ─────────────────────────────────────────────────────────────────────────────

{.525,Esperando [)]}

El compilador esperaba que en la posición indicada se cerrara un paréntesis
anteriormente abierto con el símbolo {#1053,)}.

Este error se suele producir por uno de estos dos motivos:

- En una expresión se han abierto varios paréntesis y después no se han cerrado todos;
en este caso debe cerrar los que falten.

- Dentro de una expresión entre paréntesis se ha omitido algún operador apareciendo,
entonces, dos operandos seguidos, por ejemplo {(2*3 4)}, debiendo, en este caso, indicar el
operador que falte.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.526,Esperando []]}

El compilador esperaba que en la posición indicada se cerrara un corchete
anteriormente abierto, con el símbolo {#1079,]}.

Este error se suele producir por uno de estos dos motivos:

- En una tabla o estructura se ha indicado la apertura de corchete ({[})
y después de indicar la longitud o índice de la misma no se ha cerrado;
en este caso se debe añadir en la posición indicada el símbolo {]}.

- Al señalar el índice de una tabla o estructura se ha omitido algún operador apareciendo,
entonces, dos operandos seguidos, por ejemplo {tabla[2*3 4]}, debiendo indicar, ahora, el
operador que falte.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.527,Se esperaba un operando.}

La posición indicada en el programa está dentro del contexto de una expresión,
y en ese punto de la expresión se esperaba un operando (un valor sobre el que
se puedan realizar cálculos) pero, en su lugar, ha venido otro elemento diferente
sobre el que no se pueden realizar cálculos.

Hay varias causas que pueden provocar este error; las más comunes son:

- Se ha utilizado una palabra reservada del lenguaje como si fuera una variable,
por ejemplo {x=global*2;}. En este caso se puede comprobar si se trata de una
palabra reservada accediendo al glosario.

- Se ha omitido un operando dentro de una expresión, por ejemplo {x=2+ /y;}.

- Se ha cerrado dentro de una expresión un corchete o paréntesis que no
habia sido abierto anteriormente, por ejemplo {x=);}.

En cualquier caso debe revisar la {#1000,sintaxis} de la expresión indicada
para construirla de forma correcta.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario} - {#1009,Declaración de dato}

# ─────────────────────────────────────────────────────────────────────────────

{.528,Nombre desconocido.}

En la posición indicada del programa se utiliza una constante, una variable,
una tabla o una estructura con el fin de acceder a ella antes de haberla declarado.

El compilador no puede resolver el problema dado que no conoce de qué tipo
de objeto se trata.

Todas las constantes se deben definir al comienzo del programa, dentro de
la sección {#1004,CONST}.

Las variables, tablas y estructuras se pueden definir dentro de las secciones
{#1006,GLOBAL}, {#1007,LOCAL} o {#1008,PRIVATE} según su alcance, pero
siempre tienen que estar definidas antes de ser usadas.

Los casos más frecuentes en los que se da este error son:

- Se ha tecleado incorrectamente un nombre, por ejemplo;

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    centro=160;
BEGIN
    x=cenrto; // Error: Nombre desconocido.
    //...
END
{-}

- Un objeto se usa antes y se declara después, por ejemplo:

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    doble=simple*2; // Error: Nombre desconocido.
    simple=1;
BEGIN
    //...
END
{-}

  En este caso se deberían intercambiar las dos declaraciones anteriores.

- Al inicializar una tabla o estructura, se ha colocado una coma accidentalmente
tras la lista de valores.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla[]=0, 1, 2, 3,
    a=0; // Error: Nombre desconocido.
BEGIN
    //...
END
{-}

  En este caso el compilador avisará de este error en la variable {a}, ya
que interpreta que es el siguiente valor en la lista de inicialización de
tabla, y es un nombre que todavía se ha definido.

{/}Ver: {#1000,Sintaxis} - {#1004,Declaración de constantes}

# ─────────────────────────────────────────────────────────────────────────────

{.529,Esperando [BEGIN]}

Este error se produce cuando se realiza una declaración incorrecta dentro
de las secciones {#1004,CONST}, {#1006,GLOBAL}, {#1007,LOCAL} o
{#1008,PRIVATE}.

Tras la sentencia inicial {#1003,PROGRAM nombre_de_programa;} se espera que
aparezca alguna de las secciones anteriormente citadas (siempre en ese mismo orden)
y al final la palabra {#1086,BEGIN}.

Tras el inicio de un proceso ({#1016,PROCESS nombre_de_proceso(}...{)}) se espera
que se muestre la sección {#1008,PRIVATE} o la palabra {#1086,BEGIN}.

El error puede producirse bajo las siguientes circunstancias:

- Se ha escrito incorrectamente el nombre de alguna sección.

- Se han puesto varias secciones en un orden incorrecto:

{#9999,Ejemplo:}
PROGRAM mi_juego;
LOCAL
    a=0;
GLOBAL // Error: Esperando [BEGIN]
    b=0;
BEGIN
    //...
END
{-}

  Se recuerda que las secciones deben ir en el siguiente orden:

    {CONST}·
    {#1006,GLOBAL}·
    {#1007,LOCAL}·
    {#1008,PRIVATE}·

- Dentro de cualquiera de las secciones antes mencionadas ha venido un
elemento que no es una declaración válida dentro de dicha sección.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    +variable=0; // Error: Esperando [BEGIN]
BEGIN
    //...
END
{-}

  En este ejemplo, al llegar al símbolo {#1056,+} el compilador determina
que la sección {#1006,GLOBAL} ya ha finalizado y, por lo tanto, como el
siguiente elemento no es el inicio de las secciones {#1007,LOCAL} ni
{#1008,PRIVATE}, espera que venga la palabra reservada {#1086,BEGIN}
marcando el inicio del código del programa.

- Al comienzo del programa o al definir un proceso se ha omitido la
palabra {BEGIN}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
END

PROCESS mi_proceso()
    FRAME; // Error: Esperando [BEGIN]
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1086,BEGIN}

# ─────────────────────────────────────────────────────────────────────────────

{.530,Se esperaba una expresión constante.}

Para inicializar {#1004,constantes}, variables, tablas
y estructuras se deben utilizar valores numéricos o expresiones
cuyo valor pueda ser determinado cuando se compila el programa.

En la posición indicada comienza una expresión cuyo valor no ha podido ser
resuelto en tiempo de compilación, probablemente porque use algun dato
global, local o privado, o bien porque se llame a
alguna función.

En las expresiones constantes se pueden utilizar únicamente:

    - {#1004,Constantes} definidas con anterioridad.·
    - {Valores numéricos}.·
    - {Operadores} aritméticos o lógicos.·
    - {Literales} (textos entre comillas).·
    - La función {#1094,sizeof()}.·

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    mi_variable=4;
    posición=2*mi_variable; // Error: Se esperaba una expresión constante.
BEGIN
    //...
END
{-}

En este ejemplo no se puede inicializar {posición}, ya que se está utilizando
para ello la variable local {x}.

{/}Ver: {#1000,Sintaxis} - {#1005,Definición de constantes}

# ─────────────────────────────────────────────────────────────────────────────

{.531,Se excedió la tabla.}

La expresión constante que comienza en la posición indicada del programa
no puede ser calculada, pues en ella se accede a una tabla
o estructura fuera de su rango de posiciones.

Revise el rango de la tabla o estructura en su definición.
Se recuerda que una tabla definida, por ejemplo, como {tabla[10]}
tiene {11} posiciones (desde tabla[0] hasta tabla[10]).

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla[]=1, 3, 5;
    valor=tabla[3]; // Error: Se excedió la tabla.
BEGIN
    //...
END
{-}

En este ejemplo no se puede inicializar la variable {valor}
dado que se está utilizando, para ello, una posición de tabla
inexistente.

{/}Ver: {#1000,Sintaxis} - {#1011,Declaración de tabla}

# ─────────────────────────────────────────────────────────────────────────────

{.532,No se puede calcular el offset.}

En la expresión indicada en el programa se utiliza el operador {#1085,offset}
(o el símbolo sinónimo {#1085,&}) con el fin de obtener la dirección
(desplazamiento) de un objeto. Dicho objeto no tiene dirección, pues
no es una variable, una tabla o una estructura,
por lo que el compilador no puede resolver la expresión.

Probablemente se haya pretendido obtener la dirección de una expresión constante o una que
involucre varios operandos.

A continuación se muestra un programa con varios ejemplos
de uso válido del operador {#1085,offset}, y otros tantos inválidos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    mi_constante=0;
GLOBAL
    mi_offset=0;
    mi_variable=0;
    mi_tabla[10];
    STRUCT mi_estructura[10]
        variable;
    END
BEGIN
    // Ejemplos correctos
    mi_offset=offset mi_variable;
    mi_offset=offset mi_tabla;
    mi_offset=offset mi_tabla[mi_variable];
    mi_offset=offset mi_estructura[0].variable;
    mi_offset=offset id.x;

    // Ejemplos erróneos
    mi_offset=offset (mi_variable*2);
    mi_offset=offset mi_constante;
    mi_offset=offset 0;
    write_int(0, 0, 0, 0, offset (mi_variable+1));
END
{-}

No hay ninguna diferencia entre el uso de la palabra reservada {#1085,offset}
o el símbolo {&}.

Las {#1005,constantes} como {mi_constante} no tiene una dirección pues son
simples sinónimos del valor numérico que representan.

La sentencia {mi_offset=offset (mi_variable*2);} es errónea debido a que
la multiplicación se realiza en primer lugar y, una vez realizada,
el valor {mi_variable*2} se convierte en un resultado numérico que
no tiene ninguna dirección asignada.

En cambio, la expresión {offset mi_variable*2} sí es correcta pues, en este caso, se obtiene primero la
dirección de {mi_variable} y luego será esta dirección la que se multiplique por {2}.

{/}Ver: {#1000,Sintaxis} - {#1085,offset}

# ─────────────────────────────────────────────────────────────────────────────

{.533,Demasiados valores para la tabla.}

Se ha inicializado una tabla con más valores de los que
puede contener.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[3]=0, 1,2 , 3, 4; // Error: Demasiados valores para la tabla.
BEGIN
    //...
END
{-}

Para inicializar una tabla se debe tener en cuenta que, como
máximo, puede tener tantos valores como indique el número que va
entre los corchetes más 1.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[3]=2, 4, 6, 8;
BEGIN
    //...
END
{-}

En este caso la tabla {tabla1} puede contener cuatro valores (tabla1[0]=2,
tabla1[1]=4, tabla1[2]=6 y tabla1[3]=8).

Otra opción es {no indicar el tamaño de la tabla}, por lo que el
compilador lo deducirá a partir de su inicialización.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[]=2, 4, 6, 8;
BEGIN
    //...
END
{-}

En este caso, si dentro del programa se necesitase hacer referencia a la longitud de la tabla,
se debería utilizar la expresión {sizeof(tabla1)} que, en este ejemplo, valdría {4}.

{/}Ver: {#1000,Sintaxis} - {#1011,Declaración de tabla} - {#1094,sizeof()}

# ─────────────────────────────────────────────────────────────────────────────

{.534,Desbordamiento en división.}

En la posición indicada del programa aparece una {#1005,expresión constante} que no
ha podido ser resuelta por contener dentro de sus operaciones una división
entre cero.

Al dividir un número entre cero resulta ± infinito y como en el lenguaje
de programación sólo se pueden manejar números enteros, dentro del rango
({#1177,min_int} ... {#1178,max_int}) no es posible guardar el resultado
de dicha operación en ninguna variable o relacionarlo con una constante.

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    infinito=1/0; // Error: Desbordamiento en división.
BEGIN
    //...
END
{-}

Probablemente se trate de un error involuntario, de ahí que deba evitarse que se realice
alguna división por cero al evaluar la expresión.

{/}Ver: {#1000,Sintaxis} - {#1019,Sentencia de asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.535,Tabla de longitud negativa.}

Para definir una tabla indicando entre corchetes su longitud se
debe emplear un número entero positivo (0, 1, 2, 3, ...), teniendo en cuenta
que todas las tablas comienzan en la posición cero y terminan en
la posición que indicada en el índice.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[9];
    tabla2[-9]; // Error: Tabla de longitud negativa.
BEGIN
    //...
END
{-}

El compilador ha detectado una tabla definida con una longitud
negativa como {tabla2}; en este ejemplo se debe definir la tabla como
{tabla1} que, en este caso, será una tabla de 10 posiciones (desde
tabla1[0] hasta tabla1[9]).

{/}Ver: {#1000,Sintaxis} - {#1011,Declaración de tabla}

# ─────────────────────────────────────────────────────────────────────────────

{.536,Esperando [(]}

El compilador espera que en la posición del programa indicada se abra un
paréntesis con el símbolo {#1053,(}.

Hay varios casos en los que es obligada la apertura de un {#1053,paréntesis}:

- {Tras un nombre de un proceso o una función} se deben
indicar siempre sus parámetros de llamada entre paréntesis; incluso cuando
el proceso o la función no tengan parámetros se debe abrir un paréntesis,
cerrándolo a continuación.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    mi_proceso();
    //...
END
PROCESS mi_proceso()
BEGIN
  //...
END
{-}

- {En las sentencias de control que requieran una condición}
para controlar el flujo del programa, se debe poner entre paréntesis dicha
condición.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    IF (x<10)
        //...
    END

    WHILE (x<10)
        //...
    END

    REPEAT
        //...
    UNTIL (x<10)

    SWITCH (x)
        //...
    END

    FOR (x=0;x<10;x++)
        //...
    END
END
{-}

  En este ejemplo se puede ver cómo las diferentes sentecias de control indican
entre paréntesis la condición. Hay dos excepciones:

  - La sentencia {#1021,SWITCH} no requiere una condición sino una simple expresión;
aún así, la requiere entre paréntesis.

  - La sentencia {#1025,FOR} tiene tres partes dentro de los paréntesis, separadas
por puntos y coma, siendo estas partes las siguientes: inicialización ({x=0}),
condición ({x<10}) e incremento ({x++}).

- {Tras el operador {#1089,DUP}} (utilizado para inicializar
tablas y estructuras) también es obligada la apertura
de un paréntesis.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[]=10 dup (1, 2, 3);
BEGIN
    //...
END
{-}

  En este ejemplo, tabla1 sería una tabla de 30 posiciones (desde tabla1[0]
hasta tabla1[29]) inicializada de la siguiente forma: 1, 2, 3, 1, 2, 3, ...

{/}Ver: {#1000,Sintaxis} - {#1053,( )}

# ─────────────────────────────────────────────────────────────────────────────

{.538,No se puede duplicar 0 o menos veces.}

El operador {#1089,DUP} utilizado para inicializar tablas y
estructuras permite repetir (duplicar) una secuencia de
valores un determinado número de veces: desde una sola vez (en cuyo
caso el operador no tiene nínguna utilidad) hasta un número positivo
indeterminado de veces.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla1[]=10 dup (1, 2, 3);
    tabla2[]=-10 dup (1, 2, 3); // Error: No se puede duplicar 0 o menos veces.
BEGIN
    //...
END
{-}

En este ejemplo, tabla1 sería una tabla de 30 posiciones (desde tabla1[0]
hasta tabla1[29]) inicializada de la siguiente forma: 1, 2, 3, 1, 2, 3, ...

Es posible, además, omitir el operador {#1089,DUP} quedando entonces la
declaración de tabla1 de la siguiente forma:

  {tabla1[]=10(1, 2, 3);}

El efecto es exactamente el mismo que en el ejemplo anterior, es decir,
cuando el compilador se encuentra en una inicialización de tabla la secuencia
{número ( secuencia_de_valores ... )} interpreta que se pretende repetir
la {secuencia_de_valores} el {número} de veces que se indica.

Por tanto, es imposible repetir una secuencia de valores cero o un número
negativo de veces.

{/}Ver: {#1000,Sintaxis} - {#1089,DUP}

# ─────────────────────────────────────────────────────────────────────────────

{.539,Asignación incorrecta.}

No se puede realizar la asignación indicada en esta posición del programa.
En una sentencia de asignación sólo está permitido asignar valores a
objetos tales como variables (sean del tipo que sean) a una
posición de una tabla, o a un elemento de una estructura.

No es posible asignar un valor a una {#1004,constante}, a una
función o a un proceso, o, en general, a cualquier
expresión numérica o lógica.

En el siguiente programa se muestran ejemplos de varios tipos de asignaciones
incorrectas:

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    mi_constante=0;
BEGIN
    mi_constante=1;  // Error: Asignación incorrecta.
    type mi_juego=2; // Error: Asignación incorrecta.
    sizeof(mouse)=3; // Error: Asignación incorrecta.
    4+5=6;           // Error: Asignación incorrecta.
    //...
END
{-}

Todas estas asignaciones no son válidas porque no se puede modificar con
una asignación el resultado de una expresión, que es sólo un valor numérico; por ello,
es como poner una sentencia del tipo {2=4;} que, por supuesto, es imposible de realizar.

{/}Ver: {#1000,Sintaxis} - {#1035,Definición de expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.540,Esperando [END]}

Dentro de las palabras reservadas {#1086,BEGIN} y {#1091,END} se espera un
bloque de sentencias, así como dentro de sentencias como las que siguen:

  {#1020,IF} ... {#1090,ELSE} ... {#1091,END}·
  {#1024,LOOP} ... {#1091,END}·
  {#1022,WHILE} ... {#1091,END}·
  {#1025,FOR} ... {#1091,END}·
  {#1043,FROM} ... {#1091,END}·
  {#1021,SWITCH} ... {#1091,END}·

Un bloque de sentencias acaba (y sólo puede acabar) con cualquiera de estas
tres palabras reservadas: {#1091,END}, {#1097,UNTIL} o {#1090,ELSE}.

En el programa hay un bloque que se esperaba que acabara con la palabra
reservada {#1091,END} pero finaliza con otra palabra; los dos casos más probables son:

- Que se haya perdido un {#1023,REPEAT} o un {#1020,IF} acabando el bloque de
sentencias con un {#1097,UNTIL} o un {#1090,ELSE}; en este caso, se debe
buscar el {#1023,REPEAT} o {#1020,IF} asociado.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
//  REPEAT
    //...
    UNTIL (key(_esc)); // Error: Esperando [END].
END
{-}

  En este ejemplo el bloque de sentencias que comenzó con el {#1086,BEGIN}
del programa principal ha acabado con un {#1097,UNTIL} (puesto que se ha
comentado accidentalmente el {#1023,REPEAT}), y el compilador esperaba que
este bloque acabara con un {#1091,END}.

- Que se haya perdido un {#1091,END} de alguna sentencia y llegue el
siguiente {#1016,PROCESS} o el final del programa esperando el END que
se ha perdido.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    IF (x<0) x++;
END
PROCESS mi_proceso() // Error: Esperando [END].
BEGIN
    //...
END
{-}

  En este caso no se ha puesto el {#1091,END} del {#1020,IF} interpretando
el compilador que el {#1020,IF} acaba al llegar el siguiente {#1091,END}
(el del {#1086,BEGIN}) y, por tanto, al llegar el nuevo {#1016,PROCESS}
sigue esperando el {#1091,END} del {#1086,BEGIN}.

{/}Ver: {#1000,Sintaxis} - {#1091,END}

# ─────────────────────────────────────────────────────────────────────────────

{.541,Expresión incorrecta.}

En la posición indicada del programa hay una expresión
incorrectamente construida, de forma que el compilador no puede
interpretarla.

- Revise la {#1000,sintaxis} de la expresión.

- En caso de no encontrar el error, intente expresarla de otra forma.

- Intente dividir la expresión en varias subexpresiones realizando
secuencialmente y de forma separada los distintos cálculos que se realizan
en la expresión original. Por ejemplo, la expresión:

  {x=(x*4+1)/2;}

  se puede expresar como tres expresiones diferentes, que son:

  {x=x*4;}·
  {x=x+1;}·
  {x=x/2;}·

  De esta forma podrá localizar en qué punto exacto del cálculo se haya la
operación que no es posible realizar.

{/}Ver: {#1000,Sintaxis} - {#1035,Definición de Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.542,Esperando [UNTIL]}

Un bloque de sentencias que comenzó con la palabra reservada {#1023,REPEAT}
debe acabar necesariamente con la palabra {#1097,UNTIL}; en la posición
indicada del programa se ha finalizado el bloque de sentencias con otra
palabra diferente, lo más probable es:

- Que se ha finalizado un {#1023,REPEAT} con un {#1091,END} en cuyo caso,
si lo que se prentende es realizar un bucle indefinidamente, se debe utilizar
la sentencia {#1024,LOOP} ... {#1091,END}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    REPEAT
    //...
    END // Error: Esperando [UNTIL]
END
{-}

- Que dentro del bucle {#1023,REPEAT} ... {#1097,UNTIL} aparezca una palabra
como {#1091,END} o {#1090,ELSE} de más y, por lo tanto, sin su correspondiente
inicio ({#1020,IF}, {#1022,WHILE}, ...).

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    REPEAT
        IF (x<0) x++; END
            y++;
        END // Error: Esperando [UNTIL]
    UNTIL (x>=0);
END
{-}

  En este caso, se ha puesto el {#1091,END} del {#1020,IF} dos veces,
interpretando el compilador que el segundo {#1091,END} pretende cerrar el
{#1023,REPEAT}.

- O, por último, que se haya olvidado poner el {#1097,UNTIL} del
{#1023,REPEAT}.

{/}Ver: {#1000,Sintaxis} - {#1023, Sentencia REPEAT} - {#1020,IF} - {#1022,WHILE}

# ─────────────────────────────────────────────────────────────────────────────

{.543,Local no se puede acceder.}

En la posición indicada en el programa se pretende acceder a un dato
de otro proceso, siendo imposible ya que dicho dato no es local
del otro proceso.

Debe comprobarse que el dato que se pretende acceder está
definido dentro de la sección {#1007,LOCAL} del programa, o bien un dato
local predefinido en el lenguaje (como {#1123,x}, {#1124,y}, {#1126,graph},
{#1128,size}, ...).

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    id_mi_proceso;
    puntos=0;
BEGIN
    id_mi_proceso=mi_proceso();
    id_mi_proceso.x=0;
    id_mi_proceso.puntos=0; // Error: Local no se puede acceder.
END
PROCESS mi_proceso()
BEGIN
    //...
END
{-}

En este caso se prentende acceder a los {puntos} de {mi_proceso}, pero
{puntos} es una única variable {#1006,GLOBAL} y no una variable {#1007,LOCAL}
de cada proceso. Esto también puede suceder intentando acceder a una constante
(definida en {#1005,CONST}) o a una expresión como:

  {x=id_mi_proceso.(x+1);}

En este último ejemplo la expresión carece de sentido por completo;
probablemente fuera la siguiente expresión la que se prentendiera formular:

  {x=id_mi_proceso.x+1;}

  (equivalente a {x=(id_mi_proceso.x)+1;}).

{/}Ver: {#1000,Sintaxis} - {#1007,Declaracion datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.544,Parámetro no válido.}

Los procesos pueden recibir parámetros en los siguientes tipos de datos:

- Un dato local predefinido (como {#1123,x}, {#1128,size}, {#1127,flags}, ...).

- Un dato local definido dentro de la sección {#1007,LOCAL}.

- Un dato global definido dentro de la sección {#1006,GLOBAL}.

- Un dato privado del proceso declarado dentro de la sección {#1008,PRIVATE}
del propio proceso.

- Un dato privado que {no esté declarado} dentro de la sección
{#1008,PRIVATE}.

Entendiéndose en todos estos casos que un dato puede referirse a una
variable, a una posición concreta de una tabla o a
un elemento dentro de una estructura.

En la posición indicada del programa se pretende recibir un parámetro en
un objeto diferente de los arriba indicados, o bien indicar una
expresión en lugar de un simple dato. Estos son algunos ejemplos de
declaraciones de parámetros inválidas:

  {PROCESS mi_proceso(mi_constante)}·
  No se puede recibir un parámetro en una constante.

  {PROCESS mi_proceso(x*2)}·
  No se puede recibir un parámetro en una expresión.

  {PROCESS mi_proceso(x=0)}·
  No se puede recibir un parámetro en una asignación.

{/}Ver: {#1000,Sintaxis} - {#1018,Parámetros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.545,Se esperaba otro parámetro.}

En las llamadas a procesos o funciones se deben poner tantos
valores o expresiones como párametros se requieran, todos dentro del
mismo {#1053,paréntesis} y separados por {#1059,comas (,)}. Este
error se produce cuando se cierra el paréntesis tras una {#1059,coma},
como en el siguiente ejemplo:

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    signal(id, ); // Error: Se esperaba otro parámetro.
END
{-}

Puede haber pasado dos cosas; se ha puesto una coma accidentalmente tras
el último parámetro, o bien se ha omitido el último parámetro (como en el
ejemplo anterior).

{/}Ver: {#1000,Sintaxis} - {#1018,Parámetros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.546,Número de parámetros incorrecto.}

El proceso o función tiene un número diferente de parámetros a los que aparecen
en la posición señalada en el programa.

Si se trata de una función, acceda al {#4,glosario} para consultar los parámetros
que requiere o bien sitúe el cursor sobre el nombre de la función en el
programa y entonces pulse {F1}.

Si se trata de un {#1013,proceso}, entonces puede que en la posición señalada el
número de parámetros sea correcto pero haya aparecido una llamada a dicho
proceso anteriormente en el programa con un número diferente de parámetros.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    mi_proceso();
END
PROCESS mi_proceso(x, y) // Error: Número de parámetros incorrecto.
BEGIN
    //...
END
{-}

En este ejemplo el error no está en la definición del proceso como se indica,
sino en la llamada anterior a dicho proceso ({mi_proceso();}); esto es así
porque el compilador, cuando se encuentra una llamada a un proceso que no
conoce, lo registra como un nuevo proceso y apunta su número de parámetros.
Si la próxima vez que se encuentre dicho proceso no coincide el número de
parámetros con los que tenía registrados, entonces se emite el error.

Por tanto, en caso de ser correcta la llamada o definición del proceso
señalada en el programa, utilice la opción de búsqueda ({ALT-F}) para revisar
el número de parámetros en las anteriores llamadas a dicho proceso.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario} - {#1018,Parámetros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.547,Esperando [;]}

La sentencia {#1024,FOR} tiene tres partes dentro de los paréntesis separadas
por puntos y coma, siendo estas partes las siguientes:

  FOR ({inicialización}; {condición}; {incremento})

- La {inicialización} suele ser una {#1019,asignación} que fija el
valor de un dato cuando se comienza a ejecutar la sentencia {#1025,FOR}.

- La condición que se establece en segundo lugar determina
la permanencia dentro del bucle; cada iteración se mirará primero
si se cumple dicha condición y, en caso contrario, se finalizará
la ejecución de la sentencia {#1025,FOR}.

- El {incremento} actualiza el valor del dato que sirve como contador tras cada
iteración del bucle.

Ninguna de las tres partes son obligatorias, pero sí lo son los paréntesis
y los dos símbolos {#1068,punto y coma (;)} que separan las partes.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR ( graph=10 ; graph<20 ; graph=graph+1 )
        //...
    END
    FOR ( graph=10 ; graph<20 graph=graph+1) // Error: Esperando [;]
        //...
    END
END
{-}

Dentro de cada una de las tres partes se pueden poner varias sentencias
siempre que se separen por {#1059,comas (,)} (varias inicializaciones, condiciones o
incrementos).

{/}Ver: {#1000,Sintaxis} - {#1068, Punto y coma (;)} - {#1025,Sentencia FOR}

# ─────────────────────────────────────────────────────────────────────────────

{.548,[BREAK] no aparece dentro de un bucle.}

La sentencia {#1026,BREAK} provoca que el programa continúe tras el bucle que se
esté ejecutando.

Esta sentencia sirve para salir de los siguientes bucles:

  {#1024,LOOP} ... {#1091,END}·
  {#1043,FROM} .. {#1096,TO} .. {#1095,STEP} .. ... {#1091,END}·
  {#1023,REPEAT} ... {#1097,UNTIL} {#1053,(} .. {#1053,)}·
  {#1022,WHILE} {#1053,(} .. {#1053,)} ... {#1091,END}·
  {#1025,FOR} {#1053,(} .. {#1068,;} .. {#1068,;} .. {#1053,)} ... {#1091,END}·

Un {#1026,BREAK} provocará que el programa continúe ejecutándose
tras el {#1091,END} o {#1097,UNTIL} del bucle más cercano a la sentencia.
{#1026,BREAK} sólo puede aparecer dentro de uno de estos bucles}.

En caso de haber varios bucles anidados (unos dentro de otros) la sentencia
{#1026,BREAK} saldrá unicamente del bucle más interior de todos ellos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    LOOP
        REPEAT
            IF (key(_esc)) BREAK; END
            //...
        UNTIL (x==0);
        //...
    END
    BREAK; // Error: [BREAK] no aparece dentro de un bucle.
END
{-}

En este ejemplo la sentencia {#1026,BREAK} saldrá del
{#1023,REPEAT} ... {#1097,UNTIL} (cuando se pulse la tecla {ESC})
pero no del {#1024,LOOP} ... {#1091,END}.

{/}Ver: {#1000,Sintaxis} - {#1026,Sentencia BREAK}

# ─────────────────────────────────────────────────────────────────────────────

{.549,[CONTINUE] no aparece dentro de un bucle.}

La sentencia {#1027,CONTINUE} provoca que el programa finalice la
iteración actual del bucle que se esté ejecutando.

Esta sentencia sirve para ir al inicio/final de los siguientes
bucles:

{#1024,LOOP} ... {#1091,END}·
Un {#1027,CONTINUE} dentro de este bucle saltará al {#1024,LOOP}.

{#1043,FROM} .. {#1096,TO} .. {#1095,STEP} .. ... {#1091,END}·
Un {#1027,CONTINUE} dentro de este bucle realizará el incremento
({#1095,STEP}) y, si no se ha pasado el valor indicado en el
{#1096,TO}, continuará el programa al inicio del bucle.

{#1023,REPEAT} ... {#1097,UNTIL} {#1053,(} .. {#1053,)}·
Un {#1027,CONTINUE} dentro de este bucle saltará al {#1097,UNTIL}.

{#1022,WHILE} {#1053,(} .. {#1053,)} ... {#1091,END}·
Un {#1027,CONTINUE} dentro de este bucle saltará al {#1022,WHILE}.

{#1025,FOR} {#1053,(} .. {#1068,;} .. {#1068,;} .. {#1053,)} ... {#1091,END}·
Un {#1027,CONTINUE} dentro de este bucle realizará el incremento
y la comparación; si ésta última resulta cierta continuará el
programa al inicio del bucle, pero si resulta falsa el programa
continuará tras el {#1091,END} del {#1025,FOR}.

{#1027,CONTINUE} {debe aparecer obligatoriamente dentro de uno de estos bucles}.

En caso de haber varios bucles anidados (unos dentro de otros) la sentencia
{#1027,CONTINUE} tendrá efecto únicamente en el bucle más interior de ellos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR (x=0, y=0;x<10;x++)
        IF (x<5) CONTINUE; END
        y++;
    END
END
{-}

En este ejemplo tras ejecutarse el bucle completo {x} valdrá {10} e {y}
valdrá {5}, pues mientras {x} es menor que 5 la sentencia {#1027,CONTINUE}
impide que se ejecute la sentencia {y++;}.

{/}Ver: {#1000,Sintaxis} - {#1027,Sentencia CONTINUE}

# ─────────────────────────────────────────────────────────────────────────────

{.550,Esperando [CASE], [DEFAULT] o [END]}

La sintaxis de la sentencia {#1021,SWITCH} es, a grandes rasgos, como sigue:

    {#1021,SWITCH} {#1053,( }expresión{#1053, )}·
        {#1087,CASE} valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        {#1087,CASE} valor{#1064, .. }valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        {#1087,CASE} valor, valor, valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        //...·
        {#1088,DEFAULT} {#1067,:}·
            sentencias{#1068,;}·
        {#1091,END}·
    {#1091,END}

La posición señalada en el programa está dentro de una sentencia {#1021,SWITCH},
pero fuera de una sección {#1087,CASE} o {#1088,DEFAULT}; por eso el compilador
esperaba que en dicha posición apareciera una de estas tres sentencias:

- La palabra reservada {#1087,CASE} iniciando una nueva sección a ejecutar
cuando la expresión coincidiera con el valor indicado.

- La palabra reservada {#1088,DEFAULT} iniciando una sección por defecto a
ejecutar cuando la expresión no coincidiera con ninguno de los valores
indicados en las diferentes secciones {#1087,CASE}.

- La palabra reservada {#1091,END} dando por finalizada la sentencia
{#1021,SWITCH}.

Para ver una descripción más detallada de la sentencia {#1021,SWITCH}
consulte la sintaxis del lenguaje.

{/}Ver: {#1000,Sintaxis} - {#1021,Sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.551,Esperando [END]}

Se esperaba un {#1091,END} del {#1087,CASE} o {#1088,DEFAULT} dentro de la
sentencia {#1021,SWITCH}.

Dentro de las palabras reservadas {#1021,SWITCH} y {#1091,END} se espera una
o más secciones del tipo:

  {#1087,CASE} ... {#1091,END}·
  {#1088,DEFAULT} ... {#1091,END}·

En el programa hay una de estas secciones que se esperaba que acabe con
la palabra reservada {#1091,END} pero acaba con otra palabra; el caso más
probable es:

- Que se haya perdido un {#1023,REPEAT} o un {#1020,IF} acabando el bloque
de sentencias con un {#1097,UNTIL} o un {#1090,ELSE}; en este caso se debe
buscar el {#1023,REPEAT} o {#1020,IF} asociado.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    SWITCH (x)
        CASE 0:
            //REPEAT
            //...
            UNTIL (key(_esc)); // Error: Esperando [END]
        END
    END
END
{-}

En este ejemplo la sección que comenzó con el {#1087,CASE} ha acabado con
un {#1097,UNTIL} (puesto que se ha comentado accidentalmente el
{#1023,REPEAT}), y el compilador esperaba que esta sección acabara con un
{#1091,END}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.552,Esperando [PROCESS]}

El compilador ha interpretado que, en la posición señalada en el
programa, ha finalizado el programa principal
({#1015,PROGRAM} ... {#1086,BEGIN} ... {#1091,END}), o el último
proceso ({#1016,PROCESS} ... {#1086,BEGIN} ... {#1091,END}) y, a
continuación, se esperaba que continuara otro proceso o bien que
acabara el programa.

Lo más frecuente es haber duplicado un {#1091,END} dentro del último bloque de
sentencias {#1086,BEGIN} ... {#1091,END}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    IF (x<0) x++; END
    END
    FRAME; // Error: Esperando [PROCESS].
END
{-}

En este ejemplo se ha puesto accidentalmente dos veces el {#1091,END}
del {#1020,IF}, interpretando el compilador que el segundo es el {#1091,END}
del {#1086,BEGIN}, por lo tanto, tras este último {#1091,END} sólo
puede venir el final del programa o la palabra reservada {#1016,PROCESS}
marcando el inicio de un nuevo proceso. Al encontrarse en esa
posición, una sentencia {#1029,FRAME}, el compilador emite el error.

{/}Ver: {#1000,Sintaxis} - {#1016,Declaración de proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.553,No se puede especificar una tabla como parámetro.}

No es necesario declarar dentro de la sección {#1008,PRIVATE} los
{#1018,parámetros del proceso}, pues éstos se declaran de forma automática;
pero en caso de declararlos se deben declarar como variables
no como tablas o estructuras, y no se deben inicializar.

Lo más probable es que se haya pretendido utilizar el mismo nombre para dos
objetos diferentes; por un lado, para uno de los parámetros del proceso
y, por otro, para una tabla {#1008,PRIVATE} del mismo proceso.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
END
PROCESS mi_proceso(a)
PRIVATE
    a[9]; // Error: No se puede especificar una tabla como parámetro.
BEGIN
    //...
END
{-}

El compilador interpreta que se está tipificando el parámetro {a} como
una tabla de 10 posiciones y como no se puede pasar una tabla como
parámetro, emite el error.

{/}Ver: {#1000,Sintaxis} - {#1018,Parametros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.554,No se puede inicializar un parámetro.}

No es necesario declarar dentro de la sección {#1008,PRIVATE} los
{#1018,parámetros del proceso}, ya que éstos se declaran de forma automática,
si bien en caso de declararlos se deben declarar como variables
no como tablas o estructuras, y no se deben inicializar.

Lo más probable es que se haya pretendido utilizar el mismo nombre para dos
objetos diferentes, por un lado, para uno de los parámetros del proceso y, por otro,
para una variable {#1008,PRIVATE} del mismo proceso.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
END
PROCESS mi_proceso(a)
PRIVATE
    a=0; // Error: No se puede inicializar un parámetro.
BEGIN
    //...
END
{-}

El compilador interpreta que se está inicializando el parámetro {a} a {0},
y como no está permitido inicializar un parámetro (pues su valor lo tomará
en función de la llamada al proceso), se emite el error.

{/}Ver: {#1000,Sintaxis} - {#1018,Parametros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.555,Llegó el final dentro de un comentario.}

Ha llegado el final del programa dentro de un comentario de varias líneas
(los definidos entre los símbolos{#1002, /*} y{#1002, */}).

Este error se debe a que algún comentario no se ha cerrado, por ello se debe revisar
que todos los comentarios abiertos con el símbolo{#1002, /*} tengan su
correspondiente símbolo{#1002, */} cerrándolos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    /* Inicio del comentario
    FRAME;
END // Error: Llegó el final dentro de un comentario.
{-}

{/}Ver: {#1000,Sintaxis} - {#1002,Definición de comentarios}

# ─────────────────────────────────────────────────────────────────────────────

{.556,No se puede acceder a datos PRIVATE externos.}

En la posición indicada del programa se intenta acceder a un dato
de tipo {#1008,PRIVATE} de otro proceso; no está permitido.

Si se quiere acceder desde un proceso a un dato de otro proceso, éste se
debe declarar dentro de la sección {#1007,LOCAL}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE n;
BEGIN
    mi_proceso();
    //...
END
PROCESS mi_proceso()
PRIVATE n;
BEGIN
    father.n=0; // No se puede acceder a datos PRIVATE externos.
END
{-}

Es imposible acceder a datos {#1008,PRIVATE} incluso cuando el proceso accedido
es del mismo tipo que el proceso que está intentando acceder al dato.

La forma correcta en la que se debe declarar la variable {n} en el ejemplo
anterior es como se muestra a continuación:

{#9999,Ejemplo:}
PROGRAM mi_juego;
LOCAL n;
BEGIN
    mi_proceso();
    //...
END
PROCESS mi_proceso()
BEGIN
    father.n=0;
END
{-}

Se recuerda que los datos declarados dentro de la sección {#1007,LOCAL}
los tendrán todos los procesos del programa (todos los procesos del ejemplo
anterior tendrán una variable propia de nombre {n}).

{/}Ver: {#1000,Sintaxis} - {#1008,Declaración de datos PRIVATE}

# ─────────────────────────────────────────────────────────────────────────────

{.557,Una estructura debe contener, al menos, un elemento.}

En la posición resaltada del programa se pretende cerrar con
{#1091,END} la declaración de una estructura sin
ningún elemento (campo) definido en la misma.

Una estructura ({#1012,STRUCT}) es como una lista de fichas
(registros) con varias informaciones (campos) en cada ficha.

{STRUCT nombre_estructura[10]}·
    {x, y;}·
{END}

En este ejemplo la estructura (conjunto de fichas) se llama {nombre_estructura}
y tiene {10 registros} (diez fichas) con {2 campos} cada una (con dos
informaciones; {x} e {y}).

Por lo tanto, no tiene ningún sentido definir una estructura
sin campos (ya que es como definir un conjunto de fichas sin ninguna
información).

Para acceder después a la información de las fichas se utiliza la estructura
como sigue (supóngase que se quiere poner en la variable global {n} el valor
{y} de la ficha número {5}).

{n=nombre_estructura[5].y;}

A continuación se muestra un programa erróneo.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    STRUCT mi_estructura[10]

    END // Error: Una estructura debe contener, al menos, un elemento.
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1012,Declaración de Estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.558,Esperando un elemento de la estructura.}

En la posición señalada del programa se pretende declarar un elemento (campo)
de la estructura no válido.

Una estructura puede tener únicamente campos de los siguientes tipos:

- Una variable, en cuyo caso se deberá indicar en la declaración el
nombre de la misma, sin inicializar.

- Una tabla, indicando el nombre de la misma y, a continuación,
entre corchetes, la longitud de la misma (se recuerda que una tabla declarada
como {mi_tabla[9];} es una tabla de {10} posiciones, desde mi_tabla[0] hasta
mi_tabla[10]). Tampoco se deben inicializar.

- Otra estructura. Es posible incluir estructuras dentro de
otras estructuras, sin ningún límite de anidamiento, hasta donde sea
necesario. A continuación se muestra un ejemplo de anidamiento de estructuras.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    STRUCT mi_estructura[9]
        elementos;
        STRUCT datos[9]
            x, y;
        END
    END
    a, b;
BEGIN
    FROM a=0 TO 9;
        mi_estructura[a].elementos=-1;
        FROM b=0 TO 9;
            mi_estructura[a].datos[b].x=-1;
            mi_estructura[a].datos[b].y=-1;
        END
    END
    //...
END
{-}

En este ejemplo, cada registro de {mi_estructura} tendrá una variable
denominada {elementos} y otra estructura con 10 elementos cada uno con dos
variables: {x} e {y}.

Más adelante, en el mismo ejemplo, se puede observar un ejemplo de acceso
a dicha estrucutra con dos bucles anidados que inicializan todos los
valores de la estructura a{ -1}.

Para ver cómo se debe inicializar en propia definición los valores de
una estructura acceda al tópico {#1000,sintaxis}.

{/}Ver: {#1000,Sintaxis} - {#1012,Declaración de Estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.560,No es un tipo de proceso.}

El operador {#1042,TYPE} puede utilizarse únicamente si precede a un
nombre de proceso del programa o a la palabra {#1100,mouse}
(para la detección de colisiones con el puntero del ratón).

En la posición señalada del programa no está precediendo a un nombre de
proceso; es probable que se haya escrito el nombre del proceso incorrectamente
o bien que se intente obtener el tipo de un proceso a partir de su {#1039,código identificador}.

Hay una forma de obtener el tipo de un proceso disponiendo de su {#1039,código identificador},
como se muestra a continuación (supóngase que el identificador se tiene en
la variable {id2}).

    {id2.reserved.process_type}

En lugar de {TYPE id2} que no está permitido (pues no hay ningún proceso
con el nombre {id2}, ya que {id2} es una variable).

A continuación se muestra un ejemplo de uso correcto del operador {#1042,TYPE}
(con el fin de obtener el {#1039,código identificador} de un proceso).

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE
    id2;
BEGIN
    //...
    id2=get_id(TYPE mi_proceso);
    //...
    id2=get_id(TYPE id2); // Error: No es un tipo de proceso.
    //...
END
PROCESS mi_proceso()
BEGIN
    //...
END
{-}

Como se puede observar, el operador {#1042,TYPE} requiere el nombre de un
proceso del programa sin paréntesis ni parámetros.

{/}Ver: {#1000,Sintaxis} - {#1042,Tipos de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.561,No se puede calcular el tamaño.}

La función {#1094,sizeof()} se puede utilizar para obtener el número de
elementos de una tabla o de una estructura; para ello
requiere, entre {#1053,paréntesis}, el nombre de la tabla o
estructura (sin corchetes ni índice).

También se puede utilizar con el nombre de una variable pero, en este caso,
la función devolverá siempre 1.

Se puede utilizar indistintamente con datos globales, locales
o privados.

En la posición señalada del programa se pretende obtener el tamaño de un
objeto que no es una variable, tabla o estructura. Por ejemplo, este error
se producirá si se intenta obtener el tamaño de una constante, función,
proceso, etc.

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    mi_constante=99;
GLOBAL
    a=sizeof(mi_constante); // Error: No se puede calcular el tamaño.
BEGIN
    //...
END
{-}

Este ejemplo provocará el error al intentar obtener el número de elementos
de una {#1004,constante}, pues una constante no es un objeto que tenga un tamaño
sino que, simplemente, es un sínonimo del valor numérico que representa.

{/}Ver: {#1000,Sintaxis} - {#1094,sizeof}

# ─────────────────────────────────────────────────────────────────────────────

{.562,Uso: import "nombre.dll"}

El compilador esperaba que, tras la palabra reservada {#1014,IMPORT}, apareciera
entre comillas el nombre del archivo.

Para declarar el uso de una librería externa se debe poner una declaración
como en el siguiente ejemplo.

{#9999,Ejemplo:}
PROGRAM mi_juego;
IMPORT "libreria.dll";
BEGIN
    //...
END
{-}

Este programa declara el uso de la librería denominada {libreria.dll}
(supuesto nombre de una hipotética librería de funciones externas).

La declaración debe hacerse justo antes de la sección {#1008,PRIVATE} o el
{#1086,BEGIN} del programa principal. Pudiendo hacerse varias declaraciones
{#1014,IMPORT} seguidas, para declarar el uso de más de una librería.

{/}Ver: {#1000,Sintaxis} - {#1014,Declaración de librerías}

# ─────────────────────────────────────────────────────────────────────────────

{.563,Uso de una DLL externa no válida.}

En la posición indicada del programa se pretende cargar una {DLL} que no
es válida; esto puede deberse a uno de estos motivos:

- El archivo con la {DLL} se ha corrompido al almacenarse en algún medio defectuoso.

- No se trata de una {DLL} específicamente diseñada para DIV Games Studio.

- No se encuetra el archivo con extensión {DLL} en la ruta especificada por
la sentencia {#1014,IMPORT}.

No se pueden utilizar {DLL} de otros lenguajes, pues no son compatibles con
este lenguaje aunque los archivos tengan todos la extension {DLL}.

En caso de tratarse de una {DLL} preparada para este lenguaje, revise sus
instrucciones de instalación y compruebe que el archivo con extensión
{DLL} se encuentra en el directorio de DIV Games Studio, o bien que la
sentencia {#1014,IMPORT} especifica la ruta completa de acceso a dicho archivo.

{/}Ver: {#1000,Sintaxis} - {#1014,Declaración de librerías}

# ─────────────────────────────────────────────────────────────────────────────

{.564,Expresión sin sentido.}

En la posición señalada en el programa el compilador ha supuesto que comenzaba
una sentencia de uno de estos tipos:

    Asignaciones, ej.:·
    <dato>{ = }<expresión>{ ; }

    Incrementos o decrementos, ej.:·
    <dato>{ ++ ;}

    Llamada a un proceso o función, ej.:·
    <nombre_proceso>{ ( }...{ ) ;}

Pero, en su lugar, se ha encontrado con una expresión que parece carecer de
sentido, ya que una vez efectuadas sus operaciones no se utiliza el resultado
de la misma con ningún propósito.

Es probable que se trate de algún operador suelto que se ha dejado fuera de
una sentencia, por ejemplo, por haberse perdido un operador.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x+1; // Error: Expresión sin sentido.
    //...
END
{-}

En este ejemplo se advierte de este error, pues la sentencia {x+1;} carece
de utilidad, suma la variable {x} y la constante {1}, pero, despúes, no se
utiliza este resultado para ningún fin. Si lo que se quiere es sumarle {1}
a la variable {x} se debe hacer con la siguiente sentencia:

    {x=x+1;}

Aquí se suma la variable {x} y la constante {1} y después se utiliza este
resultado para asignárselo a la variable {x}; esto tambíen se podría haber
hecho con la sentencia {x++;} (incrementar x).

{/}Ver: {#1000,Sintaxis} - {#1019,Sentencia de asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.565,Esperando [:]}

La posición señalada en el programa está dentro de una sentencia {#1021,SWITCH},
tras el comienzo de una sección con "{#1087,CASE} valor", por eso el compilador
esperaba que, en dicha posición, apareciera el símbolo{#1067, :} precediendo a
las sentencias de dicha sección.

La sintaxis de la sentencia {#1021,SWITCH} es, a grandes rasgos, como sigue:

    {#1021,SWITCH} {#1053,( }expresión{#1083, )}·
        {#1087,CASE} valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        {#1087,CASE} valor{#, .. }valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        {#1087,CASE} valor, valor, valor{#1067, :}·
            sentencias{#1068,;}·
        {#1091,END}·
        //...·
        {#1088,DEFAULT} {#1067,:}·
            sentencias{#1068,;}·
        {#1091,END}·
    {#1091,END}

Para ver una descripción más detallada de la sentencia {#1021,SWITCH}
consulte la sintaxis del lenguaje.

{/}Ver: {#1000,Sintaxis} - {#1021,Sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.566,Esperando [;]}

El compilador espera un {#1068,punto y coma (;)} en la posición indicada en
el programa.

En el lenguaje se deben indicar con puntos y coma los siguientes
puntos del programa:

- El final de la {#1003,declaración PROGRAM}.

- El final de una {#1009,declaración de un dato}.

- El final de una {#1014,declaración IMPORT}.

- El final de las siguientes sentencias:·
    {#1019,Asignaciones o incrementos de datos}.·
    {#1033,Llamadas a procesos}.·
    {#1032,Llamadas a funciones}.·
    {#1029,FRAME}, {#1028,RETURN}, {#1031,DEBUG}, {#1026,BREAK} y {#1027,CONTINUE}.·

- El final de un inicio de bucle {#1043,FROM}.

- Y como separador de las diferentes partes de una sentencia {#1025,FOR}.

El compilador indicará cuándo falta el símbolo {;} en cualquiera de estos
puntos.

Pudiendo, además, ponerse dicho símbolo en otros puntos determinados de los
programas, como detrás de cualquier otro tipo de sentencia, aunque en este
caso será opcional y, por tanto, el compilador no advertirá de su ausencia.

{/}Ver: {#1000,Sintaxis} - {#1068, ; }

# ─────────────────────────────────────────────────────────────────────────────

{.567,Esperando variable.}

El compilador esperaba una variable global, local o
privada del proceso en la posición indicada en el programa.

La sintaxis de la sentencia de bucle {#1043,FROM} es la siguiente:

{FROM} <variable>{=}{#1005,<constante>} {#1096,TO} {#1005,<constante>} {#1095,STEP} {#1005,<constante>}{;}·
    {#1017,<sentencia>} {;}·
    ...·
{END}

Siendo la declaración {STEP <constante>} opcional.

Tras la palabra reservada {#1043,FROM} debe aparecer directamente el
{#1001,nombre} de una variable (normalmente local o privada del proceso).

Si se quiere utilizar como contador una variable de otro proceso,
una tabla o un elemento de una estructura, se debe utilizar la
sentencia {#1025,FOR} en lugar de {#1043,FROM}, ya que ésta permite mayor libertad
a la hora de definir las condiciones del bucle.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.568,Esperando [=]}

El compilador esperaba un símbolo {#1073,=} (asignación) en la posición indicada
en el programa.

La sintaxis de la sentencia de bucle {#1043,FROM} es la siguiente:

{FROM} <variable>{=}{#1005,<constante>} {#1096,TO} {#1005,<constante>} {#1095,STEP} {#1005,<constante>}{;}·
    {#1017,<sentencia>} {;}·
    ...·
{END}

Siendo la declaración {#1095,STEP <constante>} opcional.

Tras la palabra reservada {#1043,FROM} debe aparecer directamente el
{nombre} de una variable (normalmente local o
privada del proceso) y, tras éste, el símbolo {#1073,=}
(asignación).

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    id2;
BEGIN
    //...
    FROM id2.x=0 TO 9; // Error: Esperando [=].
        //...
    END
END
{-}

En este ejemplo el error se produce al detectarse tras el {primer nombre}
que aparece ({id2}) el símbolo{#1063, . (punto)} en lugar de {#1073,=}. Esto
sucede porque no se puede utilizar como contador de un bucle {#1043,FROM}
una variable de otro proceso.

Si se quiere utilizar como contador una variable de otro proceso,
una tabla o un elemento de una estructura, se debe utilizar la
sentencia {#1025,FOR}, en lugar de {#1043,FROM}, ya que ésta permite mayor
libertad a la hora de definir las condiciones del bucle.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.569,Esperando [TO]}

El compilador esperaba la palabra reservada {#1096,TO} de la sentencia
{#1043,FROM} en la posición indicada en el programa.

La sintaxis de la sentencia de bucle {#1043,FROM} es la siguiente:

{#1043,FROM} <variable>{=}{#1005,<constante>} {#1096,TO} {#1005,<constante>}
{#1095,STEP} {#1005,<constante>}{;}·
    {#1017,<sentencia>} {;}·
    ...·
{#1091,END}

Siendo la declaración {#1095,STEP <constante>} opcional.

Tras la palabra reservada {#1043,FROM} debe aparecer directamente el
{nombre} de una variable (normalmente local o privada
del proceso) y, tras éste, el símbolo {#1073,=} (asignación)
precediendo a una constante. {Tras este valor constante sólo puede aparecer
la palabra reservada {#1096,TO}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    id2;
BEGIN
    //...
    FROM id2.x=0 STEP 9; // Error: Esperando [TO].
        //...
    END
END
{-}

En una sentencia {#1043,FROM} siempre deben aparecer los valores {inicial}
y {final} de la variable contador del bucle a ambos lados de la
palabra {#1096,TO}.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.570,El valor STEP no es válido.}

En una sentencia {#1043,FROM}:

- Si el valor inicial {es menor} que el valor final, no se puede
especificar un valor negativo en la declaración {#1095,STEP}.

- Si el valor inicial {es mayor} que el valor final, no se puede
especificar un valor positivo en la declaración {#1095,STEP}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FROM x=0 TO 10 STEP -1; // Error: El valor STEP no es válido.
        //...
    END
END
{-}

Este bucle no es válido pues si a {x}, que originalmente valdrá {0},
se le resta {1} en cada iteración, no llegará nunca a {10}. Si lo que
se pretende es hacer un bucle que se repita siempre, se debe utilizar
la sentencia {#1024,LOOP}.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.571,Sentencia FROM incorrecta.}

En una sentencia {#1043,FROM}:

- Los valores {inicial} y {final} de un bucle {#1043,FROM} deben ser
diferentes.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FROM x=0 TO 0; // Error: Sentencia FROM incorrecta.
        //...
    END
END
{-}

Realizar este bucle no tiene sentido, pues no se va a repetir el
grupo interior de sentencias más que una sola vez, lo que sería
equivalente a inicializar {x} a {0} (con la sentencia {x=0;}) y,
después, poner directamente las sentencias interiores, omitiendo
el bucle {#1043,FROM}.

Si lo que se pretende es hacer un bucle que se repita siempre, se debe
utilizar la sentencia {#1024,LOOP}.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.599,Compilación correcta}

El programa no tiene errores de compilación, pulse:

{Menú programas\Ejecutar} o {F10}.·
Para grabar, compilar y ejecutar el programa.

{Menú programas\Trazar} o {F12}.·
Para grabar, compilar y trazar paso a paso el programa.

# ─────────────────────────────────────────────────────────────────────────────

{.600,Excedida la capacidad del vector de nombres.}

Se excedió el buffer para almacenar los {#1001,nombres} del programa;
este error puede deberse únicamente a que se han utilizado nombres de
datos y procesos demasiado largos.

La única solución para poder compilar el programa es sustituir algunos
de estos nombres por otros más pequeños.

# ─────────────────────────────────────────────────────────────────────────────

{.601,Excedida la capacidad de la versión demo.}

Esta versión DEMO de DIV Games Studio no permite crear programas tan grandes
como este, sólo puede compilar programas de un determinado número de variables
y procesos.

En la versión completa de DIV GAMES STUDIO no existe esta limitación, pudiéndose
crear programas de cualquier tamaño.

La única opción para poder compilar este programa es eliminando primero
todos los procesos y datos que ya no se requieran y/o no sean
imprescindibles.

# ─────────────────────────────────────────────────────────────────────────────

{.602,Excedida la capacidad de la tabla de objetos.}

Se excedió el espacio disponible para guardar registros de los datos y
los procesos del programa.

Este error no debería suceder nunca pero si ha sucedido
tiene difícil solución; el programa es demasiado grande para esta versión
del compilador.

Si existe una nueva versión del compilador o algún 'patch' que actualice
esta limitación, debe actualizarse.

En caso contrario la única opción es eliminar del programa todos los
procesos y {#1034,datos} que ya no se requieran y/o no sean
imprescindibles.

# ─────────────────────────────────────────────────────────────────────────────

{.610,Esperando el nombre de la estructura.}

Para definir una estructura de datos se debe especificar el nombre de la misma
tras la palabra reservada {#1012,STRUCT}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    STRUCT posiciones[9]
        x, y;
    END
BEGIN
    //...
END
{-}

Esta estructura se ha definido con el nombre {posiciones} y contiene
{diez registros} (del 0 al 9) cada uno con dos valores {x} e {y}.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1012,Declaración Estructuras}

# ─────────────────────────────────────────────────────────────────────────────

{.611,Esperando el nombre del proceso.}

Para definir un proceso se debe especificar el nombre del mismo
tras la palabra reservada {#1016,PROCESS}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
END

PROCESS mi_proceso()
BEGIN
    //...
END
{-}

Este proceso se ha declarado con el nombre {mi_proceso}.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1016,Declaración de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.612,Esperando el nombre de un proceso.}

Tras la palabra reservada {#1042,TYPE} se debe especificar el nombre de
uno de los procesos definidos en el programa.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
    signal(TYPE mi_proceso, s_kill);
    //...
END

PROCESS mi_proceso()
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1042,Tipos de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.613,Esperando un nombre.}

La función {#1094,sizeof()} requiere como parámetro el nombre de un dato,
pudiendo ser el nombre de una variable, una tabla o una
estructura del programa.

Esta función devuelve el numero de datos (o elementos) que tiene el objeto
cuyo nombre se le pasa como argumento; por lo tanto, si dicho objeto era una
variable, la función siempre devolverá 1.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    tabla[]=0, 1, 2, 3;
    longitud_tabla;
BEGIN
    longitud_tabla=sizeof(tabla);
END
{-}

En este ejemplo {longitud_tabla} valdrá {4} tras ejecutarse la sentencia,
ya que la tabla contiene cuatro datos.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1094,sizeof}

# ─────────────────────────────────────────────────────────────────────────────

{.614,El nombre no es nuevo.}

Se ha utilizado un nombre para un campo de la estructura dos
veces. Debe sustituir dicho nombre por otro similar.

{#9999,Ejemplo:}
PROGRAM nombre_del_programa;
GLOBAL
    STRUCT posicion[9]
        x0, x0; // Error: El nombre no es nuevo.
    END
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#1012,Declaración de estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.615,El nombre no es nuevo.}

Se ha utilizado un {#1001,nombre} de programa no válido pues éste
ya estaba predefinido como nombre de otro objeto. Debe sustituir
dicho nombre por otro similar.

Para saber a qué objeto está identificado con dicho {#1001,nombre} puede acceder al
{#4,glosario}.

{#9999,Ejemplo:}
PROGRAM x; // Error: El nombre no es nuevo.
BEGIN
    //...
END
{-}

En este ejemplo se pretendía utilizar como nombre del programa {x},
que está predefinido como nombre de la variable local que indica la coordenada
x de los procesos.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.616,El nombre no es nuevo.}

Se ha utilizado para definir una {#1004,constante} un {#1001,nombre}
no válido, pues éste ya estaba predefinido como nombre de otro objeto.
Puede tratarse de un nombre de una constante, una variable,
una tabla, una estructura, un proceso o
una función del programa.

Puede ser, también, que se haya pretendido utilizar el mismo {#1001,nombre}
dentro del programa para identificar dos objetos diferentes, o bien
{puede que se haya utilizado un nombre predefinido para otro uso dentro
del lenguaje}. En dicho caso se puede acceder al {#4,glosario} para ver a
qué objeto se refiere dicho nombre.

Debe sustituir dicho nombre por otro similar.

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    x=0; // Error: El nombre no es nuevo.
BEGIN
    //...
END
{-}

En este ejemplo se pretendía utilizar como nombre de una constante {x} que
está predefinido como variable local que indica la coordenada {#1123,x} de los
procesos.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.617,El nombre no es nuevo.}

Se ha utilizado para definir un nuevo dato un {#1001,nombre}
no válido, pues éste ya estaba predefinido como nombre de otro
objeto. Puede tratarse de un nombre de una {#1004,constante},
una variable, una tabla, una estructura,
un proceso o una función del programa.

Asimismo, puede ser que se haya pretendido utilizar el mismo nombre dentro del
programa para identificar dos objetos diferentes, o bien {que se
haya utilizado un nombre predefinido para otro uso dentro del lenguaje}.
En dicho caso se puede acceder al {#4,glosario} para ver a qué objeto se refiere
dicho nombre.

Debe sustituir dicho nombre por otro similar.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    x[3]=0, 1, 2, 3; // Error: El nombre no es nuevo.
BEGIN
    //...
END
{-}

En este ejemplo se pretendía utilizar como nombre de una tabla global {x}
que está predefinido como variable local que indica la coordenada {#1123,x} de los
procesos.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.618,El nombre no es nuevo.}

Se ha utilizado un {#1001,nombre} de un proceso no válido pues éste
ya estaba predefinido como nombre de otro objeto. Puede tratarse de
un nombre de una {#1004,constante}, una variable, una
tabla, una estructura, un proceso o una
función del programa.

Puede ser que se haya pretendido utilizar el mismo nombre dentro del
programa para identificar dos objetos diferentes, o bien {puede que se
haya utilizado un nombre predefinido para otro uso dentro del lenguaje}.
En dicho caso puede acceder al {#4,glosario} para ver a que objeto se refiere
dicho nombre.

Debe sustituir dicho nombre por otro similar.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    //...
END

PROCESS mi_juego() // Error: El nombre no es nuevo.
BEGIN
    //...
END
{-}

En este ejemplo se pretendía utilizar como nombre de un proceso
el nombre que anteriormente se había empleado para identificar el
programa principal.

{/}Ver: {#1000,Sintaxis} - {#1001,Nombres} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.619,Esperando [=]}

Para definir una constante se debe poner un símbolo {#1073,=} tras el nombre de la
constante.

El compilador ha entendido que la última palabra definida era el nombre
de una nueva {#1004,constante} y, en la posición que se indica, se esperaba que se mostrara
el símbolo de asignación ({#1073,=}).

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    a=0;
    b=1;
    c,d; // Error: Esperando [=].
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#1009,Declaración de dato}

# ─────────────────────────────────────────────────────────────────────────────

{.620,Demasiados valores para la estructura.}

Se ha inicializado una estructura con más valores de los que puede contener.

Para inicializar una estructura se debe tener en cuenta el número de valores máximo
que puede contener; este número será:

    {Nº de registros} X {Nº de campos}

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    STRUCT posiciones[9]
        x, y;
    END = 10 dup (-99, 99);
BEGIN
    //...
END
{-}

En este caso la estructura {posiciones} tiene {10 registros} (desde posiciones[0]
hasta posiciones[9]) y {2 campos} (x e y); luego, el número máximo de valores que puede
contener es {20}. En el ejemplo se inicializan todos los campos {x} a{ -99} y todos
los campos {y} a {99}.

{/}Ver: {#1000,Sintaxis} - {#1012,Declaración de estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.621,Nombre desconocido.}

En la posición indicada del programa se hace referencia a un {#1016,PROCESS}
inexistente que puede tratarse de uno de los siguientes casos:

- Se ha tecleado incorrectamente el nombre de un proceso, en cuyo
caso revise el nombre del proceso original pues puede que sea en su
definición donde el nombre no aparece correctamente.

- Se ha pretendido utilizar una función del lenguaje
y no se ha escrito su nombre correctamente; en este caso puede
acceder al índice general para buscar el nombre exacto de la función.

- Se hace referencia a un proceso cuyo código aún no se ha
definido, por ello si se quiere compilar el programa se debe
definir el proceso, al menos, como sigue:

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    mi_proceso();
END

PROCESS mi_proceso()
BEGIN
END
{-}

  Indicando en el proceso los parámetros que reciba (en el ejemplo anterior
no recibe ningún parámetro).

{/}Ver: {#1000,Sintaxis} - {#3,Indice} - {#1016,Declaración de proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.622,No se puede realizar el incremento.}

En la expresión indicada en el programa se utiliza el operador
{#1057, ++} (o el operador{#1061, --}) incorrectamente, con el fin de
incrementar (o decrementar) un objeto. Dicho objeto no tiene dirección,
pues no es una variable, tabla o estructura, por
lo que el compilador no puede realizar un incremento (o decremento) sobre
el mismo.

Probablemente se haya pretendido incrementar o decrementar una expresión constante o una que
involucre varios operandos.

A continuación, se muestra un programa con varios ejemplos de uso válido de
los operadores{#1057, ++} y{#1061, --}, y otros tantos inválidos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    mi_constante=0;
GLOBAL
    mi_variable=0;
    mi_tabla[10];
    STRUCT mi_estructura[10]
        variable;
    END
BEGIN
    // Ejemplos correctos
    mi_variable++;
    mi_tabla--;
    ++mi_tabla[mi_variable];
    --mi_estructura[0].variable;
    id.x++;

    // Ejemplos erróneos
    (mi_variable*2)++;
    mi_constante--;
    ++0;
    --(mi_variable+1);
END
{-}

Las constantes como {mi_constante} no se pueden incrementar pues son simples
sinónimos del valor numérico que representan.

La sentencia {(mi_variable*2)++;} es errónea debido a que la
multiplicación se realiza en primer lugar y, una vez realizada, el valor
{mi_variable*2} se convierte en un resultado numérico que no tiene dirección
y, por lo tanto, no se puede acceder a ella para incrementarlo.

En este caso, probablemente, la sentencia correcta que se debería haber utilizado
habría sido {mi_variable=mi_variable*2+1;}

{/}Ver: {#1000,Sintaxis} - {#1057,++} - {#1061,--}

# ─────────────────────────────────────────────────────────────────────────────

{.623,Estructura de longitud negativa.}

Para definir una estructura indicando entre {#1079,corchetes} su número de registros
se debe emplear un número entero positivo (0, 1, 2, 3, ...), teniendo en cuenta que todas las
estructuras comienzan en el registro cero y terminan en el registro que se indique
en el índice.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    STRUCT e1[9]
      x, y;
    END
    STRUCT e2[-9] // Error: Estructura de longitud negativa.
      x, y;
    END
BEGIN
    //...
END
{-}

El compilador ha detectado una estructura definida con un número negativo de registros como
{e2}; en este ejemplo se debe definir la estructura como {e1} que,
en este caso, será una estructura de 10 registros (desde e1[0] hasta e1[9])
y dos campos (x e y).

{/}Ver: {#1000,Sintaxis} - {#1012,Declaración de estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.624,Se esperaba una sentencia.}

La posición indicada en el programa está dentro del contexto de un
bloque de sentencias, por lo que se esperaba que comenzara una sentencia en
la posición indicada. Éstos son los posibles tipos de sentencias:

sentencias de asignación·
<expresión>{#1035,=}<expresión>;

sentencias de control·
{#1020,IF} y {#1021,SWITCH}.

sentencias de bucles·
{#1043,FROM}, {#1022,WHILE}, {#1023,REPEAT}, {#1024,LOOP} y {#1025,FOR}.

sentencias de ruptura·
{#1026,BREAK}, {#1027,CONTINUE} y {#1028,RETURN}.

sentencias especiales·
{#1029,FRAME}, {#1030,CLONE} y {#1031,DEBUG}.

Siendo posible que en esta posición apareciera una de las palabras
reservadas que pueden marcar el final de un bloque de sentencias, como son:

{#1091,END}, {#1090,ELSE} y {#1097,UNTIL}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    CASE 0: // Error: Se esperaba una sentencia.
        //...
    END
END
{-}

Este ejemplo provocará el error, dado que la palabra reservada {#1087,CASE} no
es válida para comenzar una sentencia; sólo es válida dentro de una
sentencia {#1021,SWITCH}.

{/}Ver: {#1000,Sintaxis} - {#1017,Declaración de sentencia}

# ─────────────────────────────────────────────────────────────────────────────
# Temas de interés relacionados con los errores de compilación
# ─────────────────────────────────────────────────────────────────────────────

{.1000,Sintaxis de un programa.}

A continuación se muestra la estructura general de un programa en el
lenguaje; pulse con el ratón sobre la sección de interés para ver la
definición sintáctica correspondiente.

{#1003,<Cabecera del programa>}·
{#1004,<Declaración de constantes>}·
{#1006,<Declaración de datos globales>}·
{#1007,<Declaración de datos locales>}·
{#1014,<Declaración de librerías>}·
{#1008,<Declaración de datos privados>}·
{#1015,<Código principal>}·
{#1016,<Declaración de procesos>}·

Todos los programas deben respetar la estructura anterior con una
única excepción, y es que pueden ponerse {#1002,comentarios explicativos}
en cualquier punto del programa.

{/}Ver: {#3,Indice} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1001,Definición de un nombre.}

Un nombre es una secuencia de caracteres alfanuméricos que
se utiliza para {identificar} un objeto del programa, como puede ser
el nombre de un proceso, de una {#1004,constante} o de una
variable.

Estos nombres pueden formarse con los siguientes caracteres:

  Símbolos:·
  {_ # ª º $ ₧ ƒ £ ¥ ¢}·
  Dígitos:·
  {0123456789}·
  Letras:·
  {abcdefghijklmnopqrstuvwxyz}·
  Letras (extendido):·
  {ñ ç æ âäàåá êëèé îïìí ôöòó ûüùú ÿ}·

Siempre que se respeten las siguientes reglas para construir nuevos
nombres:

- La secuencia de caracteres no debe contener caracteres que no estén
en la relación anterior (excepto las letras {mayúsculas} correspondientes
a las minúsculas de la lista).

- Dentro de la secuencia no se pueden poner espacios en blanco, es decir,
no es válido como nombre {nave enemiga}, pues para el compilador
se trataría de dos nombres; en este caso se puede declarar el
nombre como {nave_enemiga}.

- Un nombre no puede comenzar por un dígito numérico, es decir,
{0a} no es un nombre válido. No obstante tras el primer caracter,
pueden incluirse en el nombre todos los dígitos necesarios ({a0} si
es un nombre válido).

- El nombre no debe coincidir con ninguna de las palabras reservadas
del lenguaje ni con ninguno de los objetos (constantes, variables, etc.)
predefinidos en el lenguaje. Para comprobar esto, ver la lista de palabras
reservadas y objetos predefinidos, pudiéndose acceder al glosario en cualquier
momento. Las palabras reservadas aparecen en mayúsculas y los objetos
predefinidos en minúsculas.

- No se diferencian las letras mayúsculas de las mínusculas ({ABc} y {abC}
son el mismo nombre para el compilador).

- No se puede utilizar un mismo nombre para dos objetos diferentes,
por ejemplo, no se puede llamar a una constante {valor} y, después, declarar
un proceso como {PROCESS valor(x, y);}.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1002,Definición de comentarios.}

Un comentario es una nota aclaratoria sobre el programa. Los comentarios no
son necesarios para el correcto funcionamiento del programa.

Hay dos tipos de comentarios:

- De una sola línea, comienzan con el símbolo{ //} y terminan al final de
la línea en la que se definen.

- De varias líneas, comienzan con el símbolo{ /*} y terminan con el
símbolo {*/}.

{#9999,Ejemplo:}
/*
    Esto es un ejemplo de un comentario
    de varias líneas, en el que se pueden
    realizar aclaraciones sobre el programa
*/

PROGRAM mi_juego; // Ejemplo de un comentario de una línea.
BEGIN             // Comienza el programa principal.
    FRAME;
END               // Termina el programa principal.
{-}

Todos los textos incluidos en un comentario son ignorados por el compilador.
Se pueden poner tantos comentarios en un programa como sean necesarios y
en cualquier punto del programa.

Los comentarios que comienzan con{ /*} y terminan con{ */} (denominados de
varias líneas) pueden también comenzar y terminar en la misma línea.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1003,Cabecera del programa.}

{PROGRAM} {#1001,<nombre>} {;}

Todos los programas deben comenzar con la palabra reservada {PROGRAM} seguida
del nombre del programa y un símbolo {#1068,; (punto y coma)}.

Esta cabecera es obligatoria en todos los programas. Antes de la misma sólo
puede aparecer, de forma opcional, uno o varios {#1002,comentarios} (textos explicativos
precedidos del símbolo{ //}, o bien entre los símbolos{ /*} y{ */}).

En los nombres y las palabras reservadas no se diferencia entre
mayúsculas y minúsculas, por lo que son válidas {PROGRAM}, {program}, {Program}, ...

{#9999,Ejemplo:}
// -------------------
// Listado de mi juego
// -------------------

PROGRAM nombre_de_mi_juego;
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1004,Declaración de constantes.}

{CONST}·
    {#1001,<nombre>} {=} {#1005,<constante>} {;}·
    ...

Esta sección de los programas es opcional, pues su utilidad consiste en establecer
una serie de sinónimos para unos valores numéricos.

Por ejemplo, si en un juego se establece en uno o varios puntos del programa
el número 3 como el máximo de vidas del protagonista, cuando
se quiera modificar para aumentarlo o disminuirlo habrá que buscar y
sustituir ese número en el programa. Con el consiguiente riesgo de
sustituir otros '3' que aparezcan en el programa con otros fines.

Una alternativa es declarar una constante denominada, por ejemplo,
{máximo_vidas} como un sinónimo del valor numérico 3 y utilizar en el
programa dicha constante en lugar del número; ahora, cuando se quiera
cambiar este valor por otro, simplemente habrá que hacerlo en la declaración
de la constante {máximo_vidas}.

Esta sección establece entonces una relación de nombres que van
a representar una serie de constantes numéricas.

Esta sección debe comenzar obligatoriamente con la palabra reservada {CONST}
y, a continuación, por cada constante declarada debe aparecer su nombre
seguido del símbolo {#1073,= (símbolo de asignación)} y una expresión constante
(valor numérico). Tras la declaración de cada constante debe venir el símbolo
{#1068,;} (punto y coma).

{#9999,Ejemplo:}
PROGRAM mi_juego;
CONST
    máximo_vidas=3;
BEGIN
    //...
END
{-}

Una vez que se ha asignado un valor a una constante, éste no podrá ser
modificado en el programa más adelante.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1005,Definición de una constante.}

Una constante es un valor o una expresión numérica constante.

Como valores se pueden utilizar únicamente números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int}).

Las expresiones númericas constantes son fórmulas matemáticas en las que
se puede utilizar:

    - {Constantes} definidas con anterioridad.·
    - {Valores numéricos}.·
    - {Operadores} aritméticos o lógicos.·
    - {Literales} (textos entre comillas).·
    - La función {#1094,sizeof()}.·

Estas expresiones serán evaluadas cuando el programa sea compilado y será
el resultado de las mismas el que sea utilizado en la ejecución del programa.

Los {operadores} que se pueden utilizar en una expresión constante son (entre
paréntesis se muestran los sinónimos del operador, en caso de tenerlos).

    {#1056, +}    Suma·
    {#1060, -}    Resta (o negación de signo)·
    {#1054, *}    Multiplicación·
    {#1065, /}    División·
    {#1048, MOD}  Módulo ({#1048,%})·
    {#1070, <<}   Rotación a la derecha·
    {#1077, >>}   Rotación a la izquierda·
    {#1045, NOT}  Negación binaria y lógica ({!})·
    {#1051, AND}  AND binario y lógico ({&},{&&})·
    {#1083, OR}   OR binario y lógico ({|},{||})·
    {#1082, XOR}  OR exclusivo ({^}, {^^})·
    {#1074, ==}   Comparación·
    {#1046, <>}   Distinto ({!=})·
    {#1076, >}    Mayor·
    {#1075, >=}   Mayor o igual ({=>})·
    {#1069, <}    Menor·
    {#1072, <=}   Menor o igual ({=<})·
    {#1085, OFFSET} Dirección o desplazamiento ({&})·
    {#1053, ( )}  Paréntesis·

A continuación se muestran algunos ejemplos de constantes válidas:

{ 0}·
{ -1000}·
{ 2+2}·
{ "Hola!"}·
{ 4*(2+1)}·
 ...

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1006,Declaración de datos globales.}

{GLOBAL}·
    {#1009,<declaración de dato>} {#1068,;}·
    ...

Esta sección de los programas es opcional; es donde se declaran los
datos de ámbito global, es decir, los {datos que pueden utilizarse
desde cualquier punto del programa}.

La sección debe comenzar obligatoriamente con la palabra reservada GLOBAL
seguida de una serie de {#1009,declaraciones de datos} terminadas con un
símbolo {#1068,;} (punto y coma).

En general, se declaran como datos globales todos aquellos que establecen
condiciones generales del juego que afecten a varios procesos; un ejemplo
puede ser los puntos obtenidos por el jugador, que podrían almacenarse en la
variable global {puntuación}, de modo que cualquier proceso del juego pudiera
incrementarla cuando fuera necesario.

Una declaración de dato global definirá un único dato que podrá ser utilizado
por todos los procesos del programa; en cambio una declaración de dato
local definirá un dato de ese tipo y con ese nombre, para cada uno de los
procesos del programa.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    puntuación=0;
BEGIN
    //...
END
{-}

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1007,Declaración de datos locales.}

{LOCAL}·
    {#1009,<declaración de dato>} {#1068,;}·
    ...

Esta sección de los programas es opcional, ya que es donde se declaran los
datos de ámbito local, es decir, los {datos que tendrán todos los procesos
del programa}, cada uno con sus propios valores (como las variables locales
predefinidas {#1123,x} e {#1124,y} determinan las coordenadas de todos los procesos).

La sección debe comenzar obligatoriamente con la palabra reservada {LOCAL}
seguida de una serie de {#1009,declaraciones de datos} terminadas con un
símbolo {#1068,;} (punto y coma).

En general, se declaran como datos locales todos aquellos que se consideren
informaciones importantes de los procesos, o sea, aquellos que pueda interesar
consultar o modificar desde otros procesos.

Un ejemplo puede ser la energía que le queda a un proceso (puede ser una
nave, un disparo, el protagonista, etc.); esta información podría almacenarse
en la variable local {energía} de modo que cualquier proceso pudiera
acceder o modificar la energía de los demás (por ejemplo, cuando colisionara
con ellos les podría quitar energía).

{#9999,Ejemplo:}
PROGRAM mi_juego;
LOCAL
    energía=0;
BEGIN
    //...
END
{-}

Si un dato declarado como local va a utilizarse únicamente dentro de un
proceso, entonces se puede definir como un dato privado (dentro de la sección
{#1008,PRIVATE} de dicho proceso).

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1008,Declaración de datos privados.}

{PRIVATE}·
    {#1009,<declaración de dato>} {#1068,;}·
    ...

Estas secciones de los programas son opcionales; en ellas se pueden declarar
datos de ámbito privado, es decir, {datos que van a ser utilizados exclusivamente
dentro de un proceso}.

Dicha sección se define justo antes del {#1086,BEGIN} del proceso que va a utilizar
esos datos y debe comenzar, obligatoriamente, con la palabra reservada PRIVATE
seguida de una serie de {#1009,declaraciones de datos} terminadas con un
símbolo {#1068,;} (punto y coma).

El programa principal también se considera como un proceso, pudiendo tener
su declaración de datos privados justo antes del {#1086,BEGIN} del mismo.

En general, se declaran como datos privados todos aquellos que vayan a contener
información necesaria únicamente para un proceso e, igualmente, que no van a poder ser accedidos
desde ningún otro proceso.

Típicamente se definen como datos privados aquellas variables que van a ser utilizadas
como contadores en un bucle, las variables para contener ángulos o códigos identificadores
secundarios, etc.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE
    n;
BEGIN
    FROM n=0 TO 9;
        //...
    END
    //...
END

PROCESS mi_proceso()
PRIVATE
    id2;
    angle2;
BEGIN
    id2=get_id(TYPE mi_proceso);
    IF (id2<>0)
        angle2=id2.angle;
        //...
    END
    //...
END
{-}

Si un dato declarado como privado necesita consultarse o modificarse desde
otro proceso (identificador.dato), entonces se deberá declarar dicho dato
como local (dentro de la sección {#1007,LOCAL} del programa); de esta forma,
todos los procesos poseerán el dato, pudiendo acceder cada uno a su valor
o al valor que tenga dicho dato en otro proceso.

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1009,Declaración de un dato.}

En una declaración de dato pueden manifestarse tres tipos diferentes de
objetos:

  {#1010,<Declaración de una variable>}·
  {#1011,<Declaración de una tabla>}·
  {#1012,<Declaración de una estructura>}·

En general, una variable almacenará un simple valor numérico, una tabla una
lista de valores numéricos, mientras que una estructura almacenará una lista de registros de varios
campos (como una lista de fichas con diversa información).

Todos los datos se declaran con un nombre propio que, a partir
de ese momento, será el medio por el cual se acceda o se modifique la información
que dicho dato contiene.

Cada dato pertenecerá a un ámbito determinado, según su declaración se
haga dentro de la sección {#1006,GLOBAL}, {#1007,LOCAL} o {#1008,PRIVATE}..

  {#1006,<Declaración de datos globales>}·
  {#1007,<Declaración de datos locales>}·
  {#1008,<Declaración de datos privados>}·

A los datos globales se puede acceder desde cualquier punto del
programa; los locales son aquellos que tienen todos los procesos
(cada proceso tiene su propio valor en ellos) mientras que los privados son los
que pertenecen a un solo proceso determinado.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1010,Declaración de una variable.}

{#1001,<nombre>}

(o bien, si se quiere inicializar)

{#1001,<nombre>} {#1073,=} {#1005,<constante>}

Para declarar una variable dentro de una sección {#1006,GLOBAL}, {#1007,LOCAL}
o {#1008,PRIVATE} bastará con indicar su nombre dentro de dicha sección, en
cuyo caso la variable será inicializada a 0 (cero).

Si se quiere que la variable esté inicializada a otro valor se deberá poner,
a continuación del nombre de la variable, el símbolo {#1073,=} (asignación)
y tras éste el valor constante al que se desea inicializar la variable.

Una variable es una celda (o posición) de la memoria del ordenador a la que
nos referimos por su nombre, y que puede contener valores numéricos
enteros dentro del rango ({#1177,min_int} ... {#1178,max_int}).

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1011,Declaración de una tabla.}

{#1001,<nombre>} {#1079,[} {#1005,<constante>} {#1079,]}

(o bien, si se quiere inicializar la tabla)

{#1001,<nombre>} {#1079,[} {#1005,<constante>} {#1079,]} {#1073,=} {#1013,<lista de constantes>}

(o bien, si se inicializa sin definir su longitud)

{#1001,<nombre>} {#1079,[} {#1079,]} {#1073,=} {#1013,<lista de constantes>}

Para declarar una tabla dentro de una sección {#1006,GLOBAL}, {#1007,LOCAL}
o {#1008,PRIVATE} bastará con indicar su nombre seguido de la longitud
de la tabla entre corchetes (símbolos {#1079,[} {#1079,]}), en cuyo
caso todas las posiciones de la tabla serán inicializadas a 0 (cero).

La longitud de la tabla se expresa como el valor máximo de su índice, es
decir, todas las tablas van de la posición 0 a la posición indicada entre
los corchetes en su declaración. Por ejemplo, una tabla declarada como
{mi_tabla[9]}, será una tabla de longitud {10} (de 10 posiciones, desde
mi_tabla[0] hasta mi_tabla[9]).

Si se quiere inicializar las diferentes posiciones de la tabla se deberá poner,
a continuación de la declaración anterior, el símbolo {#1073,=} (asignación)
y tras éste una {#1013,lista de constantes}.

Si se inicializa la tabla con una lista, entonces no es necesario indicar
entre corchetes la longitud de la tabla, pues el compilador creará una tabla
con tantas posiciones como valores tenga la lista.

Una tabla es una serie de celdas (o posiciones) de la memoria del ordenador,
a las que nos referimos por su nombre y tras él, entre corchetes, el
número de celda dentro de la tabla a la que se quiere acceder.

Cada celda de la tabla es una variable y puede contener valores numéricos
enteros dentro del rango ({#1177,min_int} ... {#1178,max_int}).

Por ejemplo, si declaramos una tabla como la siguiente:

    {mi_tabla[]=33, -1, 6, -3, 99;}

Estaremos declarando una tabla cuyo nombre es {mi_tabla} y tiene
{5} celdas (o posiciones), desde la celda nº 0 hasta la celda nº 4. En la
declaración anterior se inicializa la celda 0 ({mi_tabla[0]}) con el valor {33},
la 1 ({mi_tabla[1]}) con el valor{ -1}, etc.

El lenguaje permite acceder a la celda 0 simplemente con el nombre
de la tabla ({mi_tabla}), como si fuera una variable, omitiendo el cero entre
corchetes que debería aparecer a continuación, es decir, que para el compilador
{mi_tabla[0]} será lo mismo que {mi_tabla} (la primera celda de la tabla).

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1012,Declaración de una estructura.}

{STRUCT} {#1001,<nombre>} {#1079,[} {#1005,<constante>} {#1079,]}·
    {#1009,<declaración de dato>} {#1068,;}·
    ...·
{#1091,END}

(o bien, si se inicializa la estructura)

{STRUCT} {#1001,<nombre>} {#1079,[} {#1005,<constante>} {#1079,]}·
    {#1009,<declaración de dato>} {#1068,;}·
    ...·
{#1091,END} {#1073,=} {#1013,<lista de constantes>}

Para declarar una estructura dentro de una sección {#1006,GLOBAL},
{#1007,LOCAL} o {#1008,PRIVATE} se debe poner la palabra reservada {STRUCT}
precediendo a su nombre; tras éste, y entre corchetes, (símbolos {#1079,[ ]})
se deberá indicar el número de registros de la estructura.

Tras esta cabecera que define el nombre de la estructura y el
número de registros, se declararán todos los datos pertenecientes a
la estructura, que conformarán los campos de la misma. Y, por último,
para finalizar la declaración debe aparecer la palabra reservada {#1091,END}.

El número de registros de la estructura se expresa como el número de
registro máximo de la estructura, es decir, todas las estructuras
tienen desde el registro 0 hasta el registro que se indica entre
dichos corchetes. Por ejemplo, una estructura declarada como {STRUCT
mi_estructura[9]}, será una estructura de {10} registros (desde el
registro mi_estructura[0] hasta mi_estructura[9]).

Una estructura es como una caja de fichas (registros), cada una con
varias informaciones escritas (campos). Por ejemplo, una estructura
en la que podríamos contener la posición inicial y final de una
serie de procesos de un juego sería como la siguiente (sería como
una caja con 10 fichas, cada una de ellas indicando la (x, y) inicial
y la (x, y) final de un proceso):

{STRUCT movimiento_enemigos[9]}·
    {x_inicial;}·
    {y_inicial;}·
    {x_final;}·
    {y_final;}·
{END}

Esta estructura, a la que se accedería con el nombre
{movimiento_enemigos}, tiene diez registros y en cada uno cuatro
campos (dos coordenadas que determinan la posición inicial del
proceso [x_inicial ,y_final], y dos que determinan la posición final
[x_final, y_final]). Para acceder a la {x} final del primer enemigo
se utilizaría {movimiento_enemigo[0].x_final}.

El lenguaje permite acceder al registro 0 de la estructura simplemente con el nombre
de la estructura ({movimiento_enemigos.x_final}), omitiendo el cero entre
corchetes que debería venir a continuación, es decir, que para el compilador
{movimiento_enemigos[0].x_final} será lo mismo que {movimiento_enemigos.x_final}.

Cada campo de la estructura puede ser una variable, una tabla
u otra estructura completa, con sus diferentes registros y campos.

Si se quiere inicializar la estructura (fijar los valores iniciales
de sus campos en los diferentes registros), se deberá poner el símbolo
{#1073,=} (asignación) tras la palabra reservada {#1091,END} seguida de una
{#1013,lista de constantes}. Si no se inicializa de esta forma la
estructura, todos los campos serán puestos a 0 por defecto.

Para inicializar una estructura se debe tener en cuenta que los
primeros valores serán los valores de los campos del primer registro,
los siguientes los del segundo registro y, así, sucesivamente.

Por ejemplo, si se hace la siguiente declaración:

STRUCT a[2]·
    b;·
    c[1];·
END = 1, 2, 3, 4, 5, 6, 7, 8, 9;

Primero se debe tener en cuenta que la estructura {a} tiene 3 registros
(desde a[0] hasta a[2]) y en cada registro tres campos (b, c[0] y c[1]),
luego la anterior declaración inicializará la estructura de la siguiente
forma:

a[0].b=1;·
a[0].c[0]=2;·
a[0].c[1]=3;·
a[1].b=4;·
a[1].c[0]=5;·
...

{/}Ver: {#1000,Sintaxis} - {#4,Glosario}

# ─────────────────────────────────────────────────────────────────────────────

{.1013,Definición de una lista de constantes.}

Una constante es un valor o una expresión numérica constante
(ver {#1005,<definición de constante>}).

Las listas de constantes son básicamente una serie de constantes
separadas por {#1059,comas (,)} y se utilizan para inicializar los valores
de tablas o estructuras.

Un ejemplo de una lista de constantes podría ser el siguiente:

1, 2, 3, 4, 5;

Pero, además de esta forma básica de definición, se permite el
uso del operador {#1089,DUP} para repetir un número determinado de
veces una serie de constantes. Por ejemplo la siguiente lista:

0, 100 DUP (1, 2, 3), 0;

Es una lista de 302 constantes (0, 1, 2, 3, 1, 2, 3, ..., 1, 2, 3, 0), es decir,
que el operador {#1089,DUP} (de duplicar) permite repetir la secuencia que
aparece tras él, entre paréntesis, el número de veces indicadas.

Es posible anidar operaciones {#1089,DUP}, por ejemplo la lista siguiente:

2 {DUP} (88, 3 DUP (0, 1), 99);

equivaldría a:

88, 0, 1, 0, 1, 0, 1, 99, 88, 0, 1, 0, 1, 0, 1, 99;

Además, se permite la omisión del operador {#1089,DUP}, esto es, que
{2 DUP (0, 1)} equivale a {2(0, 1)}.

El operador DUP es útil, sobre todo, para la inicialización de
estructuras; si, por ejemplo, se quiere inicializar la siguiente
estructura de 100 registros:

{STRUCT a[99]}·
    {b;}·
    {c[9];}·
    {d[9];}·
{END}

Con los campos {b} incializados a {0}, los campos {c[9]} a {1} y los
campos {d[9]} a {2}, se utilizaría la siguiente lista de inicialización:

100 {#1089,DUP} (0, 10 DUP(1), 10 DUP(2));

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1014,Declaración de librerías.}

{IMPORT} {<nombre de archivo>}

La creación de librerías de funciones para el lenguaje es un tema {muy avanzado},
sólo apto para programadores con amplia experiencia en el lenguaje {C} y/o {Ensamblador}.

Las librerías deben distribuirse con dos archivos: uno, con extensión {DLL} con
la librería en sí y, otro, con el mismo nombre pero con extensión {TXT} que
debe ser un archivo de texto ascii (MSDOS), con la explicación del propósito
y funcionamiento de la librería; en el mismo deben venir explicadas todas
las funciones proporcionadas y el proceso de instalación y utilización de la
librería.

Desde el lenguaje se deben importar las librerías poniendo la palabra reservada
{IMPORT} (tras la declaración de datos globales y locales) seguida de la ruta
de acceso al archivo {DLL}. Si el archivo con extensión {DLL} se ha copiado al
directorio de {DIV Games Studio} entonces no es necesario especificar la ruta
de la librería.

{#9999,Ejemplo:}
PROGRAM mi_juego;
IMPORT "c:\tmp\3dtrans.dll";
BEGIN
    //...
END
{-}

Desde el momento en que las librerías de funciones pueden ser desarrolladas
de forma libre, {no se garantiza el correcto funcionamiento de DIV Games
Studio cuando se utilicen librerías DLL externas}. Puede ser habitual el
funcionamiento incorrecto del {trazador de programas} cuando en un juego se
cargue una DLL que modifique partes vitales de la librería de funciones o
del gestor de procesos de DIV Games Studio.

{Nota:} Si usted es un programador experto en C y Ensamblador, puede obtener
más información sobre la creación de nuevas librerías en el archivo
DLL\SOURCE\LEEME.TXT de DIV.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1015,Código principal.}

{#1086,BEGIN}·
    {#1017,<sentencia>} {;}·
    ...·
{#1091,END}

El código principal de un programa comienza con la palabra reservada
{#1086,BEGIN}, tras la cual puede aparecer cualquier número de sentencias,
y finaliza con la palabra reservada {#1091,END}.

Este código controla el proceso principal del programa, que es el encargado
de inicializar el programa, controlar los bucles de menú y de juego, y
finalizar el programa.

{#9999,Ejemplo:}
PROGRAM mi_juego;

GLOBAL
    opción;             // Opción elegida en el menú.

BEGIN                   // Inicio del código principal.

    set_mode(m640x480); // Inicialización.
    set_fps(24, 4);
    // ...              // Carga ficheros, sonidos, etc.

    REPEAT              // Inicio bucle principal.

        opcion=0;       // Bucle de control del menú de opciones.
        //...           // Inicializa el menú de opciones.
        REPEAT
            // ...
            IF (key(_enter)) opcion=1; END  // Se elige jugar.
            IF (key(_esc)) opcion=2; END    // Se elige finalizar.
            FRAME;
        UNTIL (opcion>0);

        IF (opcion==1)  // Si se ha elegido la opcion de jugar.

            // Inicializa regiones, scroll, etc.
            // Crea los procesos de juego.
            // Bucle de control del juego, espera a que finalice.

        END

    UNTIL (opcion==2);  // Final del bucle principal.

    let_me_alone();     // Finaliza todos los procesos.

END                     // Final del código pricipal.

// ...                  // Declaración de los procesos del programa.
{-}

Que finalice la ejecución del código principal no implica que finalice la
ejecución del programa, pues ésta continuará si quedan procesos vivos; si se
quiere forzar la terminación del programa cuando finalice este código, se
puede utilizar, por ejemplo, la función {#129,let_me_alone()} justo antes del
{#1091,END} que marca el final del código principal, para eliminar al resto
de procesos que puedan quedar vivos.

También se puede finalizar en cualquier punto del programa su
ejecución mediante la función {#109,exit()} que automáticamente eliminará
todos los procesos.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1016,Declaración de procesos.}

{PROCESS} {#1001,<nombre>} {(} {#1018,<parámetros>} {)}·
{#1008,<Declaración de datos privados>}·
{#1086,BEGIN}·
    {#1017,<sentencia>} {;}·
    ...·
{#1091,END}

Un proceso debe comenzar con la palabra reservada {PROCESS} seguida
de su nombre y sus {#1018,parámetros} de llamada entre
paréntesis. Los parámetros son una lista de datos en los que el
proceso va a recibir diferentes valores. Los paréntesis son
obligatorios incluso cuando el proceso no tenga parámetros.

Tras esta cabecera puede venir, de forma opcional, una sección {#1008,PRIVATE}
donde se declaren datos que va a utilizar exclusivamente el proceso.

Y, por último, se especificará el código para el proceso, que es una
secuencia de sentencias entre las palabras reservadas {#1086,BEGIN} y
{#1091,END}.

Un proceso se corresponde, normalmente, con un tipo de objeto del
juego, como puede ser una nave, una explosion, 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 {#1029,FRAME}, se dará la orden para
visualizar el objeto con los atributos establecidos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE
    id2;
BEGIN
    id2=mi_proceso(160, 100)
    // ...
END

PROCESS mi_proceso(x, y)
PRIVATE
    n;
BEGIN
    graph=1;
    FROM n=0 to 99;
        x=x+2;
        y=y+1;
        FRAME;
    END
END
{-}

Como se puede observar en este ejemplo, cuando se llama a un proceso
éste devuelve su {#1039,código identificador} (que en el ejemplo se guarda en la
variable {#1008,PRIVATE} del programa principal {id2}); si se quiere
implementar un proceso al estilo de las funciones de otros lenguajes,
que devuelva un resultado numérico, entonces se debe utilizar la
sentencia {#1028,RETURN(}valor{)} y no utilizar la sentencia {#1029,FRAME}
dentro del proceso, pues ésta retorna al proceso padre (llamante),
devolviendo el {#1039,código identificador} del proceso como valor de retorno.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1017,Relación de sentencias.}

Una sentencia es una orden a ejecutar por el ordenador dentro de un
programa. Estos son los posibles tipos de sentencias:

Sentencias de asignación·
    {#1019,=}·

Sentencias de control·
    {#1020,IF}·
    {#1021,SWITCH}·

Sentencias de bucles·
    {#1024,LOOP}·
    {#1043,FROM}·
    {#1023,REPEAT}·
    {#1022,WHILE}·
    {#1025,FOR}·

Sentencias de ruptura·
    {#1026,BREAK}·
    {#1027,CONTINUE}·
    {#1028,RETURN}·

Sentencias especiales·
    {#1029,FRAME}·
    {#1030,CLONE}·
    {#1031,DEBUG}·

Sentencias de llamada·
    {#1032,Llamada a una función}·
    {#1033,Llamada a un proceso}·

Las sentencias siempre aparecen como un grupo de sentencias, desde
ninguna (que no tiene sentido) hasta tantas como sean necesarias.

Todas las sentencias se ejecutarán secuencialmente (la primera,
la segunda, la tercera, ...) salvo por las excepciones que definen
las sentencias que pueden controlar el flujo del programa (las
sentencias de control, de bucles y de ruptura).

{/}Ver: {#1000,Sintaxis} - {#4,Glosario} - {#3,Indice}

# ─────────────────────────────────────────────────────────────────────────────

{.1018,Parámetros de un proceso.}

Los parámetros de un proceso son, básicamente, una lista de datos en los cuales
el proceso recibirá distinta información cada vez que sea invocado
(llamado o utilizado) desde otro proceso.

Los procesos pueden recibir parámetros en los siguientes tipos de datos:

- Un dato local predefinido (como {#1123,x}, {#1228,size}, {#1127,flags}, ...).

- Un dato local definido dentro de la sección {#1007,LOCAL}.

- Un dato global definido dentro de la sección {#1006,GLOBAL}.

- Un dato privado del proceso declarado dentro de la sección {#1008,PRIVATE}
del propio proceso.

- Un dato privado que {no esté declarado} dentro de la sección {#1008,PRIVATE}.

Entendiéndose, en todos estos casos, que un dato puede referirse a una variable,
a una posición concreta de una tabla o a un elemento
dentro de una estructura.

Para ejemplificar los diferentes tipos de parámetros se muestra,
a continuación, un programa con un proceso que recibe cinco parámetros
diferentes de los tipos indicados en la lista anterior, respectivamente.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
    puntos=0;
LOCAL
    energia=0;
BEGIN
    mi_proceso(1, 2, 3, 4, 5);
    // ...
END

PROCESS mi_proceso(x, energía, puntos, n, m)
PRIVATE
    n;
BEGIN
    // ...
END
{-}

El proceso {mi_proceso} recibe cinco parámetros en cinco variables:
local predefinida, local, global, {#1008,private} declarada y {#1008,private} sin
declarar.

Recibir en un dato global un parámetro (como la variable {#1006,GLOBAL}
{puntos}) equivale a realizar la asignación ({puntos=3;}) y, después,
llamar al proceso.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1019,Sentencia de asignación.}

Las sentencias de asignación sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<Referencia a un dato>} {#1073,=} {#1035,<expresión>} {#1068,;}

Se debe indicar el dato en el cual se va a guardar el resultado
de la expresión, seguido del símbolo {#1073,=} (símbolo de la {asignación})
y la expresión numérica o lógica a evaluar cuando se ejecute la
sentencia. Tras esta sentencia se debe poner siempre el
símbolo{#1068, ;(punto y coma)}.

En una sentencia de asignación sólo está permitido asignar valores a objetos
tales como variables (de cualquier tipo), a una {#1011,posición de una tabla},
o a un {#1012,elemento de una estructura}.

No es posible asignar un valor a una {#1004,constante}, a una función
o a un proceso, o, en general, a cualquier {#1035,expresión numérica o lógica}.

Se muestra a continuación un programa con varias asignaciones.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=x+1;
    angle=(angle*3)/2-pi/2;
    size=(x+y)/2;
    z=abs(x-y)*3-pow(x, 2);
    // ...
END
{-}

Ésta es la forma básica de las asignaciones, si bien existen otros símbolos de asignación
que, en lugar de asignar un nuevo valor al dato referido, modifican su valor.
Éstos son los símbolos de {asignaciones operativas}:

{#1058, +=} Suma al dato el resultado de la expresión·
        {x=2; x+=2;} -> (x==4)

{#1062, -=} Resta al dato el resultado de la expresión·
        {x=4; x-=2;} -> (x==2)

{#1055, *=} Multiplica el dato por el resultado de la expresión·
        {x=2; x*=3;} -> (x==6)

{#1066, /=} Divide el dato por el resultado de la expresión·
        {x=8; x/=2;} -> (x==4)

{#1049, %=} Pone en el dato el resto de dividir al mismo entre el resultado de la
expresión·
        {x=3; x%=2;} -> (x==1)

{#1052, &=} Realiza un AND (binario y/o lógico) entre el dato y el resultado de la
expresión y lo asigna como nuevo valor del dato·
        {x=5; x&=6;} -> (x==4)

{#1084, |=} Realiza un OR (binario y/o lógico) entre el dato y el resultado de la
expresión y lo asigna como nuevo valor del dato·
        {x=5; x|=6;} -> (x==7)

{#1081, ^=} Realiza un OR exclusivo (XOR binario y/o lógico) entre el dato y el
resultado de la expresión y lo asigna como nuevo valor del dato·
        {x=5; x^=3;} -> (x==3)

{#1078, >>=} Rota a la derecha el dato tantas veces como indique el resultado de la
expresión (cada rotación a la derecha equivale a dividir entre 2 el dato)·
        {x=8; x>>=2;} -> (x==2)

{#1071, <<=} Rota a la izquierda el dato tantas veces como indique el resultado de la
expresión (cada rotación a la izquierda equivale a multiplicar por 2 el dato)·
        {x=2; x<<=2;} -> (x==8)

También se admiten dentro de la categoría de sentencias de asignación los
{incrementos} y {decrementos} de un dato. Por ejemplo, si quisieramos sumarle 1
a la variable local {x} podríamos hacerlo con la sentencia {x=x+1;}, con
la sentencia {x+=1;} o bien con el operador de incremento: {x++;} o{ ++x;}.

Es decir, se aceptan como sentencias de asignación {#1057,incrementos ( ++ )} o
{#1061,decrementos ( -- )} de un dato.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1020,Sentencia IF}

{IF} {#1053,(} {#1037,<condición>} {#1053,)}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

(o bien)

{IF} {#1053,(} {#1037,<condición>} {#1053,)}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1090,ELSE}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

La sentencia {IF} sirve para ejecutar un bloque de sentencias opcionalmente,
cuando se cumpla una condición. En la segunda variante que aparece arriba,
se ejecutará además otro bloque de sentencias (dentro de la sección
{#1090,ELSE}) cuando la condición {no} se cumpla.

Se muestra, a continuación, un programa con varias sentencias {IF}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN

    IF (key(_esc))
        exit("Adios!", 0);
    END

    IF (x>100 AND x<220)
        y=y+4;
    ELSE
        y=y-8;
    END

    IF (size>0)
        size=size-1;
    END

    IF (timer[5]>1000)
        z=1;
    ELSE
        z=-1;
    END

    // ...
END
{-}

Es posible anidar sentencias {IF} sin ningún límite, es decir, se pueden poner
más sentencias {IF} dentro de la parte que se ejecuta cuando se cumple la
condición (parte {IF}) o dentro de la que se ejecuta cuando la condición no
se cumple (parte {#1090,ELSE}).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1021,Sentencia SWITCH}

{SWITCH} {#1053,(} {#1035,<expresión>} {#1053,)}·
    {#1087,CASE} {<rango de valores>} {#1067,:}·
        {#1017,<sentencia>} {#1068,;}·
        ...·
    {#1091,END}·
    ...·
    {#1088,DEFAULT} {#1067,:}·
        {#1017,<sentencia>} {#1068,;}·
        ...·
    {#1091,END}·
{#1091,END}

Una sentencia {SWITCH} consta de una serie de secciones {#1087,CASE} y,
opcionalmente, una sección {#1088,DEFAULT}.

Cuando se ejecuta una sentencia {SWITCH}, primero se evalúa la expresión y
después, si el resultado está dentro del rango de valores contemplados en la
primera sección {CASE}, se ejecutarán las sentencias de la misma y se dará
por finalizada la sentencia. En caso de no estar el resultado de la expresión
en el primer {#1087,CASE} se pasará a comprobarlo con el segundo {#1087,CASE}, el tercero,
etc. Y, por último, si existe una sección {#1088,DEFAULT} y el resultado de la
expresión no ha coincidido con ninguna de las secciones {#1087,CASE},
entonces se ejecutarán las sentencias de la sección {#1088,DEFAULT}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    SWITCH (x)
        CASE 1:
            x=-1;
        END
        CASE 2:
            x=-2;
        END
        CASE 3:
            x=-3;
        END
        CASE 99:
            x=-99;
        END
        DEFAULT:
            x=0;
        END
    END
END
{-}

La sentencia {SWITCH} de este programa cambiará de signo la variable {x} si
ésta vale {1}, {2}, {3} o {99}; en caso contrario la pondrá a {0}.

{Rango de valores de una sección case}{/}

En una sección case se puede especificar un valor, un rango de valores
(mínimo {#1064,..} máximo), o una lista de valores y/o rangos separados por {#1059,comas (,)}.
Por ejemplo, la sentencia anterior se podría haber expresado como:

  {SWITCH (x)}·
      {CASE 1..3, 99:}·
          {x=-x;}·
      {END}·
      {DEFAULT:}·
          {x=0;}·
      {END}·
  {END}·

Una vez ejecutada una de las secciones {#1087,CASE} de una sentencia {SWITCH}
{ya no se ejecutarán más secciones}, aunque éstas especifiquen también el
resultado de la expresión, por ejemplo, en la siguiente sentencia:

  {SWITCH (2+2)}·
      {CASE 3..5:}·
          {x=x+1;}·
      {END}·
      {CASE 2, 4, 6:}·
          {y=y-1;}·
      {END}·
  {END}

Se ejecutará la sección {x=x+1;} y después se finalizará la sentencia, no
ejecutándose la sección {y=y-1;} pues, aunque el resultado de la expresión
evaluada ({4}) está contemplado en ella, también lo está en la sección anterior,
(ya que 4 está dentro del rango 3..5).

No es necesario ordenar las secciones {#1087,CASE} según sus valores (de menor
a mayor, o de mayor a menor), pero sí es imprescindible que la sección
{#1088,DEFAULT} (en caso de haberla) sea la última sección. No puede haber
más que una sección {#1088,DEFAULT}.

Es posible anidar sentencias {SWITCH} sin ningún límite, es decir, se pueden
poner nuevas sentencias {SWITCH} dentro de una sección {#1087,CASE} (y
cualquier otro tipo de sentencia).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1022,Sentencia WHILE}

{WHILE} {#1053,(} {#1037,<condición>} {#1053,)}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}·

La sentencia {WHILE} (mientras) es una sentencia que implementa un {bucle}, es
decir, que es capaz de {repetir un grupo de sentencias un número determinado de
veces}.

Para implementar este bucle se debe especificar entre paréntesis la
condición que se debe cumplir para que se ejecute el grupo de sentencias a
continuación de la palabra reservada {WHILE}. Tras especificar esta condición,
se pondrán todas las sentencias que se necesita que se repitan y, finalmente,
se marcará el final del bucle con la palabra reservada {#1091,END} (No
importa que dentro del bucle aparezcan más palabras {#1091,END} si éstas
forman parte de sentencias interiores a dicho bucle).

Cuando se ejecute una sentencia {WHILE} se realizará la comprobación que
se especifica y, si ésta resulta cierta, se ejecutarán las sentencias
interiores; en caso contrario, se continuará el programa a partir
del {#1091,END} que marca el final del {WHILE}.

Si se han ejecutado las sentencias interiores (lo que se denomina realizar
una {iteración} del bucle), se volverá a comprobar la condición y, si ésta
vuelve a ser cierta, se realizará otra {iteración} (se volverán a ejecutar
las sentencias interiores). Este proceso se repetirá hasta que, al comprobarse
la condición del {WHILE}, ésta resulte falsa.

Si según se ejecuta una sentencia {WHILE} la condición resulta falsa directamente,
entonces no se ejecutarán las sentencias interiores ninguna vez.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=0;
    WHILE (x<320)
        x=x+10;
        FRAME;
    END
END
{-}

En este ejemplo se pondrá la variable local {x} (coordenada x del proceso) a
cero y después, mientras x sea menor que 320, se le sumarán 10 a {x} y se
dará un {#1029,FRAME}.

Una sentencia {#1026,BREAK} dentro de un bucle {WHILE} lo finalizará de forma
inmediata, continuando el programa por la sentencia siguiente a dicho bucle.

Una sentencia {#1027,CONTINUE} dentro de un bucle {WHILE} forzará al programa a
comprobar la condición inicial inmediatamente y, si ésta es cierta,
volver a ejecutar las sentencias interiores desde el principio (tras el {WHILE}).
Si la condición resulta falsa, la sentencia {#1027,CONTINUE} finalizará el bucle.

Las sentencias interiores a un bucle {WHILE} pueden ser tantas como se
quieran y de cualquier tipo, incluyendo, por supuesto, nuevos bucles {WHILE}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1023, Sentencia REPEAT}

{REPEAT}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1097,UNTIL} {#1053,(} {#1037,<condición>} {#1053,)}

La sentencia {REPEAT} (REPEAT ... UNTIL( ... )) es una sentencia que implementa
un {bucle}, es decir, que es capaz de {repetir un grupo de sentencias un número
determinado de veces}.

Para implementar este bucle se debe comenzar con la palabra reservada {REPEAT},
seguida de las sentencias que se quieren repetir una o más veces y el final
de la sentencia se determinará poniendo la palabra reservada {#1097,UNTIL}
seguida de la condición que se debe cumplir para que {se de por finalizada
la sentencia}.

Cuando se ejecute una sentencia {REPEAT} se ejecutarán primero las sentencias
interiores (las que están entre el {REPEAT} y el {#1097,UNTIL}) y, tras hacerlo,
se comprobará la condición especificada en el {#1097,UNTIL} y si ésta continúa
siendo falsa, se volverán a ejecutar las sentencias interiores. El proceso se
repetirá hasta que la condición del {#1097,UNTIL} resulte cierta, continuando
entonces la ejecución del programa tras esta sentencia.

Cada vez que se ejecutan las sentencias interiores se dice que se ha realizado
una {iteración} del bucle. La sentencia {REPEAT} ... {#1097,UNTIL} (literalmente
traducida como {REPETIR} ... {HASTA} (que se cumpla la) {<condición>}) siempre
ejecutará las sentencias interiores al menos una vez, ya que comprueba
la condición siempre tras ejecutarlas.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=0;
    REPEAT
        x=x+10;
        FRAME;
    UNTIL (x>320)
END
{-}

En este ejemplo se pondrá la variable local {x} (coordenada x del proceso) a
cero y, después, se le sumarán 10 a {x} y se dará un {#1029,FRAME} {hasta} que
{x} sea un número mayor que 320.

Una sentencia {#1026,BREAK} dentro de un bucle {REPEAT} lo finalizará de
forma inmediata, continuando el programa por la sentencia siguiente a dicho
bucle.

Una sentencia {#1027,CONTINUE} dentro de un bucle {REPEAT} forzará al programa
a realizar la comprobación del {#1097,UNTIL} inmediatamente y, si ésta es
falsa, volverá a ejecutar las sentencias interiores desde el principio (tras la
palabra reservada {REPEAT}). Si la condición resulta cierta, la sentencia
{#1027,CONTINUE} finalizará el bucle.

Las sentencias interiores a un bucle {REPEAT} pueden ser tantas como se
quieran y de cualquier tipo incluyendo, por supuesto, nuevos bucles {REPEAT}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1024,Sentencia LOOP}

{LOOP}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

La sentencia {LOOP} (bucle) es una sentencia que implementa un {bucle infinito},
es decir, que {repite indefinidamente un grupo de sentencias}.

Para implementar este bucle se debe comenzar con la palabra reservada {LOOP},
seguida de las sentencias que se quieren repetir continuamente y la palabra
reservada {#1091,END} al final.

Cuando en un programa se encuentre una sentencia {LOOP} ... {#1091,END} se
ejecutarán a partir de entonces, una y otra vez, todas las sentencias interiores
a dicho bucle.

Para finalizar un bucle {LOOP} se puede utlizar la sentencia {#1026,BREAK}
que, al ejecutarse dentro de un bucle de este tipo, forzará al programa a
seguir a continuación del {#1091,END}.

Cada vez que se ejecutan las sentencias interiores se dice que se ha realizado
una {iteración} del bucle. La sentencia {#1027,CONTINUE}, dentro de un bucle,
finalizará la {iteración} actual y comenzará la siguiente (el programa
continuará ejecutándose tras la palabra reservada {LOOP}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=0;
    LOOP
        IF (key(_esc))
            BREAK;
        END
        x=x+1;
        FRAME;
    END
END
{-}

En este ejemplo se pondrá la variable local {x} (coordenada x del proceso) a
cero y, después, se le sumará 1 y se dará un {#1029,FRAME} continuamente. Si
se pulsa la tecla de escape ({ESC}) se ejecutará la sentencia {#1026,BREAK},
finalizando el bucle {LOOP}.

Las sentencias interiores a un bucle {LOOP} pueden ser tantas como se
quieran y de cualquier tipo incluyendo, por supuesto, nuevos bucles {LOOP}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1025,Sentencia FOR}

{FOR} {#1053,(}<inicialización>{#1068,;} <condición>{#1068,;} <incremento>{#1053,)}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

La sentencia {FOR} (réplica del lenguaje C) es una sentencia que implementa
un {bucle}, es decir, que es capaz de {repetir un grupo de sentencias un número determinado de
veces}.

Para implementar este bucle se deben especificar, entre paréntesis, tres partes
diferentes, separadas por símbolos {#1068,;} (punto y coma) tras la palabra
reservada {FOR}. Estas tres partes son opcionales (pueden omitirse) y son
las siguientes:

- {Inicialización}. En esta parte se suele codificar una sentencia de asignación
que fija el valor inicial de la variable que va a utilizarse como contador de
{iteraciones} del bucle (a cada ejecución del grupo interior de sentencias
se le denomina una {iteración} del bucle). Un ejemplo puede ser la sentencia de
asignación {x=0}, que fijaría la variable {x} a cero al inicio del bucle (valor
para la primera iteración).

- {#1037,Condición}. En esta parte se especifica una condición; justo
antes de cada iteración se comprobará que sea cierta para pasar a ejecutar
el grupo de sentencias. Si la condición se evalúa como falsa, se finalizará
el bucle {FOR}, continuando el programa tras el {#1091,END} del bucle {FOR}.
Un ejemplo de condición puede ser {x<10}, que permitirá que se ejecute el
grupo interior de sentencias únicamente cuando la variable {x} sea un número
menor que {10}.

- {Incremento}. En la última de las tres partes es donde se indica el incremento
de la variable usada como contador por cada iteración del bucle; normalmente
ésto se expresa también con una sentencia de asignación. Por ejemplo, la
sentencia {x=x+1} le sumaría {1} a la variable {x} tras cada iteración del
bucle.

Tras la definición del bucle {FOR} con sus tres partes es donde debe aparecer
el grupo de sentencias interiores al bucle que se van a repetir secuencialmente
mientras se cumpla la condición de permanencia (parte segunda). Tras este grupo
de sentencias la palabra reservada {#1091,END} determinará el final del
bucle {FOR}.

Cuando en un programa llega una sentencia {FOR} se ejecuta primero la parte
de la inicialización y se comprueba la condición; si ésta es cierta se
ejecutará el grupo de sentencias interiores y, después, la parte del incremento,
volviéndose a comprobar la condición, etc. Si antes de cualquier iteración la
condición resulta falsa, finalizará la sentencia {FOR} inmediatamente.

A continuación, se muestra un programa con un bucle {FOR} con las tres partes
sugeridas en las secciones anteriores.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR ( x=0 ; x<10 ; x=x+1 )
        // Aquí vendrían las sentencias interiores.
    END
END
{-}

Este bucle se ejecutaría la primera vez con la variable {x} valiendo {0}, la
segunda valiendo {1}, ..., y la última valiendo {9}; tras esta iteración se
ejecutaría la parte del incremento, pasando {x} a valer {10} y, entonces,
al comprobarse la condición de permanencia en el bucle (que {x} sea menor
que {10}) y resultar ésta falsa, se daría por finalizado el bucle.

Como se ha mencionado, las tres partes en la definición del bucle son opcionales;
si se omitieran las tres:

  {FOR ( ; ; )}·
      // ...·
  {END}

Entonces, este bucle es equivalente a un bucle {#1024,LOOP} ... {#1091,END}.

Además en un bucle {FOR} pueden ponerse varias partes de inicialización,
condición o incremento separadas por comas ({#1059,,}), ejecutándose todas las
inicializaciones al principio, luego comprobándose todas las condiciones
de permanencia (si cualquiera resulta falsa, el bucle finalizará), las
asentencias interiores y, al final, tras cada iteración, todos los incrementos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR ( x=0, y=1000 ; x<y ; x=x+2, y=y+1 )
        // Aqui vendrían las sentencias interiores.
    END
END
{-}

Una sentencia {#1026,BREAK} dentro de un bucle {FOR} lo finalizará de forma
inmediata, continuando el programa por la sentencia siguiente a dicho bucle.

Una sentencia {#1027,CONTINUE} dentro de un bucle {FOR} forzará al programa a
ejecutar directamente la parte del incremento y, después, realizar la comprobación
de permanencia y, si ésta es cierta, volver a ejecutar las sentencias interiores
desde el principio. Si la condición resulta cierta, la sentencia {#1027,CONTINUE}
finalizará el bucle {FOR}.

Un bucle {FOR} es, prácticamente, equivalente a un bucle {#1022,WHILE} implementado
de la siguiente forma:

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=0;
    WHILE (x<10)
        // Aqui vendrían las sentencias interiores.
        x=x+1;
    END
END
{-}

Con la única excepción de que una sentencia {#1027,CONTINUE}, dentro de este
bucle {#1022,WHILE}, no ejecutaría la parte del incremento, mientras que en un bucle {FOR}
sí lo haría.

Si en un bucle {FOR}, tras ejecutarse la inicialización, la condición
resulta falsa directamente, no se ejecutarán ninguna vez las sentencias interiores.

Las sentencias interiores a un bucle {FOR} pueden ser tantas como se
quieran y de cualquier tipo incluyendo, por supuesto, nuevos bucles {FOR}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1026,Sentencia BREAK}

Una sentencia {BREAK} dentro de un bucle lo finalizará de forma
inmediata, continuando el programa por la sentencia siguiente a dicho bucle.
No se puede poner esta sentencia más que dentro de los siguientes bucles:

  {#1022,LOOP} ... {#1091,END}·
  {#1043,FROM} .. {#1096,TO} .. {#1095,STEP} .. ... {#1091,END}·
  {#1023,REPEAT} ... {#1097,UNTIL} {#1053,(} .. {#1053,)}·
  {#1024,WHILE} {#1053,(} .. {#1053,)} ... {#1091,END}·
  {#1025,FOR} {#1053,(} .. {#1068;} .. {#1068,;} .. {#1053,)} ... {#1091,END}·

Un {BREAK} provocará que el programa continúe ejecutándose tras el {#1091,END}
o {#1097,UNTIL} del bucle más cercano a la sentencia.

En caso de haber varios bucles anidados (unos dentro de otros) la sentencia
{BREAK} saldrá únicamente del bucle más interior de ellos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    LOOP
        REPEAT
            IF (key(_esc)) BREAK; END
            //...
        UNTIL (x==0);
        //...
    END
END
{-}

En este ejemplo la sentencia {BREAK} saldrá del {#1023,REPEAT} ... {UNTIL}
(cuando se pulse la tecla {ESC}), pero no del {#1022,LOOP} ... {#1091,END}.

{Importante}{/}

La sentencia {BREAK} no es válida para finalizar sentencias {#1020,IF}, ni
{#1021,SWITCH} (ni las secciones {#1087,CASE} de esta sentencia), ni
sentencias {#1030,CLONE}.

{BREAK} sólo puede finalizar las sentencias que implementan un bucle.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1027, Sentencia CONTINUE}

Una sentencia {CONTINUE} dentro de un bucle forzará al programa a
finalizar la iteración actual del mismo y comenzar la siguiente.

Se denomina {iteración} a cada ejecución del grupo de sentencias interior
a un bucle (las sentencias entre un {#1022,LOOP} y su {#1091,END}, por
ejemplo).

No se puede poner esta sentencia más que dentro de los siguientes bucles:

{#1022,LOOP} ... {#1091,END}·
Un CONTINUE dentro de este bucle saltará al LOOP.

{#1043,FROM} .. {#1096,TO} .. {#1095,STEP} .. ... {#1091,END}·
Un CONTINUE dentro de este bucle realizará el incremento (STEP) y, si no
se ha pasado el valor indicado en el TO, continuará el programa al inicio
del bucle.

{#1023,REPEAT} ... {#1097,UNTIL} {#1053,(}..{#1053,)}·
Un CONTINUE dentro de este bucle saltará al UNTIL.

{#1024,WHILE} {#1053,(} .. {#1053,)} ... {#1091,END}·
Un CONTINUE dentro de este bucle saltará al WHILE.

{#1025,FOR} {#1053,(} .. {#1068,;} .. {#1068,;} .. {#1053,)} ... {#1091,END}·
Un CONTINUE dentro de este bucle realizará el incremento y la comparación;
si ésta última resulta cierta continuará el programa al inicio del bucle,
si resulta falsa el programa continuará tras el END del FOR.

En caso de haber varios bucles anidados (unos dentro de otros) la sentencia
{CONTINUE} tendrá efecto únicamente en el bucle más interior de ellos.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR (x=0, y=0;x<10;x++)
        IF (x<5) CONTINUE; END
        y++;
    END
END
{-}

En este ejemplo, tras ejecutarse el bucle completo, {x} valdrá {10} e {y}
valdrá {5}, pues mientras {x} es menor que 5 la sentencia {CONTINUE}
impide que se ejecute la sentencia {y++;}.

{Importante}{/}

La sentencia {CONTINUE} no es válida dentro de sentencias {#1020,IF}, ni
{#1021,SWITCH} (ni las secciones {#1087,CASE} de esta sentencia), ni
sentencias {#1030,CLONE} (ya que estas sentencias no implementan bucles y,
por tanto, no realizan iteraciones).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1028,Sentencia RETURN}

La sentencia {RETURN} finaliza el proceso actual de forma inmediata, como
si se llegara al {#1091,END} de su {#1086,BEGIN}.

Esta sentencia en el código principal lo finalizará, pero si quedan procesos
vivos éstos se seguirán ejecutando. Para terminar un programa y todos sus
procesos se puede utilizar, por ejemplo, la función {#109,exit()}.

Un {RETURN} dentro de un proceso lo finalizará, matando a dicho proceso.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    LOOP
        IF (key(_esc))
            RETURN;
        END
        FRAME;
    END
END
{-}

En este ejemplo, al pulsarse la tecla de escape ({ESC}) se ejecutará la
sentencia {RETURN}, finalizando el programa.

{Uso de RETURN para retornar un valor}{/}

Es posible construir procesos con un comportamiento similar a las funciones
de otros lenguajes de programación, que {reciban una serie de parámetros y
devuelvan un valor}. Por ejemplo, un proceso que reciba dos valores numéricos
y devuelva el mayor de ambos.

Para ello, se debe utilizar esta sentencia con la siguiente sintaxis:

{RETURN(}{#1035,<expresión>}{)}

También es importante no utilizar la sentencia {#1029,FRAME} dentro del proceso,
pues ésta retornará inmediatamente al proceso llamante. Cuando el compilador
encuentra la sentencia {#1029,FRAME} dentro de un {#1016,PROCESS} lo cataloga
directamente como proceso, descartando su posible uso como función.

A continuación se muestra el ejemplo antes propuesto: una implementación de
la función matemática {max} que devuelve el mayor de sus dos parámetros.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    x=max(2, 3)+max(5, 4);
END
PROCESS max(a, b)
BEGIN
    IF (a>b)
        RETURN(a);
    ELSE
        RETURN(b);
    END
END
{-}

Tras ejecutarse este programa, la variable {x} del proceso principal valdrá {8} (3+5).

{Importante}{/}

Por defecto, si se utiliza la sentencia {RETURN} sin la expresión
entre paréntesis o la sentencia {#1029,FRAME} en un proceso, el valor de retorno del
mismo será su {#1039,código identificador} de proceso}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1029,Sentencia FRAME}

La sentencia {FRAME} es una pieza clave dentro del lenguaje. El funcionamiento
de un programa es, a grandes rasgos, el siguiente:

- Comienza ejecutándose el proceso principal, el cual puede crear más
procesos (objetos del juego) en cualquier punto. Todos los procesos pueden
finalizar en cualquier momento, crear o eliminar otros procesos.

- Los juegos se visualizarán siempre imagen a imagen (frame by frame).
En cada imagen, el sistema ejecutará todos los procesos existentes en ese
momento, uno por uno, hasta que cada uno ejecute la sentencia {FRAME}, que
indicará que está listo para la siguiente visualización (imagen).

En la preparación de cada imagen todos los procesos serán ejecutados en
el orden de prioridad establecido (la variable local {#1121,priority} de los
procesos determina este orden).

Luego esta sentencia es algo así como la orden de visualización de los
procesos.

Si un proceso comienza a ejecutarse y no finaliza ni ejecuta
esta sentencia, entonces el programa se quedará bloqueado, ya que existe
un proceso que no está nunca listo para la siguiente visualización; por lo que
el sistema será incapaz de mostrar la siguiente imagen.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    mi_proceso();
    mi_proceso();
    LOOP
        IF (key(_esc))
            mi_segundo_proceso();
        END
        FRAME;
    END
END
PROCESS mi_proceso()
BEGIN
    LOOP
        FRAME;
    END
END
PROCESS mi_segundo_proceso()
BEGIN
    LOOP
    END
END
{-}

En este programa el proceso principal (de tipo {mi_juego}) crea otros dos
procesos (de tipo {mi_proceso}); a partir de este momento los tres procesos
se ejecutarán continuamente, cada uno hasta su sentencia {FRAME}. Pero si
se pulsa la tecla de escape ({ESC}), el proceso principal creará un nuevo
proceso (de tipo {mi_segundo_proceso}) que se quedará en un bucle {#1024,LOOP}
indefinidamente, sin ejecutar ningún {FRAME}, por lo que el programa
quedará interrumpido (el sistema advertirá de dicha situación transcurridos
unos segundos, ver {#1115,max_process_time}).

Básicamente, todos los procesos que se corresponden con objetos de un juego
construyen un bucle dentro del cual, cada imagen, fija todos sus valores
de visualización ({#1123,x}, {#1124,y}, {#1126,graph}, {#1128,size}, {#1129,angle}, ...)
y, después, ejecutan la sentencia {FRAME}.

{Sincronización de procesos}{/}

Es posible utilizar esta sentencia con la siguiente sintaxis:

{FRAME(}<porcentaje>{)}

Poniendo un porcentaje entero, de 0 a 100 o mayor, entre paréntesis tras
la palabra reservada {FRAME}.

Este porcentaje indicará el tanto por ciento de la siguiente imagen completado
por el proceso; es decir, cuando no se especifica dicho porcentaje
es lo mismo que si se pusiera {FRAME(100)} (se ha completado el 100% del
trabajo previo a la siguiente visualización por parte del proceso).

Por ejemplo, si un proceso ejecuta en un bucle la sentencia {FRAME(25)},
necesitará ejecutarla {4 veces} antes de estar listo para la siguiente
visualización (ya que 4*25% es el 100%).

En el otro extremo, si un proceso ejecuta dentro de su bucle la sentencia
{FRAME(400)}, cuando se ejecute la primera vez habrá completado ya un
400% de la visualización, por lo que, aun tras visualizarse, le seguirá
restando un 300% de visualización completado. Por ello, en la preparación
de las siguientes {3} imágenes el sistema no ejecutará dicho proceso, pues
ya está listo para la visualización. Luego este proceso se ejecutaría
sólo una de cada 4 imágenes (al contrario que el ejemplo del párrafo anterior,
que se ejecutaba 4 veces por cada imagen del juego).

Los procesos no llegarán a la siguiente visualización hasta no dar,
{por lo menos, el 100%}. Por ejemplo, si un proceso ejecuta siempre sentencias
{FRAME(80)}, las ejecutará dos veces antes de la primera visualización con lo
que llevará el 160% (2*80%) de la visualización completado. Para la siguiente
visualización tendrá, por tanto, un 60% pre-completado (160%-100%); por ello, en la
segunda visualización tan solo requerirá una sentencia {FRAME(80)} para
visualizarse, ya que este 80%, unido al 60% sobrante de la primera, hará un total
de un 140% completado, con lo cual se visualizará inmediatamente, e incluso le
sobrará otro 40% para la preparación de la siguiente imagen.

{/}

Una sentencia {FRAME(0)}, que complete un 0% de la siguiente visualización,
puede tener sentido en estos dos casos:

- Puede ser una forma de forzar al sistema a que ejecute en ese punto al resto
de los procesos que tienen la misma prioridad que el actual y que, tras ellos,
vuelva a ejecutarlo.

- O puede ser una forma de inicializar funciones como {#120,get_id()} o
{#104,collision()}, pues éstas devuelven unos determinados valores para
cada imagen; si se quiere volver a obtener valores de nuevo, se puede
ejecutar una sentencia {FRAME(0)} que estas funciones interpretarán
como una nueva imagen.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1030,Sentencia CLONE}

{CLONE}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

Esta sentencia crea un nuevo proceso idéntico al actual, con la salvedad
de que las sentencias entre las palabras reservadas {CLONE} y {#1091,END} se
ejecutarán únicamente en el nuevo proceso y no en el actual.

Por ejemplo, si cualquier proceso del programa, con unas coordenadas ({#1123,x},
{#1124,y}) determinadas y un gráfico ({#1126,graph}) concreto, ejecuta la
siguiente sentencia:

  {CLONE}·
      x=x+100;·
  {#1091,END}

Se creará un nuevo proceso identico a él, con el mismo gráfico y los mismos
valores en todas sus variables, a excepción de la coordenada {#1123,x}, que
el nuevo proceso tendrá {100} puntos más a la derecha.

Esta sentencia se utiliza para crear réplicas de un proceso, dividirlo en
dos procesos (casi) iguales.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    // ...
    x=0;
    y=0;
    CLONE
        x=x+10;
    END
    CLONE
        y=y+10;
    END
    // ...
END
{-}

En este ejemplo, las {2} sentencias {CLONE} crearán {3} copias del proceso
principal (y no 2, como podría haberse esperado).

Al ejecutarse la primera sentencia {CLONE} se creará un nuevo proceso, con
lo que habrá {2}: uno en (x=0, y=0) y otro en (x=10, y=0). Y estos dos
procesos ejecutarán la segunda sentencia {CLONE}, el primero (el original)
creando con ello un nuevo proceso en (x=0, y=10), y el segundo creará el
nuevo proceso en (x=10, y=10).

Para crearse únicamente {2} copias del proceso original se podría haber
construido el programa, por ejemplo, de la siguiente forma:

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    // ...
    x=0;
    y=0;
    CLONE
        x=x+10;
        CLONE
            y=y+10;
        END
    END
    // ...
END
{-}

El proceso original (x=0, y=0) creará uno en (x=10, y=0) y éste, a su vez,
otro en (x=10, y=10), creandose únicamente dos copias del original.

Se debe, por tanto, tener mucho cuidado con el uso de la sentencia {CLONE}
de forma secuencial o dentro de un {bucle}, pues se debe contar con que los
primeros '{clones}' pueden crear, a su vez, a nuevos '{clones}'.

Esta sentencia permite usarse sin poner sentencias entre las palabras
{CLONE} y {#1091,END}. Pero, al menos en un principio, no parece tener mucho
sentido el querer tener dos procesos idénticos, con las mismas coordenadas,
el mismo gráfico y ejecutando el mismo código.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1031,Sentencia DEBUG}

La sentencia {DEBUG} invocará al trazador (o debugger) interactivo cuando
se ejecute.

Se suele utilizar para depurar programas, es decir, para encontrar posibles
errores que tengan los programas. Se suele poner, en ocasiones, en los siguientes
puntos.

- Donde se quiera comprobar que una parte del programa ha hecho lo que se
esperaba que hiciera; tras ejecutarse dicha parte, {DEBUG} invocará al
trazador, desde donde pueden comprobarse todos los procesos activos y el
valor de todas sus variables.

- Cuando no se está muy seguro de si algo puede suceder en un programa, se
puede poner esta sentencia en dicho punto, para que nos avise en caso de que
suceda.

Esta sentencia se pone únicamente de forma temporal hasta que se localiza
el error buscado; una vez encontrado ya no es necesaria la sentencia por lo que se puede quitar
del programa, ya que por lo demás, no tiene ningún otro efecto.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    // ...
    IF (x<0)
        DEBUG;
    END
    // ...
END
{-}

En este ejemplo se comprueba, en un determinado punto del programa, que la
coordenada {x} del proceso no sea un número negativo (menor que cero); si
esto sucediera, se invocará al trazador para poder investigar por qué
ha sucedido.

Cuando se ejecuta esta sentencia se abre un cuadro de diálogo que nos
ofrece las siguientes opciones:

- Desabilitar la sentencia {DEBUG}, para que no vuelva a activarse en
esta ejecución del programa.

- Detener el programa y entrar en el trazador, para poder examinar todos
los procesos y sus variables.

- O terminar de inmediato la ejecución del programa, regresando a la edición
del mismo en el entorno gráfico de ventanas.

Además, si se pulsa la tecla de escape {ESC} en dicho cuadro, simplemente
se ignorará dicha sentencia {DEBUG} y se continuará ejecutando el programa
normalmente.

{/}

Cuando se ejecuta un programa desde el entorno gráfico de ventanas, puede
invocarse al trazador en cualquier instante pulsando la tecla {F12}.

Al invocarse de esta forma al trazador, el programa será interrumpido siempre
justo antes de empezar a procesar una nueva imagen, estando todos los
procesos por ejecutar antes de la próxima visualización.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1032,Lista de funciones del lenguaje.}

  Funciones de interacción entre procesos·
    {#104,collision()}·
    {#116,get_angle()}·
    {#117,get_dist()}·
    {#118,get_distx()}·
    {#119,get_disty()}·
    {#120,get_id()}·
    {#129,let_me_alone()}·
    {#158,signal()}·

  Funciones matemáticas·
    {#100,abs()}·
    {#101,advance()}·
    {#113,fget_angle()}·
    {#114,fget_dist()}·
    {#142,near_angle()}·
    {#145,pow()}·
    {#149,rand()}·
    {#150,rand_seed()}·
    {#160,sqrt()}·

  Funciones gráficas·
    {#103,clear_screen()}·
    {#123,get_pixel()}·
    {#135,map_block_copy()}·
    {#136,map_get_pixel()}·
    {#137,map_put()}·
    {#138,map_put_pixel()}·
    {#139,map_xput()}·
    {#146,put()}·
    {#147,put_pixel()}·
    {#148,put_screen()}·
    {#173,xput()}·

  Funciones para música y sonido·
    {#102,change_sound()}·
    {#127,is_playing_cd()}·
    {#134,load_pcm()}·
    {#144,play_cd()}·
    {#178,set_volume()}·
    {#159,sound()}·
    {#164,stop_cd()}·
    {#167,stop_sound()}·
    {#175,reset_sound()}·
    {#170,unload_pcm()}·

  Funciones de entrada·
    {#121,get_joy_button()}·
    {#122,get_joy_position()}·
    {#128,key()}·

  Funciones para el manejo de la paleta·
    {#105,convert_palette()}·
    {#110,fade()}·
    {#111,fade_off()}·
    {#112,fade_on()}·
    {#133,load_pal()}·
    {#154,roll_palette()}·

  Funciones para scroll y modo-7·
    {#140,move_scroll()}·
    {#152,refresh_scroll()}·
    {#162,start_mode7()}·
    {#163,start_scroll()}·
    {#165,stop_mode7()}·
    {#166,stop_scroll()}·

  Funciones para imprimir textos·
    {#107,delete_text()}·
    {#131,load_fnt()}·
    {#141,move_text()}·
    {#171,write()}·
    {#177,unload_fnt()}·
    {#172,write_int()}·

  Funciones para animaciones·
    {#108,end_fli()}·
    {#115,frame_fli()}·
    {#153,reset_fli()}·
    {#161,start_fli()}·

  Funciones de regiones de pantalla·
    {#106,define_region()}·
    {#143,out_region()}·

  Funciones de información sobre gráficos·
    {#124,get_point()}·
    {#125,get_real_point()}·
    {#126,graphic_info()}·

  Funciones de inicialización·
    {#156,set_fps()}·
    {#157,set_mode()}·
    {#132,load_fpg()}·
    {#174,load_map()}·
    {#169,unload_fpg()}·
    {#176,unload_map()}·

  Funciones de grabación de datos·
    {#130,load()}·
    {#155,save()}·

  Funciones de sistema·
    {#109,exit()}·
    {#168,system()}·

{/}

{Nota:} Para obtener ayuda de una función en concreto directamente, sitúe el
cursor de edición sobre el nombre de la función (en el editor de programas)
y pulse {F1}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1033,Llamada a un proceso}

<nombre_del_proceso>{(}<lista de parámetros>{)}

Una llamada a un proceso se hace poniendo el {#1001,nombre} del
proceso (su nombre), seguido de una lista con tantas expresiones
separadas por {#1059,comas (,)}, como {#1018,parámetros} tenga el proceso,
entre {#1053,paréntesis (())}. Los paréntesis son obligatorios aun cuando
el proceso no tenga {#1018,parámetros} de llamada.

Una llamada a un proceso siempre devolverá un valor, que depende de cual
de las siguientes acciones realice primero el proceso llamado.

- Si ejecuta la sentencia {#1029,FRAME} el proceso retornará su {#1039,código identificador}.

- Si el proceso ejecuta la sentencia {#1028,RETURN}{#1053,(}<expresión>{#1053,)}
retornará el resultado de dicha expresión.

- Si el proceso termina, bien porque llegue el {#1091,END} de su {#1086,BEGIN}
o porque ejecute una sentencia {#1028,RETURN} sin expresión, el proceso
retornará el {#1039,código identificador} que tuvo, pero como el proceso ha
finalizado (muerto), se debe tener en cuenta que dicho
{#1039,código identificador} puede ser ahora utilizado por cualquier otro proceso
que se cree a partir de ahora.

El valor de retorno puede ignorarse, asignarse a una variable o bien
utilizarse dentro de una expresión.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE
  id2;
BEGIN
    mi_proceso(0, 0);
    id2=mi_proceso(320, 200);
    // ...
END
PROCESS mi_proceso(x, y)
BEGIN
    LOOP
        FRAME;
    END
END
{-}

En este ejemplo el proceso principal {mi_juego} realiza dos llamadas
al proceso {mi_proceso}, que recibe dos parámetros en sus variables locales
{x} e {y}.

Como el proceso ejecuta la sentencia {#1029,FRAME} devolverá su
{#1039,código identificador}.

Se puede observar cómo el valor devuelto en la primera llamada al proceso
es despreciado (no se utiliza para nada), y cómo en la segunda se asigna
el {#1039,código identificador} de {mi_proceso(320, 200)} a la variable privada del
proceso principal {id2}.

Cuando se realiza una llamada a un proceso se detiene momentáneamente la
ejecución del proceso actual y se pasa a ejecutar el código del proceso
llamado, hasta que este retorne por uno de los tres casos enumerados (hasta
que termine o ejecute una sentencia {#1029,FRAME} o {#1028,RETURN}).

Si el proceso ha terminado con una sentencia {#1029,FRAME} se visualizará
en la siguiente imagen según los valores establecidos en sus variables
locales ({#1023,x}, {#1024,y}, {#1026,graph}, ...) y, en la preparación de
la siguiente imagen, dicho proceso continuará ejecutándose a partir de
la sentencia {#1029,FRAME}.

{/}Ver: {#1000,Sintaxis} - {#1018,Parámetros de un proceso}

# ─────────────────────────────────────────────────────────────────────────────

{.1034,Referencia a un dato}

Una referencia a un dato es cualquier expresión que haga referencia a una
celda o posición de la memoria del ordenador, normalmete suele entenderse
como uno de los siguientes aspectos:

- Si el dato es una variable, para referirnos de esta forma al dato
simplemente debemos especificar su nombre.

Ejemplo de una referencia a una variable: {x}

- Si el dato es una tabla se suele hacer referencia a la misma
con su nombre seguido de una expresión entre corchetes ({#1079,[ ]}); dicha
expresión determinará la posición de la tabla que se pretende acceder.
Si se omite el índice entre corchetes se accederá a la primera posición de
la tabla (la posición 0).

Ejemplo de una referencia a una tabla: {timer[0]}

- Si el dato es una estructura se hará referencia a la misma con su
nombre seguido de una expresión entre corchetes ({#1079,[ ]}) que
determinará el número de registro al que se accederá y, tras esto, irá
el símbolo{#1063, . (punto)} precediendo al nombre concreto del campo
de la estructura al que se va a acceder. Si se omite el número de registro
entre corchetes se accederá al primer registro de la estructura (el número 0).

Ejemplo de una referencia a una estructura: {scroll[0].z}

Estos tres casos se refieren a accesos a datos del propio proceso o globales;
cuando se pretenda acceder a un dato ajeno (un dato local de otro proceso),
se precederá por el {#1039,código identificador} del
proceso ajeno y el símbolo{#1063, . (punto)}, operador de acceso a datos
locales y estructuras).

Ejemplo de una referencia a una variable local ajena: {father.x}

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1035,Definición de una expresión}

Una expresión se entiende, básicamente, como una fórmula matemática que
involucre a uno o más {operandos} ({x}, {2}, {id}, ...) por medio de diversos
{operadores} ({*}, {AND}, {>>}, ...); algunos ejemplos de expresiones serían:
{2}, {2+3} o {(x*4)/-3}.

Como valores se pueden utilizar únicamente números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int}) y el resultado de la expresión
siempre quedará truncado dentro de este rango.

Estas expresiones serán evaluadas cuando se ejecute la sentencia que las
contiene dentro del programa.

Los {operandos} que se pueden utilizar en una expesión son:

    - {#1004,Constantes}.·
    - {Valores numéricos}.·
    - {Literales} (textos entre comillas).·
    - {#1010,Variables}, tablas o estructuras de cualquier tipo.·
    - Cualquier tipo de función o proceso.·
    - {#1039,Código identificador} del proceso.·
    - Tipo de proceso ({#1042,type <nombre>}).·

Los {operadores} que se pueden utilizar en una expresión son (entre
paréntesis se muestran los sinónimos del operador, en caso de tenerlos):

    {#1056, +}    Suma·
    {#1060, -}    Resta (o negación de signo)·
    {#1054, *}    Multiplicación·
    {#1065, /}    División·
    {#1048, MOD}  Módulo ({#1048,%})·
    {#1070, <<}   Rotación a la derecha·
    {#1077, >>}   Rotación a la izquierda·
    {#1045, NOT}  Negación binaria y lógica ({#1045,!})·
    {#1051, AND}  AND binario y lógico ({#1050,&}, {#1051,&&})·
    {#1083, OR}   OR binario y lógico ({#1083,|}, {#1083,||})·
    {#1082, XOR}  OR exclusivo ({#1080,^}, {#1082,^^})·
    {#1074, ==}   Comparación·
    {#1046, <>}   Distinto ({#1046,!=})·
    {#1076, >}    Mayor·
    {#1075, >=}   Mayor o igual ({#1075,=>})·
    {#1069, <}    Menor·
    {#1072, <=}   Menor o igual ({#1072,=<})·
    {#1085, OFFSET} Dirección o desplazamiento ({#1050,&})·
    {#1057, ++}   Operador de incremento·
    {#1061, --}   Operador de decremento·
    {#1079, POINTER} Operador de indirección ({#1054,*}, {#1080,^}, {#1079,[ ]})·
    {#1053, ( )}  Paréntesis·

Pulse sobre "{#1036,Evaluación de una expresión}" para ver el orden en el
que son realizados los cálculos dentro de una expresión y cuándo deben usarse los paréntesis.

A continuación se muestran algunos ejemplos de expresiones válidas:

{    -33}·
{    44-2*22}·
{    id}·
{    x+1}·
{    (angle*3)/2-pi/2}·
{    (x+y)/2}·
{    abs(x-y)*3-pow(x, 2)}·
    ...

{/}Ver: {#1000,Sintaxis} - {#1036,Evaluación de una expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1036,Evaluación de una expresión}

Es importante conocer la forma en la que son evaluadas las expresiones para
saber dónde pueden ser necesarios o no paréntesis que indiquen el modo en el
que se pretende que la expresión sea evaluada.

En el lenguaje, una expresión puede contener operadores de diferentes niveles
de prioridad.

En la evaluación de una expresión serán siempre procesados primero los de
{prioridad 1} (si los hay), luego los de {prioridad 2}, tras estos los de
{prioridad 3} y, así, sucesivamente.

Prioridad 1·
    {#1053, ( )}  Paréntesis, inicio y fin de una sub-expresión·

Prioridad 2·
    {#1063, .}    Punto, operador de acceso a datos locales y estructuras·

Prioridad 3·
    {#1045, NOT}  Negación binaria y lógica (#1045,{!})·
    {#1085, OFFSET} Dirección o desplazamiento (#1050,{&})·
    {#1079, POINTER} Operador de indirección ({#1054,*}, {#1080,^}, {#1079,[ ]})·
    { -}  Negación de signo·
    {#1057, ++}   Operador de incremento·
    {#1061, --}   Operador de decremento·

Prioridad 4·
    {#1054, *}    Multiplicación·
    {#1065, /}    División·
    {#1048, MOD}  Módulo ({#1048,%})·

Prioridad 5·
    {#1056, +}    Suma·
    {#1060, -}    Resta·

Prioridad 6·
    {#1070, <<}   Rotación a la derecha·
    {#1077, >>}   Rotación a la izquierda·

Prioridad 7·
    {#1051, AND}  AND binario y lógico ({#1050,&}, {#1051,&&})·
    {#1083, OR}   OR binario y lógico ({#1083,|}, {#1083,||})·
    {#1082, XOR}  OR exclusivo ({#1080,^}, {#1082,^^})·

Prioridad 8·
    {#1074, ==}   Comparación·
    {#1046, <>}   Distinto ({#1046,!=}·
    {#1076, >}    Mayor·
    {#1075, >=}   Mayor o igual ({#1075,=>}·
    {#1069, <}    Menor·
    {#1072, <=}   Menor o igual ({#1072,=<}·

Prioridad 9·
    {#1073, =}    Asignación·
    {#1058, +=}   Suma-asignación·
    {#1062, -=}   Resta-asignación·
    {#1055, *=}   Multiplicación-asignación·
    {#1066, /=}   División-asignación·
    {#1049, %=}   Módulo-asignación·
    {#1052, &=}   AND-asignación·
    {#1084, |=}   OR-asignación·
    {#1081, ^=}   XOR-asignación·
    {#1078, >>=}  Rotación a la derecha-asignación·
    {#1071, <<=}  Rotación a la izquierda-asignación·

Los operadores de {prioridad 3} son los operadores conocidos como {unarios}; éstos
no relacionan a dos operandos (que es el caso de los operadores {binarios} como,
por ejemplo, una multiplicación), sino que únicamente afectan al valor de un
operador. Dentro de los operadores {unarios} se ejecutarán primero los más
cercanos al operando, por ejemplo en la expresión:

  {NOT -x}

El operando {x} tiene dos operadores {unarios}, la negación de signo{ -} y
el {#1045,NOT} lógico y/o binario; de éstos se ejecutará primero la negación de
signo, pues es la que está más cerca del operando.

Todos los operadores a partir de la {prioridad 4} son {binarios} y se
ejecutarán según su nivel de prioridad por lo que, cuando en una expresión haya más
de un operador del mismo nivel (por ejemplo, una multiplicación y una división,
que son ambas de prioridad 4), se procesarán de izquierda a derecha, es decir,
en la siguiente expresión:

  {8/2*2}

Se ejecutará primero la división y después la multiplicación (que es la forma
natural de evaluar las expresiones en matemáticas).

La única excepción son los operadores de {prioridad 9} (operadores de {asignación}),
que serán evaluados de derecha a izquierda (en lugar de izquierda a derecha), es
decir, en la expresión:

  {x=y=0}

Primero, se procesará {y=0} (se pondrá {y} a {0}) y, después, {x=y} (también se
pondrá {x} a {0}, ya que {y} ahora valdrá {0}).

Como se puede observar las asignaciones funcionan a modo de operador
devolviendo, tras realizar la asignación, el valor que han asignado como
resultado de la operación.

{/}Ver: {#1000,Sintaxis} - {#1035,Definición de una expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1037,Definición de una condición}

Las condiciones son expresiones que normalmente son como las siguientes:

  {x<320}·
  {size==100 AND graph>10}·
  {y==0 OR (x>=100 AND x<=200)}·
  ...

En general, cualquier expresión es válida como condición. En el lenguaje
se interpretan todas las expresiones {IMPARES} como {ciertas} y todas las {PARES}
como {falsas}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    IF (20*2+1)
        x=x+1;
    END
END
{-}

En este ejemplo la sentencia {x=x+1;} se ejecutará siempre, pues la expresión
{20*2+1} vale {41}, que es un número {impar}.

Todos los operadores disponibles son válidos dentro de una condición, incluso
es posible realizar asignaciones dentro de una condición (las asignaciones
son operaciones que devuelven como resultado el valor asignado).

Todos los {#1039,códigos identificadores} de procesos son números {impares},
es decir, todos son {ciertos}. Es posible, por tanto, implementar condiciones
como la siguiente (suponiendo que {id2} se haya declarado como variable,
y {disparo} es un tipo de proceso del programa).

  {WHILE (id2=get_id(type disparo))}·
      {id2.size=id2.size-1;}·
  {END}

En la condición {id2=get_id(type disparo)} se está asignando el resultado
de la función {get_id} a la variable {id2}; si dicha función ha devuelto
un {#1039,código identificador} éste será un número {impar} y la condición será evaluada
como {cierta} (si {get_id()} no encuentra (más) identificadores de procesos
"tipo {disparo}", entonces devolverá {0} (que es un número {par})
interpretándose la condición como {falsa}, y terminando la sentencia {#1022,WHILE}.

Las sentencias anteriores decrementarían la variable {#1128,size} (tamaño) de todos
los procesos de tipo {disparo} que hubiera en el programa.

{/}Ver: {#1000,Sintaxis} - {#1035,Definición de una expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1038,Formas de obtener el código identificador de un proceso.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Todos los procesos tienen su propio {#1039,código identificador} en {#1092,ID}
(palabra reservada en el lenguaje que equivale al {#1039,código identificador} del
proceso).

Cuando se crea un proceso (se llama), éste devuelve como valor de retorno
su propio {#1039,código identificador}, a no ser que haya terminado con un
{#1028,RETURN}{#1053,(}<expresión>{#1053,)}. Es decir, un proceso devolverá
su {#1039,código identificador} siempre que termine (llegue su {#1091,END}), ejecute
la sentencia {#1029,FRAME} o la sentencia {#1028,RETURN} sin expresión
entre paréntesis.

En el siguiente ejemplo, desde el programa principal se crea un proceso
(de tipo {mi_proceso}) y se guarda su identificador en la variable {id2}.

{#9999,Ejemplo:}
PROGRAM mi_juego;
PRIVATE id2;
BEGIN
    id2=mi_proceso();
    // ...
END
PROCESS mi_proceso()
BEGIN
    // ...
END
{-}

Todos los procesos tienen predefinidas las siguientes variables locales
con indentificadores de otros procesos:

{#1117,father} - padre, identificador del proceso que lo creó (el que hizo
la llamada).

{#1118,son} - hijo, identificador del último proceso creado por éste (último
proceso al que se ha llamado).

{#1120,bigbro} - Hermano mayor, identificador del último proceso que creó
el padre antes de crear éste.

{#1119,smallbro} - Hermano menor, identificador del siguiente proceso que
creó el padre tras crear éste.

Estas variables pueden valer {0} si no han sido definidas (por ejemplo
{#1118,son} valdrá {0} hasta que no se cree un proceso, o si éste ya
ha desaparecido).

Los códigos identificadores de los procesos permiten acceder a las variables
locales del mismo (<identificador>.<variable>), y como {#1117,father},
{#1118,son}, etc., son, a su vez, variables locales se pueden realizar
combinaciones como {son.bigbro} para acceder al identificador del penúltimo
proceso creado (ya que {#1118,son} es el del último, por lo que su hermano mayor será
el penúltimo).

Hay otras formas de obtener códigos identificadores de procesos (además de
cuando se crean y por parentesco directo), como son:

- La función {#120,get_id()} para obtener los identificadores de los procesos
de un tipo determinado (nave, disparo, etc.) que existen en un determinado
momento del juego.

- La función {#104,collision()} para obtener los identificadores de los
procesos con los se está chocando (colisionando).

Cuando un proceso determinado necesita acceder desde muchos otros, por
ser un proceso importante como, por ejemplo, la nave protagonista de un juego,
entonces puede ser más útil asignar su identificador a una variable
{#1006,GLOBAL} del programa (que puede ser accedida por cualquier proceso
en cualquier punto).
De esta forma cualquier proceso podrá interactuar con él, ya que tendrá su
identificador.

{#9999,Ejemplo:}
PROGRAM mi_juego;
GLOBAL
  id_nave;
BEGIN
    id_nave=nave();
    // ...
END
PROCESS nave()
BEGIN
    // ...
END
PROCESS enemigo()
BEGIN
    // ...
    id_nave.z=0;
    // ...
END
{-}

En este ejemplo los procesos de tipo {enemigo} acceden en un determinado
punto a la variable {z} de la {nave} que creó el programa principal,
utilizando para ello su identificador que está en la variable global {id_nave}.

{/}Ver: {#1039,Códigos identificadores de procesos.}

# ─────────────────────────────────────────────────────────────────────────────

{.1039,Códigos identificadores de procesos.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Un proceso es un objeto independiente del programa que ejecuta su propio
código y que puede tener sus propias coordenadas, gráficos, etc., por ejemplo
pueden ser procesos de un programa: una nave, un disparo o un enemigo.

Cuando se pone dentro de un programa algo similar a esto:

{PROCESS disparo(}...{);}·
{#1086,BEGIN}·
   { // }sentencias{ ...}·
{#1091,END}

Se están especificando las sentencias que van a ejecutar los procesos
"de tipo {disparo}", es decir, el código que va a regir su comportamiento.

Como se puede observar puede haber en un programa más de un proceso tipo
{disparo}, luego ¿cómo se diferencian unos de otros? Sencillamente, por
su código identificador.

Cada vez que en un juego se crea un nuevo proceso, a éste le es asignado un
código identificador; este código va a ser la referencia exclusiva del
proceso hasta el momento en el que desaparezca.

Dos procesos diferentes no tendrán nunca el mismo código identificador a la vez;
sin embargo, el código que perteneció a un proceso que ya ha desaparecido le puede
ser asignado a un nuevo proceso (algo así como el número del carnet de identidad).

Los código identificadores son siempre números enteros positivos e impares,
como podrían ser 471, 1937 o 10823.

Todos los procesos tienen su propio código identificador en {#1092,ID}, que es
algo similar a una variable local del proceso, salvo que no puede modificarse.

Los procesos, además, tienen el código identificador del proceso que les
creó (el que los llamó) en {#1117,father} (padre), el del último proceso
que ellos crearon (el último que llamaron) en {#1118,son} (hijo), etc.
(ver {#1041,Jerarquías de procesos}).

{¿Para qué sirven los códigos identificadores?}{/}

Normalmente, todos los procesos necesitan el código identificador de los demás
procesos para interactuar con ellos (ver donde están, modificarlos, ...).

No se puede, por ejemplo, restarle energía al proceso "tipo {enemigo}", pues
procesos de ese tipo pueden no existir ninguno o existir muchos; se necesita el
código identificador concreto del proceso {enemigo} al que se quiere restarle
energía.

Un proceso accede a todas sus propias variables simplemente por sus nombres, como
{#1123,x}, {#1128,size} o {#1126,graph}. Pues bien, si se dispone del
identificador de un proceso (en {#1118,son}, {#1117,father} o cualquier
variable definida por el usuario, como {id2}) se puede, entonces, acceder
a las variables de dicho proceso como ({son.x}, {father.size} o {id2.graph}),
es decir, la sintaxis para acceder a variables locales de otro proceso es:

  <código_identificador> . <nombre_variable>

Pudiéndose utilizar dichas variables normalmente para consultarlas o modificarlas.

{No es posible en ningún caso acceder a variables de tipo {#1008,PRIVATE} de
otro proceso}. Si se quiere acceder a una variable privada de otro proceso,
se debe cambiar la declaración de ésta a la sección {#1007,LOCAL} para
convertirla en una variable local; entonces, cualquier proceso podrá acceder
a dicha variable teniendo el código identificador del proceso, ya que todos
los procesos poseerán dicha variable.

Los identificadores tienen más usos que el acceso a variables locales ajenas,
como puede ser la función {#158,signal()} que puede enviar determinadas señales
a un proceso si se dispone de su código identificador (por ejemplo, para
eliminar el proceso).

También hay otras funciones, como {#104,collision()}, para detectar colisiones
(choques) con otros procesos que, en caso de detectar una colisión, devuelve
el código identificador del proceso con el cual se está chocando. Una vez
se tiene dicho código, se puede acceder a las variables del proceso y enviarle
señales.

La función {#120,get_id()} funciona de forma similar a {#104,collision()},
obteniendo el código identificador de un proceso, pero sin necesidad de que se
produzca una colisión con él.

{/}Ver: {#1038,Formas de obtener el código identificador de un proceso.}

# ─────────────────────────────────────────────────────────────────────────────

{.1040,Estados de un proceso.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Los procesos son los diferentes elementos de un programa (objetos del juego);
éstos pueden pasar por diferentes estados al crearse, destruirse o recibir
determinadas señales por medio de la función {#158,signal()}.

proceso {vivo o despierto.}

Si un proceso se está ejecutando (está interpretando las sentencias
comprendidas entre su {#1086,BEGIN} y su {#1091,END}) se dice que está
vivo.

proceso {muerto.}

Cuando un proceso finaliza (porque llega su {#1091,END} en la ejecución,
porque ejecute un {#1028,RETURN} o porque reciba una señal {#1153,s_kill} o
{#1157,s_kill_tree}) se dice que ha muerto.

proceso {dormido.}

Un proceso puede recibir la señal {#1155,s_sleep} (o {#1159,s_sleep_tree}) y,
entonces, pasará a estado dormido; en este estado el proceso se comporta como
si estuviera muerto, sólo que no lo está pues, en cualquier momento, puede
recibir una señal {#1154,s_wakeup} y volver a estado vivo o despierto.
También se puede matar a un proceso que está dormido.

proceso {congelado.}

La señal {#1156,s_freeze} (o {#1160,s_freeze_tree}) pasa a estado congelado
un proceso. En este estado el proceso se queda inmovilizado, se sigue viendo
y el resto de los procesos lo pueden seguir detectando (en las colisiones,
por ejemplo), pero no se ejecuta (deja de interpretar sus sentencias de
código). Estará en este estado hasta que reciba otra señal que le cambie
de estado o lo mate.

Un proceso congelado puede ser controlado (movido) por otro proceso,
manipulando directamente sus variables.

{/}

Siempre que se envía una señal a un proceso con el fin de cambiarle de estado,
ésta no tendrá efecto si el proceso se está ejecutando hasta que llegue a
su próxima visualización ({#1029,FRAME}). Si el proceso no se estuviera ejecutando,
entonces la señal tendría efecto de inmediato.

No se deben enviar señales a procesos inexistentes (a un {#1039,código identificador}
que no se corresponda a ningún proceso).

Si se intenta poner a un proceso en el estado en el que ya está, la señal
será ignorada.

{/}Ver: {#1041,Jerarquías de procesos.}

# ─────────────────────────────────────────────────────────────────────────────

{.1041,Jerarquías de procesos.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Un proceso es un objeto independiente del programa que ejecuta su propio
código y que puede tener sus propias coordenadas, gráficos, etc., por ejemplo,
pueden ser procesos de un programa: una nave, un disparo o un enemigo.

Cuando un programa comienza a ejecutarse sólo existe un proceso; el proceso
inicial que es el que comienza a ejecutar las sentencias del código
principal, pero, a partir de entonces, éste puede crear nuevos procesos
y éstos, a su vez, otros, destruirse procesos, etc.

Para aclarar los acontecimientos que van sucediendo en un programa se establece
un símil, que es hablar de los procesos como si fueran seres vivos que nacen
y mueren (cuando se crean y destruyen). Por ello, se establecen los siguientes
términos:

{Padre}, denominación que se da al proceso que ha creado a otro (la verdad
es que se debería haber llamado madre).

{Hijo}, el proceso que ha sido creado por otro.

{Hermanos}, procesos que han sido creados por el mismo padre.

{Huérfano}, proceso cuyo padre ha muerto (ha sido eliminado o a finalizado).

Y esta jerga se puede extender hasta donde llegue la imaginación, {abuelos},
{nietos}, {tíos}, etc.

Todos los procesos tienen acceso a los códigos identificadores de los
procesos con los que tienen parentesco directo (ver: {#1038,Formas de obtener
el {#1039,código identificador} de un proceso}.

En ocasiones, se hace referencia a acciones hechas por "{el sistema}"; este
proceso, denominado {div_main}, es el que controla al resto, por tanto es el
encargado de crear el proceso inicial al comienzo de la ejecución, de ajustar
la velocidad de ejecución, el trazador, etc. Todos los procesos que se
quedan huérfanos pasan a ser hijos de este proceso.

El {identificador de div_main} se puede obtener con {#120,get_id(0)}. Puede
servir para enviar una señal en árbol (tree) a todos los procesos,
pero dicho proceso no se visualizará en pantalla aunque se definan sus
variables {#1123,x}, {#1124,y}, {#1126,graph}, etc.

{/}Ver: {#1040,Estados de un proceso.}

# ─────────────────────────────────────────────────────────────────────────────

{.1042,Tipos de procesos.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Los bloques de los programas que comienzan con la palabra reservada {#1016,PROCESS}
determinan el comportamiento de un tipo concreto de proceso. Después, cuando
se ejecute el programa podrá haber cualquier número de procesos de dicho
tipo en un momento determinado, cada uno con un {#1039,código identificador}
diferente pero todos del mismo tipo.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    // ...
END
PROCESS nave()
BEGIN
    // ...
END
PROCESS enemigo()
BEGIN
    // ...
END
PROCESS disparo()
BEGIN
    // ...
END
{-}

En este ejemplo se definen cuatro tipos de procesos, {mi_juego} (que será
el tipo del proceso inicial del programa}, {nave}, {enemigo} y {disparo}.

El número de procesos de cada uno de estos tipos que haya después en el
juego depende del número de llamadas que se realicen a dichos procesos.

Todos los procesos de tipo {nave} ejecutarán siempre las sentencias que
se definen en el bloque {PROCESS nave()} del programa.

{Un "tipo de proceso" es un código numérico que hace referencia al
nombre que tiene el PROCESS que determina el comportamiento del }
proceso{ durante el juego; este código numérico se puede
obtener con: TYPE <nombre_del_proceso>.}

{TYPE} es un operador definido en el lenguaje que, aplicado a un nombre de proceso,
devuelve este código numérico.

Por ejemplo, {TYPE nave} equivaldrá a una constante numérica determinada y
{TYPE enemigo} a otra.

Todos los procesos tienen una variable local que contiene este código numérico
y es: {reserved.process_type}.

{¿Para qué sirve el tipo de un proceso?}{/}

El tipo de los procesos se emplea para varias cosas, por ejemplo:

- Para la función {#120,get_id()} que recibe como parámetro un tipo de proceso
(por ejemplo, {get_id(TYPE enemigo)}) y devuelve los códigos identificadores
de los procesos de dicho tipo que existan en el juego en ese momento.

- Para la función {#104,collision()} es similar a la anterior sólo que devuelve
los códigos identificadores de los procesos con los que se esté colisionado
(chocando, es decir, que los gráficos de ambos procesos estén parcialmente
superpuestos).

- Para la función {#158,signal()} que puede enviar una señal a todos los
procesos que existan de un tipo determinado.

- O bien para, a partir de un {#1039,código identificador} de un proceso, poder comprobar
de qué tipo de proceso se trata (si es de tipo nave, de tipo disparo, etc.).

{/}

El operador TYPE puede utilizarse únicamente precediendo a un nombre de
proceso del programa o a la palabra {mouse}, para la detección de colisiones
con el puntero del ratón (con {collision(TYPE mouse)}).

{/}Ver: {#1039,Códigos identificadores de procesos.}

# ─────────────────────────────────────────────────────────────────────────────

{.1043,Sentencia FROM}

{FROM} <variable>{#1073,=}{#1005,<constante>} {#1096,TO} {#1005,<constante>}{#1068,;}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

(o bien)

{FROM} <variable>{#1073,=}{#1005,<constante>} {#1096,TO} {#1005,<constante>} {#1095,STEP} {#1005,<constante>}{#1068,;}·
    {#1017,<sentencia>} {#1068,;}·
    ...·
{#1091,END}

La sentencia {FROM} es una sentencia que implementa un {bucle}, es decir, que
es capaz de {repetir un grupo de sentencias un número determinado de veces}.

Para implementar este bucle se necesita una variable {#1006,GLOBAL}, {#1007,LOCAL} o
{#1008,PRIVATE} del propio proceso que sirva como contador del bucle.

Antes de las sentencias que conformarán el grupo interior de sentencias se
debe poner la palabra reservada {FROM} seguida del {nombre de la variable contador},
el símbolo de asignación ({#1073,=}), el {valor inicial} de la variable, la
palabra reservada {#1096,TO} y, finalmente, el {valor final} de la variable.
Tras esta declaración del bucle {FROM} se debe poner el símbolo {#1068,;}
(punto y coma).

Después de esta cabecera definiendo las condiciones del bucle vendrá
el grupo interior de sentencias que se pretende repetir un número
determinado de veces y, al final, la palabra reservada {#1091,END}.

Se denomina {iteración} del bucle el número de veces que se ejecuta el grupo
interior de sentencias.

La primera iteración se hará con el {valor incial}
en la variable usada como contador, tras esta iteración se le {sumará 1}
a esta variable (si el valor inicial {es menor} que el valor final)
o se le {restará 1} (en caso contrario). Tras actualizar el valor
de la variable, se pasará a la siguiente iteración siempre que el
valor de dicha variable no haya llegado (o sobrepasado) el {valor
final} del bucle.

Como segunda acepción de la sentencia {FROM} se puede poner tras los valores
inicial y final de la sentencia la palabra reservada {#1095,STEP} seguida de un
{valor constante} que indique el incremento de la variable contador tras
cada iteración del bucle, en lugar de {1} o{ -1}, que son los incrementos
que se harán por defecto si se omite la declaración {#1095,STEP} (paso).

A continuación, se muestra un programa con dos bucles {FROM}, uno sin declaración
{#1095,STEP} (con incremento o decremento por defecto) y otro con ella.

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FROM x=9 TO 0;
        // sentencias interiores ...
    END
    FROM x=0 TO 9 STEP 2;
        // Sentencias interiores ...
    END
END
{-}

El primer bucle se ejecutará {10} veces con la variable {x} valiendo
desde {9} hasta {0} en las diferentes iteraciones; por defecto, se le resta
uno a la variable cada vez, ya que el valor inicial (9) es mayor que
el valor final (0).

En el segundo, se indica como incremento de la variable la constante {2},
por lo que el bucle se ejecutará {5} veces con la variable {x} valiendo
{0}, {2}, {4}, {6} y {8}, respectivamente, en las sucesivas iteraciones.
Como se puede observar no se hará ninguna iteración con {x} valiendo {9},
aunque éste sea el {valor final} del bucle.

Por defecto, si no se hubiera especificado como {#1095,STEP} (paso) del bucle {2},
se le habría sumado {1} a la variable {x} tras cada iteración.

Un bucle {FROM} siempre se puede realizar también con la sentencia {#1025,FOR},
como se muestra a continuación (con dos bucles equivalentes a los del
ejemplo anterior).

{#9999,Ejemplo:}
PROGRAM mi_juego;
BEGIN
    FOR ( x=9 ; x>=0 ; x=x-1 )
        // Sentencias interiores ...
    END
    FOR ( x=0 ; x<=9 ; x=x+2 )
        // Sentencias interiores ...
    END
END
{-}

Los valores {inicial} y {final} de un bucle {FROM} deben ser diferentes.

Si el valor inicial {es menor} que el valor final, no se puede
especificar un valor negativo en la declaración {#1095,STEP}.

Si el valor inicial {es mayor} que el valor final, no se puede
especificar un valor positivo en la declaración {#1095,STEP}.

Una sentencia {#1026,BREAK} dentro de un bucle {FROM} lo finalizará de forma
inmediata, continuando el programa por la sentencia siguiente a dicho bucle
(tras el {#1091,END}).

Una sentencia {#1027,CONTINUE} dentro de un bucle {FROM} forzará al programa a
incrementar inmediatamente la variable usada como contador y, después,
si no se ha sobrepasado el valor final, comenzar con la siguiente iteración.

Las sentencias interiores a un bucle {FROM} pueden ser tantas como se
quiera y de cualquier tipo, incluyendo, por supuesto, nuevos bucles {FROM}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1044,Uso de ángulos en el lenguaje.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Todos los ángulos se especifican en el lenguaje en milésimas de grado.
Por ejemplo:

  {0} es {0 grados} (hacia la derecha)·
  {90000} son {90 grados} (hacia arriba)·
 { -45000} son{ -45 grados} (diagonal abajo derecha)·

Si a cualquier ángulo se le suman o restan {360 grados} (360000) se
obtiene un ángulo equivalente. Por ejemplo, los ángulos -90000 y
270000 son equivalentes (los ángulos de {-90 grados} y {270 grados}
son ambos hacia abajo)

Se puede utilizar como referencia la constante {#1179,PI} predefinida como {180000},
{3.1415 radianes} o, lo que es lo mismo, {180 grados}. Por ejemplo {PI/2}
equivaldrá a 90 grados (90000).

Algunas de las funciones para el manejo de ángulos son las siguientes:

  {#116,get_angle()}·
  {#118,get_distx()}·
  {#119,get_disty()}·
  {#113,fget_angle()}·
  {#142,near_angle()}·
  {#101,advance()}·

Todos los procesos tienen una variable local predefinida denominada {angle}
que, por defecto, valdrá {0}; si se modifica su valor se cambiará el ángulo
de visualización del gráfico del proceso (se rotará el gráfico en los grados
indicados, a partir del gráfico original).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1045,NOT  !}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador unario de {negación} lógica y binaria utilizado en expresiones y
condiciones.

La palabra reservada {NOT} y el símbolo {!} son sinónimos.

{NOT lógico:} Si el operando es {cierto}, al aplicarle este operador, se obtendrá
una expresión {falsa} y viceversa.

  CIERTO  ->  FALSO
  FALSO   ->  CIERTO

{NOT binario:} Cambia todos los bit del operando, es decir, pasa los 0 a 1 y
los 1 a 0.

{/}

{Nota:} Este operador funciona indistintamente como lógico y binario debido
a que en el lenguaje se interpretan las expresiones lógicas {ciertas} como las
que tienen el último bit a 1 (el bit 0, de peso 1), es decir, los números
impares (1, -1, 3, -3, ...), y como expresiones lógicas {falsas} las que
tienen el último bit a 0 (los números pares: 0, 2, -2, 4, -4, ...).

Al cambiar el operador {NOT} todos los bit también cambian
el último convirtiendo, de este modo, los números pares en impares (expresiones
falsas en ciertas) e impares en pares (expresiones ciertas en falsas).

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1046,<>  !=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{distinto que}] utilizado en condiciones. Los símbolos
{<>} y {!=} son sinónimos.

Debe utilizarse entre dos expresiones numéricas y devuelve un
resultado lógico:

{Falso} - Si ambas expresiones dan el mismo resultado (si son dos
expresiones equivalentes), pues NO son distintas.

{Cierto} - Si las expresiones dan resultados distintos, pues SI son distintas.

{Ejemplos:}

  {2+2 <> 4} devolverá {falso}.
  {0 <> -1}  devolverá {cierto}.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1047,"  '}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Símbolos delimitadores de literales.

Los literales son los {textos entre comillas} que pueden comenzar y terminar
con el carácter [{'}] o bien con el carácter [{"}] (deben comenzar y terminar
con el mismo carácter). Si se quiere incluir el carácter [{"}] en un literal, se puede
hacer de dos formas; supóngase que se quiere definir un literal que contenga
el texto: a"B"c

 - Duplicar el carácter: "a""B""c"

 - Definirlo con la comilla simple: 'a"B"c'

Lo mismo sucede con el carácter [{'}], que se puede incluir en un literal
si se duplica, o bien si el literal se delimita con el carácter [{"}].

Todos los literales deben cerrarse en la misma línea en la que comenzaron, no
pudiéndose definir literales de más de una línea.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1048,MOD  %}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador aritmético de {módulo} o {resto de una división} entera. La palabra
reservada {MOD} y el símbolo{ %} son sinónimos.

Este operador se utiliza en las {#1035,expresiones aritméticas} entre dos
operandos, para obtener el módulo del primero partido por el segundo.

Por ejemplo {7 MOD 3} devolverá 1, ya que al realizar la división entera de 7
entre 3 se obtiene 2 como cociente y {1} como {resto}.

Es decir, que {n MOD m} siempre devolverá un número dentro del rango (0..m-1).

Para comprender de forma sencilla cómo obtener el resto de una operación
{n MOD m} se pueden seguir los siguientes pasos:

{Paso 1} - Si {n} es menor que {m}, el resultado de la operación {MOD} es {n}.

{Paso 2} - (Cuando {n} es mayor o igual que {m}) se le resta {m} a {n} y se
vuelve al {paso 1}.

{/}

{Uso:} Este operador se utiliza en ocasiones en los programas en los que
se requiere que una variable contador varíe entre {0} y {otro número}
siempre; si se quiere, por ejemplo, que la variable {x} varíe
entre 0 y 319 indefinidamente (x=0, x=1, x=2, ..., x=319, x=0, x=1, ...)
se podría optar por lo siguiente:

  {x=0;}·
  {LOOP}·
  {    x=x+1;}·
  {    IF (x==320) x=0;}·
  {    // ...}·
  {END}·

Pero muchos programas sustituyen estas sentencias por las siguientes:

  {x=0;}·
  {LOOP}·
  {    x=(x+1) MOD 320;}·
  {    // ...}·
  {END}·

que realizan exactamente la misma función, ya que el operador {MOD} truncará
la expresión cuando sea mayor o igual que 320 a un valor menor.

{/}

El {cociente} de una división entera se obtiene con el operador {#1065,/}
(división).

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1049,%=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación de {módulo} o {resto de división} entera.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo {%=} en lugar de {=} para realizar la asignación,
se asignará al dato el {módulo} o {resto de la división} siguiente:

  [{valor_anterior_del_dato}] / [{resultado_de_la_expresión}]

Ejemplo: {x=3; x%=2;} -> (x=1)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n %= m;} será equivalente a
ésta otra {n = n MOD m;}.

Ver el operador {#1048,MOD} para más información sobre el {módulo}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1050,&}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Símbolo bifuncional que tiene dos usos diferentes según se utilice como
un operador unario o binario.

Un operador {UNARIO} aparece dentro de una expresión precediendo,
simplemente, a un operando (como si fuera el signo de éste); en este caso
el operador{ &} será un sinónimo de {#1085,OFFSET}.

{Ejemplo: &x} es equivalente a {OFFSET x}

Un operador {BINARIO} aparece dentro de una expresión concatenando
a dos operandos (indicando una operación entre ambos), en este caso el
operador{ &} será un sinónimo de {#1051,AND}.

{Ejemplo: x&2} es equivalente a {x AND 2}

{/}Ver: {#1000,Sintaxis} - {#1085,OFFSET} - {#1051,AND}

# ─────────────────────────────────────────────────────────────────────────────

{.1051,AND  &&}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador binario del {producto lógico} utilizado en expresiones y
condiciones.

La palabra reservada {AND} y el símbolo{ &&} son sinónimos.

{AND lógico:} Se evalúan, primero, las condiciones de la derecha e izquierda
del operador y, si ambas son {ciertas}, este operador devolverá {cierto},
en caso contrario el operador devolverá siempre {falso}.

  FALSO  AND FALSO  = FALSO
  FALSO  AND CIERTO = FALSO
  CIERTO AND FALSO  = FALSO
  CIERTO AND CIERTO = CIERTO

Se utiliza para comprobar que se cumplan obligatoriamente más de una condición,
por ejemplo:

  {(x>0 AND x<100)}

Para comprobar que la variable sea mayor que 0 {Y} que sea menor que 100.

{AND binario:} Evalúa los bit de los resultados de las expresiones anterior
y posterior al operador generando, como resultado, un valor que tendrá a uno
únicamente los bit que tuvieran a uno ambas expresiones.

  0 AND 0 = 0
  0 AND 1 = 0
  1 AND 0 = 0
  1 AND 1 = 1

Esta regla se aplicará a todos los bits de los operandos (en el lenguaje
son enteros de 32 bits).

{/}

{Nota:} Este operador funciona indistintamente como lógico y binario debido
a que en el lenguaje se interpretan las expresiones lógicas {ciertas} como las
que tienen el último bit a 1 (el bit 0, de peso 1), es decir, los números
impares (1, -1, 3, -3, ... ), y como expresiones lógicas {falsas} las que
tienen el último bit a 0 (los números pares: 0, 2, -2, 4, -4, ...).

El operador {AND} únicamente dejará a 1 el último bit (sólo devolverá {cierto}
como resultado} cuando lo tuvieran a 1 ambos operandos (cuando los dos fueran
expresiones {ciertas}).

{/}

{Nota:} El símbolo{ &} también puede utlizarse como un sinónimo más de
{AND} y{ &&}.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1052,&=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación binaria de {producto lógico} ({AND}).

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo {&=} en lugar de {=} para realizar la asignación,
se asignará al dato el {producto lógico} siguiente:

  [{valor_anterior_del_dato}] AND [{resultado_de_la_expresión}]

Ejemplo: {x=5; x&=6;} -> (x=4)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C};
en cualquier caso, una sentencia del tipo {n &= m;} será equivalente a
esta otra {n = n AND m;}.

Ver el operador {#1051,AND} para más información sobre el {producto lógico}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1053,(  )}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Los símbolos {(} y {)}, denominados paréntesis, deben aparecer siempre
emparejados y en este mismo orden.

Se utilizan para delimitar determinados cálculos, parámetros o condiciones
de los programas, marcando el inicio de los mismos con el símbolo {(} y
el final con el símbolo {)}.

{/}

Dentro de una expresión indican que el cálculo de su interior se
debe realizar antes que el de su exterior.

Por ejemplo, la expresión {2*3+2} se evaluará como {8}, ya que primero
se realizará la multiplicación (2 por 3, que es 6) y después la suma
(6 más 2, que da como resultado 8).

Utilizando paréntesis se puede forzar a que se realice la suma en primer lugar,
expresando el cálculo como {2*(3+2)}, que será evaluado como {10}, ya que
ahora se realizará primero la suma (3 más 2, que es 5) y después la
multiplicación (2 por 5, que es 10).

{/}

Los paréntesis también se utilizan para delimitar los parámetros de llamada
de los {#1033,procesos} o las funciones y dentro de la
sintáxis de diferentes sentencias del lenguaje.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1054,*}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador aritmético de {multiplicación} entera. Este operador se utiliza en las
{#1035,expresiones aritméticas} entre dos operandos, para obtener como resultado
su producto (la multiplicación).

Por ejemplo {2 * 8} devolverá {16}, {99 * 0} devolverá {0}, {2 * -1}
devolverá{ -2}, etc.

Todas las variables son {enteros} con signo de 32 bit en el lenguaje.
Por lo tanto, únicamente se pueden manejar números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int})} por lo que, cuando el resultado de
la {multiplicación} deba exceder dicho rango, {se mostrarán resultados
incorrectos}. En este caso, el sistema no advertirá de ningún error, de ahí
que se deban extremar las precauciones.

{/}

Este símbolo es bifuncional, es decir, tiene dos usos diferentes según
se utilice como un operador unario o binario.

Un operador {UNARIO} aparece dentro de una expresión precediendo
simplemente a un operando (como si fuera el signo de éste); en este caso
el operador {*} será un sinónimo de {#1079,POINTER}.

{Ejemplo: *x} es equivalente a {POINTER x}

Un operador {BINARIO} aparece dentro de una expresión concatenando
a dos operandos (indicando una operación entre ambos), en cuyo caso el
operador {*} será el operador aritmético de {multiplicación} explicado
anteriormente.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1079,POINTER}

# ─────────────────────────────────────────────────────────────────────────────

{.1055,*=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación aritmética de {multiplicación}.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo {*=} en lugar de {=} para realizar la asignación,
se asignará al dato la {multiplicación} siguiente:

  [{valor_anterior_del_dato}] * [{resultado_de_la_expresión}]

Ejemplo: {x=2; x*=3;} -> (x=6)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n *= m;} será equivalente a
esta otra {n = n * m;}.

Ver el operador {#1054,*} para más información sobre la {multiplicación}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1056,+}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador aritmético de {suma}. Este operador se utiliza en las
{#1035,expresiones aritméticas} entre dos operandos, para obtener su suma.

Por ejemplo {2 + 6} devolverá 8, la suma de 2 más 6.

Todas las variables son {enteros} con signo de 32 bits en el lenguaje.
Luego, únicamente se pueden manejar números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int})}, por lo que cuando el resultado de
la {suma} deba exceder dicho rango, {se mostrarán resultados
incorrectos}. En este caso, el sistema no advertirá de ningún error, de ahí
que deban extremarse las precauciones.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1057,++}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador de incremento, este operador, derivado del lenguaje C, permite
incrementar el valor de un dato (sumarle 1) sin requerir, para ello, una
{#1019,sentencia de asignación}.

El dato puede ser una variable, una {posición de una tabla}, o bien un
{campo de una estructura}.

Este operador se puede incluir dentro de una expresión en dos modalidades:
{preincremento} y {postincremento}.

{Operador de preincremento.}

Cuando se ponga el símbolo { ++} justo delante de un dato, se le sumará 1
al mismo {antes de ejecutar la sentencia}, por ejemplo, véanse las siguientes
sentencias:

{ ++x;} - sentencia que sumará 1 a la variable {x}.

{ z=++x+y;} - sentencia que sumará 1 a la variable {x} y, después, asignará
a la variable {z} la suma de {x} (ya incrementada) e {y}.

{Operador de postincremento.}

Cuando se ponga el símbolo{ ++} justo detrás de un dato, se le sumará 1 al
mismo {tras ejecutar la sentencia}, por ejemplo, véanse las siguientes
sentencias:

{ x++;} - sentencia que sumará 1 a la variable {x}.

{ z=x+y++;} - sentencia que asignará la suma de {x} más {y} a la variable {z},
y, después, incrementará la variable {y}.

{/}

{Resumen:}

En general, una sentencia del tipo{ ++dato;} o {dato++;} es siempre equivalente
a la siguiente sentencia: {dato=dato+1;} (o bien {dato+=1;}).

La diferencia entre el {preincremento} y el {postincremento} es que en el primero se
toma el valor del dato ya incrementado para evaluar el resto de la expresión,
mientras que en el segundo se evalúa la expresión con el valor que tenía el dato antes de
ser incrementado.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1061,Decremento(--)}

# ─────────────────────────────────────────────────────────────────────────────

{.1058,+=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación aritmética de {suma}.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ +=} en lugar de {=} para realizar la asignación,
se asignará al dato la {suma} siguiente:

  [{valor_anterior_del_dato}] + [{resultado_de_la_expresión}]

Ejemplo: {x=2; x+=2;} -> (x=4)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n += m;} será equivalente a
esta otra {n = n + m;}.

Ver el operador {#1056,+} para más información sobre la {suma}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1059,,}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

El símbolo de la coma ( {,} ) se utiliza dentro del lenguaje de programación,
en diferentes puntos de un programa, {para separar} dos elementos consecutivos
de una lista.

Se utiliza, por ejemplo, en los siguientes puntos:

- En las {#1013,listas de constantes} para separar los diferentes valores
numéricos de las mismas.

- En la definición de los {#1018,parámetros de un proceso} para separar
los nombres de los diferentes parámetros.

- En la {#1032,llamada a una función} y en la {#1033,llamada a un proceso}
igualmente parar separar las diferentes expresiones que serán asignadas a
los párametros de la función o proceso.

- En la {#1025,sentencia FOR} para separar diferentes inicializaciones,
condiciones o incrementos.

- En la {#1021,sentencia SWITCH} para definir los diferentes valores
aceptados en un bloque {CASE ... END}.

{/}

El símbolo de la coma se puede utilizar también para separar varias
{#1009,declaraciones de datos}, en lugar de finalizar cada una de ellas
con un símbolo {punto y coma} ({#1068,;}).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1060,-}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador aritmético de {resta}. Este operador se utiliza en las
{#1035,expresiones aritméticas} entre dos operandos para obtener su suma.

Por ejemplo {2 - 6} devolverá -4, el resultado de restarle 6 a 2.

Todas las variables son {enteros} con signo de 32 bits en el lenguaje.
Por ello, únicamente se pueden manejar números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int})}, por lo que cuando el resultado de
la {resta} deba exceder dicho rango, {se mostrarán resultados
incorrectos}. En este caso, el sistema no advertirá de ningún error, con
lo que se deben extremar las precauciones.

{/}

Este símbolo es bifuncional, es decir, tiene dos usos diferentes según
se utilice como un operador unario o binario.

Un operador {UNARIO} aparece dentro de una expresión precediendo
simplemente a un operando, este caso el operador{ -} será el {signo menos}.

{Ejemplo: -7} el número entero negativo {menos siete}.

Un operador {BINARIO} aparece dentro de una expresión concatenando
a dos operandos (indicando una operación entre ambos); en este caso el
operador{ -} será el operador aritmético de {resta} explicado anteriormente.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1061,--}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador de decremento, este operador, derivado del lenguaje C, permite
decrementar el valor de un dato (restarle 1), sin requerir para ello una
{#1019,sentencia de asignación}.

El dato puede ser una variable, una {posición de una tabla}, o bien un
{campo de una estructura}.

Este operador se puede incluir dentro de una expresión en dos modalidades:
{predecremento} y {postdecremento}.

{Operador de predecremento.}

Cuando se ponga el símbolo{ --} justo delante de un dato, se le restará 1
al mismo {antes de ejecutar la sentencia}, por ejemplo, véanse las siguientes
sentencias:

{ --x;} - sentencia que restará 1 a la variable {x}.

{ z=--x+y;} - sentencia que restará 1 a la variable {x} y después asignará
a la variable {z} la suma de {x} (ya decrementada) e {y}.

{Operador de postdecremento.}

Cuando se ponga el símbolo{ --} justo detrás de un dato, se le restará 1 al
mismo {tras ejecutar la sentencia}, por ejemplo, véanse las siguientes
sentencias:

{ x--;} - sentencia que restará 1 a la variable {x}.

{ z=x+y--;} - sentencia que asignará la suma de {x} más {y} a la variable {z},
y después decrementará la variable {y}.

{/}

{Resumen:}

En general, una sentencia del tipo{ --dato;} o {dato--;} siempre equivalente
a la siguiente sentencia: {dato=dato-1;} (o bien {dato-=1;}).

La diferencia entre el {predecremento} y el {postdecremento} es que en el primero se
toma el valor del dato ya decrementado para evaluar el resto de la expresión,
y en el segundo se evalúa la expresión con el valor que tenía el dato antes de
ser decrementado.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1057,Incremento(++)}

# ─────────────────────────────────────────────────────────────────────────────

{.1062,-=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación aritmética de {resta}.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ -=} en lugar de {=} para realizar la asignación,
se asignará al dato la {resta} siguiente:

  [{valor_anterior_del_dato}] - [{resultado_de_la_expresión}]

Ejemplo: {x=4; x-=2;} -> (x=2)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C};
en cualquier caso una sentencia del tipo {n -= m;} será equivalente a
esta otra {n = n - m;}.

Ver el operador{#1060, -} para más información sobre la {resta}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1063,.  ->}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador de acceso a estructuras o datos locales ajenos. Los símbolos{ .} y{ ->}
son sinónimos, por lo que pueden ser usados indistintamente.

{/}

{Acceso a estructuras.}

Para acceder a un campo de una estructura se debe utilizar este operador
de la siguiente forma:

<nombre de la estructura>{[}<nº registro>{]}{ . }<nombre del campo>

(o bien, utilizando el otro símbolo)

<nombre de la estructura>{[}<nº registro>{]}{ -> }<nombre del campo>

{Ejemplos:}·
  {scroll[0].camera}·
  {m7[1]->z}·

{Nota:} Se recuerda que el número de registro entre corchetes se puede omitir
cuando se acceda al registro número 0, por ejemplo {scroll[0].camera} equivaldrá
siempre a {scroll.camera}.

{/}

{Acceso a datos locales ajenos (de otro proceso).}

Para acceder a un dato {#1007,LOCAL} de un proceso desde otro, se debe
tener el {#1039,código identificador} del proceso del cual se quiere leer
o modificar su dato, entonces se podrá acceder al mismo de la siguiente forma:

<código identificador>{ . }<nombre dato local>

(o bien, utilizando el otro símbolo)

<código identificador>{ -> }<nombre dato local>

{Ejemplos:}·
   {father.x}·
   {son->graph}·

{/}Ver: {#1012,Declaración de una estructura} - {#1039,Códigos identificadores} - {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1064,..}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{Rango de valores de una sección CASE}{/}

El símbolo{ ..} (doble punto) se utiliza para definir un rango de valores,
es decir, para expresar el conjunto de números comprendidos entre dos valores
(incluyendo éstos).

Este símbolo se utiliza {únicamente en las sentencias} {#1021,SWITCH}, dentro
de las {secciones CASE}, para especificar un rango de valores.

Resulta indiferente expresar un rango como {mínimo..máximo} o como {máximo..mínimo}.

Por ejemplo, el rango definido con{ -2 .. 1} serían los números{ -2},{ -1}, {0} y {1}.

{/}Ver: {#1000,Sintaxis} - {#1021,sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.1065,/}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador aritmético de {división} entera. Este operador se utiliza en las
{#1035,expresiones aritméticas} entre dos operandos, para obtener el cociente
del primero partido por el segundo.

Por ejemplo {7 / 3} devolverá 2, ya que al realizar la división entera de 7
entre 3 se obtiene {2} como {cociente} (y 1 como resto).

Es decir, que {n / m} siempre devolverá el resultado de la división
de {n} entre {m}, pero sin decimales (ya que todas las variables son
{enteros} con signo de 32 bits en el lenguaje).

{/}

El {resto} de una división entera se obtiene con el operador {#1048,MOD}
(módulo).

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1066,/=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación de {división entera} (cociente).

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ /=} en lugar de {=} para realizar la asignación,
se asignará al dato el {resultado entero} (cociente) de la {división} siguiente:

  [{valor_anterior_del_dato}] / [{resultado_de_la_expresión}]

Ejemplo: {x=8; x/=2;} -> (x=4)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n /= m;} será equivalente a
esta otra {n = n / m;}.

Ver el operador {#1065,/} para más información sobre la {división entera}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1067,:}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

El símbolo {:} (dos puntos) se utiliza para finalizar una declaración
{#1087,CASE} o una declaración {#1088,DEFAULT} de una {#1021,sentencia SWITCH}.

En realidad, los símbolos {:} (dos puntos) y {;} (punto y coma) son sinónimos
en este lenguaje, es decir, que es indiferente utilizar uno u otro.

Aún así, por similitud a otros lenguajes de programación se utiliza, normalmente,
el símbolo {punto y coma} como terminador de sentencias y el símbolo {dos puntos}
dentro de la sintaxis de la {#1021,sentencia SWITCH}.

{/}Ver: {#1000,Sintaxis} - {#1087,CASE} -  {#1088,DEFAULT} - {#1021,sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.1068,;}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

El símbolo {;} (punto y coma) se utiliza en múltiples puntos de un programa
para indicar, siempre, que finaliza una sentencia o algún tipo de declaración.
Es lo que se denomina un símbolo {terminador} que tiene, como único fin marcar el
final de algo.

En el lenguaje se deben indicar con punto y coma los siguientes
puntos del programa:

- El final de la {#1003,declaración PROGRAM}.

- El final de una {#1009,declaración de un dato}.

- El final de una {#1014,declaración IMPORT}.

- El final de las siguientes sentencias:·
    {#1019,Asignaciones o incrementos de datos}.·
    {#1033,Llamadas a procesos}.·
    {#1032,Llamadas a funciones}.·
    {#1029,FRAME}, {#1028,RETURN}, {#1031,DEBUG}, {#1026,BREAK} y {#1027,CONTINUE}.

- El final de un inicio de bucle {#1043,FROM}.

- Y como separador de las diferentes partes de una sentencia {#1025,FOR}.

El compilador indicará cuando falte el símbolo {;} en cualquiera de estos
puntos.

Pudiendo, además, ponerse dicho símbolo en otros puntos determinados de los
programas, como detrás de cualquier otro tipo de sentencia, aunque en este
caso será opcional y, por tanto, el compilador no advertirá de su ausencia.

{/}

En realidad los símbolos {;} (punto y coma) y {:} (dos puntos) son sinónimos
en este lenguaje, es decir, que es indiferente utilizar uno u otro.

Aún así, por similitud a otros lenguajes de programación se utiliza, normalmente,
el símbolo {punto y coma} como terminador de sentencias y el símbolo {dos puntos}
dentro de la sintaxis de la {#1021,sentencia SWITCH}.

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1069,<}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{menor que}] utilizado en condiciones. Debe utilizarse entre
dos expresiones numéricas y devuelve un resultado lógico:

{Falso} - Si la primera expresión NO es menor que la segunda.

{Cierto} - Si la primera expresión SI es menor que la segunda.

{Ejemplos:}

  {2+2 < 4} devolverá {falso}.
  {1 < 2}   devolverá {cierto}.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1070,<<}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador binario de {rotación a la izquierda}. Este operador se utiliza en las
{#1035,expresiones aritméticas}, entre dos operandos, para obtener el resultado
de rotar el primer operando a la izquierda el número de veces que indique
el segundo. Por ejemplo, la siguiente rotación:

  {n} << {m}

Devolverá {n} rotado a la izquierda {m} veces; cada rotación a la izquierda
equivale a multiplicar por 2 el número. Es decir, rotar a la izquierda 1
vez, equivale a multiplicar por 2, rotar a la izquierda 2 veces a multiplicar
por 4, 3 veces a multiplicar por 8, y, así, sucesivamente.

O lo que es equivalente (la {#145,función POW}{(2, m)} devuelve {2} elevado a {m}):

  {n} * POW(2, {m})

Por ejemplo, {2<<3} devolverá 16, {4<<1} devolverá 8, {100<<0} devolverá 100, etc.

Todas las variables son {enteros} con signo de 32 bits en el lenguaje.
Por eso sólo se pueden manejar números enteros dentro del rango
({#1177,min_int} ... {#1178,max_int})}, por lo que cuando el resultado de
la {rotación} deba exceder dicho rango, {se mostrarán resultados
incorrectos}. En este caso, el sistema no advertirá de ningún error, por
lo que se deben extremar las precauciones.

{/}

El operador de rotación a la derecha (operación opuesta a ésta) es el
{#1077,símbolo >>}.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1071,<<=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación binaria de {rotación a la izquierda}.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ <<=} en lugar de {=} para realizar la asignación,
se asignará al dato el resultado de la siguiente rotación:

  [{valor_anterior_del_dato}] << [{resultado_de_la_expresión}]

O lo que es equivalente (la {#145,función POW}{(2, n)} devuelve {2} elevado a {n}):

  [{valor_anterior_del_dato}] * POW(2, [{resultado_de_la_expresión}])

Es decir, si el resultado de la expresión es:

  0 -> el dato mantendrá su valor.·
  1 -> el dato será multiplicado por 2.·
  2 -> el dato será multiplicado por 4.·
  3 -> el dato será multiplicado por 8.·
  ...

Ejemplo: {x=2; x<<=2;} -> (x=8)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n <<= m;} será equivalente a
esta otra {n = n << m;}.

Ver el operador {#1070,<<} para más información sobre la {rotación a la izquierda}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1072,<=  =<}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{menor o igual que}] utilizado en condiciones. Los símbolos
{<=} y {=<} son sinónimos.

Debe utilizarse entre dos expresiones numéricas y devuelve un
resultado lógico:

{Falso} - Si la primera expresión NO es menor o igual que la segunda.

{Cierto} - Si la primera expresión SI es menor o igual que la segunda.

{Ejemplos:}

  {2+2 <= 3} devolverá {falso}.
  {2+2 <= 4} devolverá {cierto}.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1073,=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

El símbolo {=} (símbolo de {asignación}) se utiliza en el lenguaje dentro
de las {#1009,declaraciones de datos} para inicializarlos, es decir, para
definir el valor inicial de los mismos y en las {#1019,sentencias de
asignación} para separar la referencia al dato, de la expresión asignada.

Dentro de una expresión este operador se puede utilizar como un
operador aritmético binario convencional, que se sitúa entre dos operandos,
y devuelve como resultado el valor del segundo operando (además de realizar
la asignación de este resultado al dato reflejado como primer operando).

Este operador representa una {orden imperativa}; se ordena que, al ejecutarse
la sentencia que lo contiene, el primer operando (anterior al símbolo) tome
el valor que tiene el segundo operando (o expresión posterior al símbolo).

En la evaluación de una expresión los operandos de asignación son siempre
los de {menor prioridad} (los últimos que se interpretan en la expresión),
pudiendo utilizar paréntesis para forzar una prioridad mayor. Si en una
expresión (o sentencia) se han utilizado varios operadores de asignación,
éstos serán evaluados (ejecutados) de derecha a izquierda.

Por ejemplo, en la sentencia:

  {x=y=x+y;}

Primero se relizará la suma ({x+y}), después se asignará el resultado como
nuevo valor de la variable {y} ({y=x+y}) y, por último, se asignará este
mismo valor a la variable {x} ({x=y}).

{/}

{Importante:}

Este símbolo no puede utilizarse para realizar comparaciones (que se realizan
con el {#1074,símbolo ==}), por ejemplo en la siguiente sentencia:

  {IF (x=2) ... END}

No se comparará la variable {x} con el valor {2}, sino que se asignará el
valor {2} a la variable {x} y, después, como el resultado de esta operación
(de asignación) es {2}, un número par, se interpretará la condición como
{falsa} (se interpretan como ciertas las expresiones impares y falsas las pares),
por lo que las sentencias interiores a la sentencia {IF} no serán ejecutadas
nunca.

Asimismo, el símbolo {#1074,==} no puede utilizarse para realizar asignaciones,
ya que es el operador lógico de comparación.

{/}Ver: {#1000,Sintaxis} - {#1009,Declaraciones de datos} - {#1019,Sentencias de asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1074,==}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{igual que}] utilizado en condiciones. Debe utilizarse entre
dos expresiones numéricas y devuelve un resultado lógico:

{Falso} - Si las expresiones dan resultados distintos, pues NO son iguales
(ni equivalentes).

{Cierto} - Si ambas expresiones dan el mismo resultado (si son dos
expresiones equivalentes), pues SI son iguales.

{Ejemplos:}

  {0 == -1}  devolverá {falso}.
  {2+2 == 4} devolverá {cierto}.

{/}

{Nota:} El símbolo {#1073,=} no puede utilizarse para comparar dos expresiones
o valores numéricos, ya que es el símbolo de asignación.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1075,>=  =>}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{mayor o igual que}] utilizado en condiciones. Los símbolos
{>=} y {=>} son sinónimos.

Debe utilizarse entre dos expresiones numéricas y devuelve un
resultado lógico:

{Falso} - Si la primera expresión NO es mayor o igual que la segunda.

{Cierto} - Si la primera expresión SI es mayor o igual que la segunda.

{Ejemplos:}

  {2+2 >= 5} devolverá {falso}.
  {2+2 >= 4} devolverá {cierto}.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1076,>}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico [{mayor que}] utilizado en condiciones. Debe utilizarse entre
dos expresiones numéricas y devuelve un resultado lógico:

{Falso} - Si la primera expresión NO es mayor que la segunda.

{Cierto} - Si la primera expresión SI es mayor que la segunda.

{Ejemplos:}

  {2+2 > 4} devolverá {falso}.
  {2 > 1}   devolverá {cierto}.

{/}Ver: {#1000,Sintaxis} - {#1037,Condición}

# ─────────────────────────────────────────────────────────────────────────────

{.1077,>>}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador binario de {rotación a la derecha}. Este operador se utiliza en las
{#1035,expresiones aritméticas} entre dos operandos para obtener el resultado
de rotar el primer operando a la derecha el número de veces que indique
el segundo. Por ejemplo, la siguiente rotación:

  {n} >> {m}

devolverá {n} rotado a la derecha {m} veces; cada rotación a la derecha
equivale a dividir por 2 el número. Es decir, rotar a la izquierda 1
vez, equivale a dividir por 2, rotar a la izquierda 2 veces a dividir
por 4, 3 veces a dividir por 8, etc.

Se recuerda que todos los números manipulados en este lenguaje son {enteros}
(sin decimales) por lo que siempre se devolverá el resultado {entero} de la
división (7 dividido entre 2 devolverá 3, por ejemplo).

O lo que es equivalente (la {#145,función POW}{(2, m)} devuelve {2} elevado a {m}):

  {n} / POW(2, {m})

Por ejemplo, {16>>3} devolverá 2, {2>>1} devolverá 1, {100>>0} devolverá 100, etc.

{/}

El operador de rotación a la izquierda (operación opuesta a ésta) es el
{#1070,símbolo <<}.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión}

# ─────────────────────────────────────────────────────────────────────────────

{.1078,>>=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación binaria de {rotación a la derecha}.

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ >>=} en lugar de {=} para realizar la asignación,
se asignará al dato el resultado de la siguiente rotación:

  [{valor_anterior_del_dato}] >> [{resultado_de_la_expresión}]

O lo que es equivalente (la {#145,función POW}{(2, n)} devuelve {2} elevado a {n}):

  [{valor_anterior_del_dato}] / POW(2, [{resultado_de_la_expresión}])

Es decir, si el resultado de la expresión es:

  0 -> el dato mantendrá su valor.·
  1 -> el dato será dividido por 2.·
  2 -> el dato será dividido por 4.·
  3 -> el dato será dividido por 8.·
  ...

Ejemplo: {x=8; x>>=2;} -> (x=2)

El resultado de una rotación a la derecha será siempre un número entero,
sin decimales, es decir, el cociente de la división entera anterior.

Ejemplo: {x=9; x>>=2;} -> (x=2)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C};
en cualquier caso, una sentencia del tipo {n >>= m;} será equivalente a
esta otra {n = n >> m;}.

Ver el operador {#1077,>>} para más información sobre la {rotación a la derecha}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1079,POINTER  [  ]}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador de indirección. Este operador requiere un nivel ligeramente
avanzado en técnicas de programación. El uso de punteros es una
característica de otros lenguajes que, aunque puede ser muy útil,
no resulta imprescindible para la realización de programas, por
complejos que éstos sean.

La palabra reservada {POINTER} sirve para hacer referencia a una
posición determinada de la memoria del ordenador.

{Caso práctico.}{/}

Por ejemplo, si se tiene una variable denominada {mi_variable}
con el valor {3}, ésta estará en una dirección de la memoria (todas
las variables tienen su dirección), el operador {#1085,OFFSET} sirve
para obtener esta dirección.

Suponiendo que exista otra variable denominada {dirección_de_mi_variable}
en la que guardar la dirección de la variable anterior, ésto se haría
con la siguiente sentencia:

  {dirección_de_mi_variable = OFFSET mi_variable;}

Esta dirección será un número entero, pongamos {12345}; para
obtener el valor de la variable ({3}) o modificarlo, teniendo únicamente
la dirección (posición) de la variable en memoria (y no su nombre),
se debe utilizar el operador {POINTER}, la sentencia obtener el
valor de la variable a partir de su dirección sería:

  {mi_variable = POINTER dirección_de_mi_variable;}

Para aclarar los conceptos de {nombre de variable}, {dirección de la
variable} y {valor de la variable} se muestran a continuación una
serie de expresiones y sus equivalentes numéricos.

  {mi_variable} = {3}·
  {OFFSET mi_variable} = {12345}·
  {dirección_de_mi_variable} = {12345}·
  {POINTER dirección_de_mi_variable} = {3}·

La dirección de una variable puede variar según se vaya ampliando
un programa (añadiendo nuevos datos y sentencias al mismo).

En resumen, {el operador POINTER accede al valor que está en la
posición de la memoria del ordenador indicada tras él}, es decir:

  {POINTER 12345} = {3}·

Lo que quiere decir que, en la dirección {12345} de la memoria del
ordenador, está el valor {3}, ya que en esta dirección es donde
se {almacena} el valor de la variable {mi_variable} y ése es
su valor.

{/}

El {#1054,símbolo *} y el {#1080,símbolo ^} pueden utilizarse como
{sinónimos} de la palabra reservada {POINTER} (en el ejemplo
anterior {*12345} = {3} o bien {^12345} = {3}).

{/}

Los corchetes (símbolos {[ ]}) funcionan de forma similiar al operador
{POINTER}, con la única diferencia que acceden al dato cuya dirección se indica
entre ellos (en el ejemplo anterior {[12345]} = {3}).

Los corchetes también se utilizan para especificar el índice en las
tablas y estructuras.

{/}Ver: {#1000,Sintaxis} - {#1085,OFFSET}

# ─────────────────────────────────────────────────────────────────────────────

{.1080,^}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Símbolo bifuncional que tiene dos usos diferentes según se utilice como
un operador unario o binario.

Un operador {UNARIO} aparece dentro de una expresión precediendo
simplemente a un operando (como si fuera el signo de éste), en cuyo caso
el operador{ ^} será un sinónimo de {#1079,POINTER}.

{Ejemplo: ^x} es equivalente a {POINTER x}

Un operador {BINARIO} aparece dentro de una expresión concatenando
a dos operandos (indicando una operación entre ambos); en este caso el
operador{ ^} será un sinónimo de {#1082,XOR}.

{Ejemplo: x^2} es equivalente a {x XOR 2}

{/}Ver: {#1000,Sintaxis} - {#1079,POINTER} - {#1082,XOR}

# ─────────────────────────────────────────────────────────────────────────────

{.1081,^=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación lógica y binaria de {OR (o) exclusivo} ({XOR}).

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ ^=} en lugar de {=} para realizar la asignación,
se asignará al dato el {OR (o) exclusivo} siguiente:

  [{valor_anterior_del_dato}] XOR [{resultado_de_la_expresión}]

Ejemplo: {x=5; x^=3;} -> (x=3)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C};
en cualquier caso una sentencia del tipo {n ^= m;} será equivalente a
ésta otra {n = n XOR m;}.

Ver el operador {#1082,XOR} para más información sobre el {OR (o) exclusivo}.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1082,XOR  ^^}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador lógico y binario de {OR (o) exclusivo} utilizado en expresiones y
condiciones.

La palabra reservada {XOR} y el símbolo{ ^^} son sinónimos.

{XOR lógico:} Se evalúan primero las condiciones de la derecha e izquierda
del operador y si {sólo una} de ambas es {cierta}, este operador devolverá
{cierto}; en caso contrario el operador devolverá siempre {falso}.

  FALSO  XOR FALSO  = FALSO
  FALSO  XOR CIERTO = CIERTO
  CIERTO XOR FALSO  = CIERTO
  CIERTO XOR CIERTO = FALSO

Se utiliza para comprobar que se cumplan una, y sólo una, de las dos
condiciones que se especifican, por ejemplo:

  {(y>0 XOR x>0)}

Para comprobar que la primera variable sea mayor que 0, o bien
('o' exclusivo), que lo sea la segunda (pero no la primera).

{XOR binario:} Evalúa los bits de los resultados de las expresiones anterior
y posterior al operador generando, como resultado, un valor que tendrá a 1
solamente los bits que tuvieran a 1 una, y sólo una, de las expresiones.

  0 XOR 0 = 0
  0 XOR 1 = 1
  1 XOR 0 = 1
  1 XOR 1 = 0

Esta regla se aplicará a todos los bits de los operandos (en el lenguaje
son enteros de 32 bits).

{/}

{Nota:} Este operador funciona indistintamente como lógico y binario debido
a que en el lenguaje se interpretan las expresiones lógicas {ciertas} como las
que tienen el último bit a 1 (el bit 0, de peso 1), es decir, los números
impares (1, -1, 3, -3, ... ), y como expresiones lógicas {falsas} las que
tienen el último bit a 0 (los números pares: 0, 2, -2, 4, -4, ...).

El operador {XOR} únicamente dejará a 1 el último bit (sólo devolverá {cierto}
como resultado} cuando lo tuviera a 1 uno, y sólo uno, de ambos operandos
(cuando únicamente una de las dos expresiones fuera {cierta}).

{/}

{Nota:} El símbolo{ ^} también puede utilizarse como un sinónimo más de
{XOR} y{ ^^}.

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1037,Condición} - {#1083,OR}

# ─────────────────────────────────────────────────────────────────────────────

{.1083,OR  ||  |}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Operador binario de {suma lógica} utilizado en expresiones y
condiciones.

La palabra reservada {OR} y los símbolos{ ||} y{ |} son sinónimos.

{OR lógico:} Se evalúan primero las condiciones de la derecha e izquierda
del operador y si al menos una de ellas es {cierta}, este operador devolverá
{cierto}, en caso contrario el operador devolverá {falso} (cuando las dos
condiciones sean {falsas}).

  FALSO  OR FALSO  = FALSO
  FALSO  OR CIERTO = CIERTO
  CIERTO OR FALSO  = CIERTO
  CIERTO OR CIERTO = CIERTO

Se utiliza para comprobar que se cumplan una (cualquiera) de las condiciones
que se establecen, por ejemplo:

  {(x>0 OR y>0)}

Para comprobar que al menos una de las dos variables sea mayor que 0. Es
decir, que se cumpla la primera condición {O} la segunda.

{OR binario:} Evalúa los bit de los resultados de las expresiones anterior
y posterior al operador, generando como resultado un valor que tendrá a 1
los bit que tuvieran a 1 cualquiera de las expresiones.

  0 OR 0 = 0
  0 OR 1 = 1
  1 OR 0 = 1
  1 OR 1 = 1

Esta regla se aplicará a todos los bit de los operandos (en el lenguaje
son enteros de 32 bits).

{/}

{Nota:} Este operador funciona indistintamente como lógico y binario debido
a que en el lenguaje se interpretan las expresiones lógicas {ciertas} como las
que tienen el último bit a 1 (el bit 0, de peso 1), es decir, los números
impares (1, -1, 3, -3, ... ), y como expresiones lógicas {falsas} las que
tienen el último bit a 0 (los números pares: 0, 2, -2, 4, -4, ...).

El operador {OR} dejará a 1 el último bit (devolverá {cierto}
como resultado} cuando lo tuviera a 1 uno (cualquiera) de los operandos (cuando los dos fueran,
al menos, una de las dos expresiones fuera {cierta}).

{/}Ver: {#1000,Sintaxis} - {#1035,Expresión} - {#1037,Condición} - {#1082,XOR}

# ─────────────────────────────────────────────────────────────────────────────

{.1084,|=}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Asignación operativa. Operación binaria de {suma lógica} ({OR}).

Las {#1019,sentencias de asignación} sirven para calcular expresiones y
{asignárselas} a un dato.

{#1034,<referencia a un dato>} {=} {#1035,<expresión>} {;}

Si se utiliza el símbolo{ |=} en lugar de {=} para realizar la asignación,
se asignará al dato la {suma lógica} siguiente:

  [{valor_anterior_del_dato}] OR [{resultado_de_la_expresión}]

Ejemplo: {x=5; x|=6;} -> (x=7)

{/}

{Nota:} Este símbolo es una simple abreviatura derivada del {lenguaje C},
en cualquier caso una sentencia del tipo {n |= m;} será equivalente a
esta otra {n = n OR m;}.

Ver el operador {#1083,OR} para más información sobre la {suma lógica}.

{/}

{Nota:} No se debe confundir este símbolo con el de [{distinto que}] que
se expresa como {#1046,!=}, y sirve para comparar si dos expresiones
difieren en su resultado.

{/}Ver: {#1000,Sintaxis} - {#1019,Asignación}

# ─────────────────────────────────────────────────────────────────────────────

{.1085,OFFSET}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

La palabra reservada {OFFSET} permite obtener la dirección de un
dato dentro de la memoria del ordenador.

Todos los datos de un programa se corresponden con alguna posición
concreta de la memoria en la que está almacenado su valor; el
operador {OFFSET} permite obtener esta posición como un valor
numérico.

Este operador se utiliza, principalmente, en los parámetros de algunas
de las funciones del lenguaje; esto se hace para permitir a dichas
funciones que puedan modificar estos parámetros.

Si se tiene una variable, por ejemplo denominada {mi_variable},
con el valor {321} y se pasa, como parámetro, dicha variable a una función
parámetro, se le está pasando a la función el número 321; con esto,
la función no podrá modificar la variable ya que conoce su valor
pero no {dónde está la variable} (pues puede haber muchos valores
{321} por toda la memoria del ordenador, y no sabrá cuál de ellos
es la variable).

Si a esta función se le pasa como parámetro {OFFSET mi_variable}
se le estará informando del lugar en el que está almacenado el
valor de la variable, pudiendo, la función, acceder a dicho valor para
consultarlo o modificarlo.

Para más información sobre este operador se puede acceder al
{#1079,operador POINTER} que realiza la operación inversa al operador
{OFFSET} (es decir, obtiene el valor que hay en una posición determinada
de la memoria).

{/}

El {#1050,símbolo &} puede utilizarse como {sinónimo} de la palabra
reservada {OFFSET}.

{/}Ver: {#1000,Sintaxis} - {#1079,POINTER}

# ─────────────────────────────────────────────────────────────────────────────

{.1086,BEGIN}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra reservada indica el comienzo del programa o proceso.

Es decir, la palabra {BEGIN} se utiliza para separar la zona
de declaración de datos del programa principal o de un proceso,
de la zona de sentencias.

Es obligatoria la declaración {BEGIN} (inicio) en el programa
principal y todos los procesos.

Cuando se ejecuta un programa o proceso, éste comenzará siempre por
la sentencia que venga a continuación de {BEGIN}.

La sentencia {BEGIN no hace nada}, únicamente sirve como delimitador
dentro de la estructura de los programas.

{/}

Cada {BEGIN} (inicio) viene relacionado directamente con un
{#1091,END} (fin) que marcará el final de la zona de sentencias
del programa o proceso.

{/}Ver: {#1000,Sintaxis} - {#1015,Código Principal} - {#1016,Declaración de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.1087,CASE}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra reservada forma parte de la sentencia {#1021,SWITCH};
se utiliza como inicio de las diferentes secciones de sentencias
que pueden ejecutarse o no, dependiendo del resultado de la expresión
evaluada.

Cada {CASE} debe tener una palabra {#1091,END} que indique el
final de la sección.

La sentencia {#1021,SWITCH} evalúa una expresión y el significado
que tiene la palabra {CASE} es "{en el caso de que el resultado de
la expresión sea ..., entonces se deben ejecutar las siguientes
sentencias ...}".

{/}Ver: {#1000,Sintaxis} - {#1021,Sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.1088,DEFAULT}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra reservada forma parte de la sentencia {#1021,SWITCH} que
se utiliza como inicio de una sección de sentencias que debe ejecutarse
cuando el resultado de la expresión evaluada no esté contemplado en
ninguna de las secciones {#1087,CASE} de la sentencia.

Cada {DEFAULT} debe tener una palabra {#1091,END} que indique el
final de la sección.

La sentencia {#1021,SWITCH} evalúa una expresión; cada sección
{#1087,CASE} de la sentencia contemplará uno o varios resultados en los
que se debe ejecutar dicha sección y, por último, si aparece una
sección {DEFAULT} es para expresar "{en el caso de que el resultado de
la expresión no sea ninguno de los anteriores, entonces se deben ejecutar
las siguientes sentencias ...}".

{/}Ver: {#1000,Sintaxis} - {#1021,Sentencia SWITCH}

# ─────────────────────────────────────────────────────────────────────────────

{.1089,DUP}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra sirve para definir {#1013,listas de constantes} (valores numéricos),
a base de repetir un patrón sencillo. Se utiliza para inicializar los
valores iniciales de tablas y estructuras.

Su sintaxis es la siguiente:

<número de veces> {DUP (}<secuencia a repetir>{)}

Es equivalente a poner la <secuencia a repetir> el <número de veces>
que se indica.

Por ejemplo, la secuencia {1, 2, 3, 1, 2, 3, 1, 2, 3} sería equivalente a
la secuencia {3 DUP (1, 2, 3)}.

{/}Ver: {#1000,Sintaxis} - {#1013,Definición de una lista de constantes}

# ─────────────────────────────────────────────────────────────────────────────

{.1090,ELSE}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra forma parte de la sentencia {#1020,IF}, y sirve
para especificar dónde comienza el bloque de sentencias que se debe
ejecutar cuando la condición especificada en la sentencia
{#1020,IF} no se cumpla.

El formato de la sentencia {#1020,IF} es el siguiente:

{IF (<}condición{>)}·
    // Código a ejecutar cuando se cumpla la condición·
{ELSE}·
    // Código a ejecutar cuando {no} se cumpla la condición·
{END}·

El significado semántico de {ELSE} es "{en el caso contrario ...}".

{/}

La sección {ELSE} es opcional, pudiendo formularse la sentencia {#1020,IF}
de la siguiente forma:

{IF (<}condición{>)}·
    // Código a ejecutar cuando se cumpla la condición·
{END}·

Cuando no se requiera que se ejecute ninguna sentencia {en el caso
contrario}.

{/}Ver: {#1000,Sintaxis} - {#1020,Sentencia IF}

# ─────────────────────────────────────────────────────────────────────────────

{.1091,END}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra reservada marca el final de una de las siguientes sentencias:

  {#1086,BEGIN}·
  {#1020,IF}·
  {#1022,WHILE}·
  {#1021,SWITCH}·
  {#1087,CASE}·
  {#1087,DEFAULT}·
  {#1025,FOR}·
  {#1043,FROM}·
  {#1024,LOOP}·
  {#1030,CLONE}·

Es decir, la función de la palabra {END} es {delimitar dónde acaba
una sentencia}.

Se debe tener en cuenta que las sentencias se pueden
anidar, es decir, incluir unas dentro de otras, por lo que si no
se estructura bien un programa (tabulando el código), puede resultar
difícil averiguar a qué sentencia corresponde cada {END}.

Por ejemplo, en el siguiente código se puede ver claramente a qué
sentencia pertenece cada {END}.

{BEGIN}·
    {IF (x>0)}·
        {x=x-1;}·
    {END}·
{END}·

Pero este mismo código podría haberse expresado como sigue:

{BEGIN}·
    {IF (x>0)}·
    {x=x-1;}·
{END}·
    {END}·

resultando mucho más complicada la lectura del programa, aunque
para el compilador del lenguaje {ambos bloques de código son
exactamente iguales} (el compilador seguirá interpretando que
el primer {END} es el de la sentencia {IF} y el segundo el
del {BEGIN}, aunque éstos estén tabulados incorrectamente).

{/}Ver: {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1092,ID}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

La palabra reservada {ID} se utiliza para obtener el {#1039,código
identificador} de un proceso en tiempo de ejecución.

Un {#1039,código identificador} es un valor numérico que
{identifica} a cada uno de los porcesos activos en cada momento
(cada uno de los objetos que tenga el juego).

Es decir, {ID} es como una constante numérica sólo que su valor
será diferente para cada proceso que la consulte.

No es posible cambiar el valor de {ID}, ya que es un objeto
únicamente de lectura.

Normalmente, un proceso accede a este valor cuando quiere informar
a otros procesos de cuál es su {#1039,código identificador}.

{/}Ver: {#1000,Sintaxis} - {#1039,Códigos identificadores}

# ─────────────────────────────────────────────────────────────────────────────

{.1093,SETUP_PROGRAM}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Esta palabra reservada sirve para designar un tipo especial de
programas, de {configuración del hardware de sonido}.

Estos programas se identifican por comenzar con la palabra
reservada {SETUP_PROGRAM} en lugar de {#1003,PROGRAM}.

Éste es un tópico muy avanzado, para usuarios con experiencia.

Se puede observar un programa de este tipo en el directorio {SETUP}
de DIV Games Studio; estos programas, una vez compilados, se incluirán
automáticamente en las instalaciones del resto de programas, cuando
en el proceso de instalación se active la casilla "{Incluir setup de sonido}".

{Nota:} En las instalaciones siempre se incluirá el último programa
de setup que haya sido compilado en DIV Games Studio.

{/}

No obstante, se recuerda que no es imprescindible crear programas
de configuración del sistema de sonido, ya que los juegos creados con DIV Games
Studio detectarán automáticamente si el ordenador en el que se
ejecutan tiene una tarjeta de sonido compatible con {Sound Blaster}
o {Gravis Ultrasound}, siempre que ésta esté apropiadamente configurada.

{/}

Este tipo de programas suelen modificar la {#1104,estructura global
setup}, que es la que controla los parámetros del sistema de sonido.

{/}Ver: {#1000,Sintaxis} - {#1104,Estructura setup}

# ─────────────────────────────────────────────────────────────────────────────

{.1094,SIZEOF()}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{SIZEOF(}<nombre del dato>{)}

{Retorna:}

El número de elementos que contiene el dato.

{Descripción:}

La palabra reservada {SIZEOF} se utiliza para calcular el número
de elementos que tiene una tabla o una estructura.

Esta palabra reservada {se utiliza como si fuera una función} del lenguaje,
indicando, entre paréntesis, el {#1001,nombre} del dato y devolviendo el
número de elementos (posiciones) del mismo.

Es posible utilizarla para obtener el número de elementos de una
variable pero, en este caso, {SIZEOF} retornará siempre {1}
como número de elementos (ya que una variable es un único elemento).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_sizeof;

PRIVATE
    tabla1[]=0, 1, 2, 3;
    tabla2[]=4, 5, 6, 7, 8;
    variable=9;

BEGIN
    // ...

    save("help\help.dat", OFFSET tabla1, SIZEOF(tabla1)+SIZEOF(tabla2)+SIZEOF(variable));

    // ...
END
{-}

En este ejemplo se utiliza {SIZEOF} para obtener el número de elementos
de tres datos diferentes; éstos son:

{tabla1} de {4} elementos.·
{tabla2} de {5} elementos.·
{variable} ({1} elemento).·

En este caso se utiliza para grabar en el archivo {help.dat} el
contenido de estos tres datos con la función {#155,save()} que
requiere, como tercer parámetro, el número de elementos que se quieren
guardar en el archivo.

En este caso se guardarán {10} elementos en el archivo {help.dat},
que según están inicializados los datos en el ejemplo serán los
números del {0} al {9}.

La sentencia {#155,save()} del ejemplo anterior se podría haber
expresado también sin utilizar {SIZEOF} de la siguiente forma:

  {save("help\help.dat", OFFSET tabla1, 10);}

La única diferencia es que si en el programa del ejemplo se añadieran
elementos a alguna de las dos tablas, no haría falta modificar la
llamada a la función {#155,save()}, ya que {SIZEOF} siempre devolverá
el tamaño actual de las mismas.

{/}Ver: {#1000,Sintaxis} - {#1011,Declaración de una tabla} - {#1012,Declaración de una estructura}

# ─────────────────────────────────────────────────────────────────────────────

{.1095,STEP}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

La palabra reservada {STEP} forma parte de la sentencia {#1043,FROM} y sirve
para indicar el incremento (paso) que se debe hacer en cada iteración del bucle.

La sentencia {#1043,FROM} implementa un bucle, es decir, un grupo de
sentencias que se van a repetir un número determinado de veces; para
ello, utiliza una variable como contador del número de repeticiones.

Se define el valor inicial de la variable así como el valor final, y el
bucle se repetirá hasta que la variable alcance el valor final, partiendo
del valor inicial.

Por defecto, la variable pasará por todos los valores numéricos enteros
comprendidos entre el valor inicial y el valor final, pero se puede
indicar una declaración {STEP} para establecer un incremento de la
variable diferente.

Por ejemplo, si se define un bucle en el que la variable {x} va a
recorrer los valores del {1} al {10}, se ejecutará dicho bucle un
total de {10} veces, pero si se estable el paso ({STEP}) como {2}
el bucle se ejecutará únicamente {5} veces, en donde la variable
{x} tomará los valores {1}, {3}, {5}, {7} y {9}, pues se habrá
establecido que la variable debe incrementarse de {2} en {2}. Este
bucle se implementaría de la siguiente forma:

{FROM x=1 TO 10 STEP 2}·
  // Sentencias que se van a repetir las cinco veces·
{END}·

Si se omite la declaración {STEP} de la sentencia {#1043,FROM}, el
incremento será siempre de 1 en 1, sumando 1 a la variable tras cada
iteración del bucle (o restando 1, en el caso de que el valor final
sea menor que el valor inicial).

{Nota:} Unicamente se pueden establecer incrementos enteros.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM}

# ─────────────────────────────────────────────────────────────────────────────

{.1096,TO}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

La palabra reservada {TO} forma parte de la sentencia {#1043,FROM} y sirve
para separar las constantes que indican los valores inicial y final que
debe tomar la variable que se utilice como contador del bucle.

La sentencia {#1043,FROM} implementa un bucle, es decir, un grupo de
sentencias que se van a repetir un número determinado de veces; para
ello utiliza una variable como contador del número de repeticiones.

Se define el valor inicial de la variable y el valor final, y el
bucle se repetirá hasta que la variable alcance el valor final, partiendo
del valor inicial.

{Ejemplo:}

  {FROM x=1 TO 10}·
    // Sentencias que se repetirán 10 veces·
  {END}·

Por defecto, la variable pasará por todos los valores numéricos enteros
comprendidos entre el valor inicial y el valor final, pero se puede
indicar una declaración {#1095,STEP} para establecer un incremento de la
variable diferente.

{/}Ver: {#1000,Sintaxis} - {#1043,Sentencia FROM} - {#1095,STEP}

# ─────────────────────────────────────────────────────────────────────────────

{.1097,UNTIL}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

La palabra reservada {UNTIL} forma parte de la sentencia {#1023,REPEAT},
cuya sintaxis es, a grandes rasgos, la siguiente:

{#1023,REPEAT}·
    {#1017,<sentencia>};·
    ...·
{UNTIL (<}condición>}{)}

La sentencia {#1023,REPEAT} implementa un bucle, es decir, es capaz
de repetir un grupo de sentencias un número determinado de veces.

El final de la sentencia se determina poniendo la palabra reservada {UNTIL}
seguida de la condición que se debe cumplir para que {se de por finalizada
la sentencia}.

{/}Ver: {#1000,Sintaxis} - {#1023,Sentencia REPEAT}

# ─────────────────────────────────────────────────────────────────────────────

{.1100,GLOBAL STRUCT mouse}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT mouse;}·
    {x, y;}                // Coordenadas·
    {graph;}               // Código del gráfico·
    {file;}                // Código del fichero·
    {z;}                   // Plano de profundidad·
    {angle;}               // ángulo·
    {size;}                // Tamaño (%)·
    {flags;}               // Indicador espejados·
    {region;}              // Región de corte·
    {left, middle, right;} // Estado botones·
{END}·

Esta estructura global sirve para controlar el ratón; contiene
una serie de campos relacionados con la programación de este
dispositivo, como la posición en pantalla, el gráfico del puntero,
el estado de los botones, etc.

Para acceder a estos campos se debe preceder el nombre del campo
por la palabra {mouse} y el símbolo {#1063,. (punto)}; por ejemplo, para
acceder al campo {x} (coordenada horizontal del puntero del ratón)
se debe utilizar {mouse.x}.

{/}

{x}, {y} - Coordenadas horizontal y vertical del ratón. Estos dos campos
({mouse.x} y {mouse.y}) serán los únicos que necesariamente habrá que leer para
conocer la posición en pantalla del cursor del ratón.

Para {posicionar el ratón en otras coordenadas} (forzar su posición),
bastará con asignar las nuevas coordenadas a estos dos campos.

{/}

{graph} - {Código del gráfico} asignado como puntero del ratón. Por
defecto {el ratón no será visible}; para hacerlo visible se debe crear
el gráfico que va a servir de puntero en el {editor gráfico},
cargarlo en el programa (con la función {#132,load_fpg()} o {#174,load_map()}, según
se haya guardado este gráfico en un {fichero FPG} o en un {archivo MAP}), y
asignar su {código de gráfico} a esta variable ({mouse.graph}). Entonces se hará
visible el puntero del ratón en pantalla.

En las coordenadas {mouse.x}, {mouse.y} aparecerá el centro del gráfico,
a no ser que se haya definido el {#1136,punto de control} número {0} del mismo
en el {editor gráfico}. Si se define este punto, comúnmente denominado
"{punto caliente del ratón}" ({hot spot}), será él mismo el que aparezca
en las coordenadas indicadas en los campos {mouse.x} e {mouse.y}.

Por ejemplo, si se crea como dibujo para el puntero del ratón la
típica flecha (como el puntero de ratón DIV Games Studio), el "punto
caliente" (punto de control número {0}) se definiría en la
esquina superior izquierda del gráfico, pues éste es el {punto activo}
dentro del gráfico. Entonces, cuando el ratón estuviera, por ejemplo,
en las coordenadas (0, 0), sería la precisamente la "{punta de la flecha}"
la que se situara en dichas coordenadas.

{/}

{file} - {Código del fichero} que contiene el gráfico. En este campo se define
el {código de fichero} que contiene el gráfico del puntero del ratón.
{No es necesario} indicar aquí un valor si el gráfico se cargó de un
{archivo MAP}, o si está en el primer {archivo FPG} cargado en el
programa. En caso contrario, se deberá asignar a {mouse.file} el
{código de fichero} que retornó la función {#132,load_fpg()} al cargar
el fichero que contiene el gráfico del puntero del ratón.

{/}

{z} - Prioridad de impresión del gráfico. Indica en qué plano de profundidad
debe pintarse el gráfico del puntero del ratón. {Por defecto} este campo
valdrá{ -512}, lo que implica que {el puntero se verá por encima del resto
de gráficos y textos}. Cuanto mayor sea este campo, más al fondo se situará
el puntero del ratón.

Si se quisiera que un gráfico de un proceso apareciera
por encima del puntero del ratón, bastaría con asignar a la variable
{#1125,local z} de dicho proceso un número entero menor de{ -512},
por ejemplo{ -600}.

{/}

{angle} - ángulo con el que se verá el gráfico del puntero del ratón.
El valor de {mouse.angle} por defecto es {0}, lo que implica que no
se verá rotado este gráfico, a no ser que se asigne un nuevo ángulo
a este campo.

Se recuerda que los ángulos se deben especificar en
milésimas de grado, por ejemplo, la sentencia {mouse.angle=90000;} hará que el
puntero aparezca rotado {90 grados} (ver el {#1044,uso de ángulos
en el lenguaje}).

{/}

{size} - Tamaño del gráfico en porcentaje. Por defecto, este campo
valdrá {100} (el gráfico se verá al 100% de su tamaño), y no es
necesario indicar aquí otro valor a no ser que se quiera que el
gráfico se escale (se vea ampliado o reducido).

Si por ejemplo se quisiera que el gráfico apareciera el doble de
grande que su tamaño original (al 200%), se debería utilizar la sentencia
{mouse.size=200;}.

{/}

{flags} - En este campo se indicarán diferentes valores cuando se
pretenda que el gráfico del ratón aparezca espejado (invertido
horizontal o verticalmente), o se quiera visualizarlo como un
gráfico (semi) transparente. Los posibles valores asignables a
la variable {mouse.flags} son:

 {0}-Gráfico normal (valor por defecto).·
 {1}-Espejado horizontal.·
 {2}-Espejado vertical.·
 {3}-Espejado horizontal y vertical (180°).·
 {4}-Gráfico transparente.·
 {5}-Transparente y espejado horizontal.·
 {6}-Transparente y espejado vertical.·
 {7}-Transparente, espejado horizontal y vertical.·

{/}

{region} - Región de corte del gráfico. A este campo se debe asignar
un valor {únicamente cuando se quiera que el puntero del ratón sea
visible sólo dentro de una región} (una zona rectangular de la pantalla);
para conseguirlo se debe, primero, definir esta región con la función
{#106,define_region()} y, después, asignar a este campo ({mouse.region})
el número de la región que se ha definido.

Por defecto este valor será {0}, que es el número de región que se
refiere a la pantalla completa, por lo que el gráfico será visible
en toda la pantalla.

{/}

{left}, {middle} y {right} - Estos tres campos almacenan valores
lógicos ({0} o {1}) según los botones del ratón estén pulsados o
no (se corresponden con los botones izquierdo, central y derecho
del ratón). Normalmente, se activan únicamente dos botones del ratón
({left} y {right}) ignorándose el estado del botón central. Esto
depende del {driver} (dispositivo de control) del ratón que esté
instalado en el ordenador.

Por ejemplo, para realizar en un programa una acción {cuando se pulse
el botón izquierdo del ratón} ({mouse.left}) se debe incluir en el código
una sentencia como la siguiente:

  {IF (mouse.left)}·
    // Acción a realizar (sentencias)·
  {END}·

{/}Ver: {#1200,Datos globales}

# ─────────────────────────────────────────────────────────────────────────────

{.1101,GLOBAL STRUCT scroll}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT scroll[9];}·
    {x0, y0;}    // Coordenadas del primer plano·
    {x1, y1;}    // Coordenadas del segundo plano·
    {z;}         // Plano de profundidad·
    {camera;}    // {#1039,Código identificador} de la cámara·
    {ratio;}     // Velocidad relativa del segundo plano·
    {speed;}     // Velocidad máxima del primer plano·
    {region1;}   // Primera región de pantalla·
    {region2;}   // Segunda región de pantalla·
{END}·

Esta estructura de {10} registros contiene ciertos campos relacionados
con parámetros modificables de las {ventanas de scroll}. Los diez
registros tienen los mismos nombres de campos, pero cada uno de
ellos modifica los parámetros de una ventana de scroll diferente
(ya que pueden activarse hasta 10 ventanas de este tipo).

Una {ventana de scroll} se podría definir como una región de pantalla que
muestra sólo una parte de un gráfico más grande que dicha ventana (este
gráfico suele ser el {decorado} o {fondo} del juego). El {scroll} en sí
es el movimiento de dicha ventana por el gráfico en cualquier dirección,
visualizándose poco a poco el gráfico completo, sección a sección del mismo.

Para que un registro (del {0} al {9}) de la {estructura scroll} tenga sentido,
primero debe activarse dicha {ventana de scroll} (del {0} al {9}) con la
función {#163,start_scroll} (ver esta función para más información sobre
las ventanas de scroll}.

Se entiende que los campos de esta estructura son complementarios a los
parámetros de llamada de esta última función.

{/}

{Forma de uso de la estructura scroll:}

Para acceder a estos campos se debe preceder el nombre del campo
por la palabra {scroll}, el número de registro entre corchetes y el símbolo
{#1063,.} (punto).

Por ejemplo, si se inicializaran dos ventanas de scroll, la número 0 y la
número 1, se podría acceder al campo {camera} de ambas ventanas como
{scroll[0].camera} y {scroll[1].camera}, respectivamente. Cuando se acceda a la
ventana número 0 de scroll se puede, además, omitir el número de
ventana entre corchetes, es decir, que la variable {scroll.camera} y la variable
{scroll[0].camera} son, a todos los efectos, la misma para el lenguaje.

{/}

{Se muestra a continuación una descripción detallada de cada campo.}

{x0, y0} - Coordenadas del primer plano de scroll, cuando es scroll {NO} es
automático (no se ha definido el campo {camera}), {éstos son los campos que
se deberán modificar para mover el primer plano de la ventana de scroll}.

Estos dos campos almacenan las coordenadas horizontal y vertical de la esquina
superior izquierda de la ventana de scroll (el punto del gráfico del primer
plano que se verá en la esquina superior izquierda de la ventana).

Cuando se haya definido el campo {camera} de esta estructura, el movimiento
de la ventana de scroll será automático, por lo que estos campos serán
sólo de lectura; para poder comprobar donde está situado el scroll en cada
momento (ver la función {#140,move_scroll()}).

{/}

{x1, y1} - Coordenadas del segundo plano, cuando se haya definido un gráfico
para el segundo plano. Cuando el scroll {NO} es automático (no se ha definido
el campo {camera}), {éstos son los campos que se deberán modificar para mover
el plano de fondo de la ventana de scroll}.

Cuando se haya definido el campo {camera} de esta estructura, el movimiento
de la ventana de scroll será automático, por lo que estos campos serán
sólo de lectura, determinándose la velocidad de movimento del segundo plano
en función del campo {ratio} de esta misma estructura.

{/}

{z} - Prioridad de impresión del scroll, aquí se indica en que plano de profundidad
se debe pintar esta ventana, respecto al resto de procesos. Por defecto, esta
variable valdrá {512}, lo cual quiere decir que como los procesos por defecto
tienen su variable {#1125,local z} a {0}, la ventana de scroll se pintará en un plano
de profundidad mayor, más al fondo, visualizándose los gráficos de los procesos
por encima de la ventana. Para variar esta situación se puede modificar la
variable {z} de la ventana (por ejemplo, ponerla a{ -1}) o la variable {z} de
los procesos (por ejemplo, ponerla a {600}).

{/}

{camera} - Este campo no es necesario inicializarlo, se inicializará cuando
se quiera que el scroll sea {automático}, esto es, que el sistema se encargue
de que éste siga siempre a un proceso (un gráfico del juego). Para ello, se
debe poner en este campo el {#1039,código identificador} del proceso; sólo
con esto, el desplazamiento de la ventana de scroll pasará a ser controlado
automáticamente por el sistema, intentando centrar el gráfico de dicho proceso
siempre en la ventana. Este proceso debe tener la variable local {#1122,ctype}
con el valor {#1168,c_scroll}.

Por defecto este campo valdrá {0}, lo que implica que el scroll no seguirá a
ningún proceso, a no ser que se asigne el {#1039,código identificador} de uno
a {camera}. Cuando se haga esto, se denominará a este proceso como el {proceso
cámara} del scroll.

{Nota:} A continuación se muestra una serie de campos {sólo para ventanas de
scroll automático}; esto quiere decir que para que dichos campos tengan sentido
(y, por consiguiente, efecto) se debe haber definido previamente el campo
{camera} de esta estructura con el {#1039,código identificador} del proceso
que se va a centrar en el scroll. Estos valores afectarán a la forma en la
que se va a hacer este seguimiento al proceso denominado {cámara del scroll}.

{/}

{ratio} - {Ventanas de scroll automático}. Cuando se hayan definido dos planos
de scroll en la llamada a la función {#163,start_scroll()}, en este campo
se puede definir la {velocidad de movimiento del plano del fondo} respecto
a la del primer plano. Por defecto, este valor será {200} lo que implicará
que el plano de fondo se moverá a la mitad de velocidad del primer plano;
si se define como {400} se moverá a la cuarta parte (cuatro veces más lento),
{100} a la misma velocidad, {50} al doble de velocidad que el primer plano, etc.

{/}

{speed} - {Ventanas de scroll automático}. Velocidad máxima del primer plano
de scroll, por defecto valdrá {0}, lo que quiere decir que no se impone ningún
límite de velocidad. Si se impone un límite, especificando el número de puntos máximo
que puede desplazarse el primer plano por cada imagen del juego, se descentrará
el {proceso cámara} de la ventana de scroll cuando éste se mueva a una velocidad mayor.

{/}

{region1} - {Ventanas de scroll automático}. Región de bloqueo del scroll, cuyo
valor, por defecto, es{ -1} lo que implica que no hay ninguna región de bloqueo.
Si se define este campo con un número de región (una zona rectangular de la
pantalla definida previamente con la función {#106,define_region()}), entonces
el sistema no moverá el scroll mientras el {proceso cámara} permanezca dentro
de la misma.

{/}

{region2} - {Ventanas de scroll automático}. Region exterior del scroll; por
defecto su valor es{ -1}, lo que implica que no hay una región exterior.
Si se define este campo con un número de región y se ha definido una {velocidad
máxima} en el campo {speed}, entonces el sistema ignorará dicho límite de
velocidad cuando el proceso{ cámara} vaya a salirse de esta región (ésto se hace para
no perder de vista al proceso (para que su gráfico siempre sea visible dentro
de la ventana de scroll).

{Nota:} Si se definen las dos regiones ({region1} y {region2}), normalmente la región
1 es menor que la región 2 (está contenida en ella), esto implicará que:

- No se desplazará el gráfico de fondo (no se hará scroll) mientras el gráfico
del proceso cámara esté dentro de la región 1.

- Si se ha definido una velocidad máxima ({speed}), entonces se hará scroll para
intentar devolver el gráfico del proceso cámara a la región 1, pero sin sobrepasar
el límite de velocidad impuesto.

- Si el gráfico del proceso cámara intentara salirse de la región 2, se
ignoraría el límite de velocidad impuesto, para no permitirlo.

{/}Ver: {#1200,Datos globales} - {#163,start_scroll()} - {#166,stop_scroll()}

# ─────────────────────────────────────────────────────────────────────────────

{.1102,GLOBAL STRUCT m7}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT m7[9];}·
    {camera;}   // {#1039,Código identificador} de la cámara·
    {height;}   // Altura de la cámara·
    {distance;} // Distancia de la cámara·
    {horizon;}  // Altura del horizonte·
    {focus;}    // Focal de visión·
    {z;}        // Plano de profundidad·
    {color;}    // Color del exterior·
{END}·

Esta estructura de {10} registros contiene ciertos campos relacionados
con parámetros modificables de las {ventanas de modo 7}. Los diez
registros tienen los mismos nombres de campos, pero cada uno de
ellos modifica los parámetros de una ventana de modo 7 diferente
(ya que pueden activarse hasta 10 ventanas de este tipo).

Una {ventana de modo 7} se podría definir como una región de pantalla que
muestra un plano gráfico tridimensionalmente abatido. Por ejemplo como
una hoja de papel con un dibujo que pusieramos horizontal, visualizándose
en pantalla como un suelo (o techo) virtual.

Para que un registro (del {0} al {9}) de la {estructura m7} tenga sentido,
primero debe activarse dicha {ventana de modo 7} (del {0} al {9}) con la
función {#162,start_mode7()} (ver esta función para más información sobre
las ventanas de modo 7}.

Se entiende que los campos de esta estructura son complementarios a los
parámetros de llamada de esta última función. Para poder observar un ejemplo
práctico de un modo 7, se puede acceder a la ayuda sobre la función
{#162,start_mode7()}.

{/}

{Forma de uso de la estructura m7:}

Para acceder a estos campos se debe preceder el nombre del campo
por la palabra {m7}, el número de registro entre corchetes y el símbolo
{#1063,. (punto)}.

Por ejemplo, si se inicializaran dos ventanas de modo-7, la número 0 y la
número 1, se podría acceder a la variable {camera} de ambas ventanas como
{m7[0].camera} y {m7[1].camera}, respectivamente. Cuando se acceda a la
ventana número 0 de modo-7 se puede, además, omitir el número de
ventanas entre corchetes, es decir, que la variable {m7.camera} y la variable
{m7[0].camera} son, a todos los efectos, la misma para el lenguaje.

{/}

{Se muestra a continuación una descripción detallada de cada campo.}

{camera} - {#1039,Código identificador del proceso} al que sigue la cámara. Para mover
la cámara que controla la visión del modo-7, únicamente se debe crear un proceso
de modo-7, un proceso que tenga su variable local {#1122,ctype} {=} {#1169,c_m7}, y poner
su {#1039,código identificador} en la variable {camera} de esta estructura.
Tras esto, símplemente se deben modificar las variables locales {#1123,x}, {#1124,y} e {#1129,angle} de
este proceso y, por ejemplo, utilizar la función {#101,advance()} para mover hacia
delante la cámara.

El campo {camera} es {imprescindible} inicializarlo para que
se active la ventana de modo 7; sin este campo, la ventana no puede determinar
desde dónde se debe {ver} el plano abatido.

{/}

{height} - Altura de la cámara. Esta variable de la estructura regula la
distancia a la que se sitúa del suelo la cámara, por defecto su valor es {32}.
Cualquier número positivo hará que se sitúe la cámara más arriba cuanto mayor
sea el número. Si el valor puesto en el campo {height} de esta misma estructura
es negativo, menor que cero, entonces la cámara se situará por debajo del
plano abatido, mostrándose un "{techo}" en lugar de un "{suelo}".

Se pueden crear dos modos-7 dentro de la misma región: uno
como techo y otro como suelo (uno con {height} positiva y otro negativa). En
este caso, es importante fijar la variable {z} de la {#1102,estructura m7} de
ambos para, de esta forma, determinar en qué plano de profundidad se debe
pintar cada uno.

{/}

{distance} - Distancia de la cámara al proceso seguido. El punto de vista
de la cámara siempre se situará un poco por detrás del proceso cuyo identificador
se ha puesto en el campo {camera} de la estructura. Esto se hace para que se vea el gráfico
del proceso utilizado como cámara, en el caso de que este proceso lo tenga definido
(en su variable local {#1126,graph} o {#1132,xgraph}).

Por defecto, la cámara se situará a {64} puntos por detrás del proceso. Se
entiende por "detrás", a un punto situado a la distancia indicada del gráfico
en el ángulo contrario al que esté orientado el proceso; por ejemplo, si el
proceso está mirando a la derecha, 64 puntos a la izquierda del mismo.

{/}

{horizon} - Altura del horizonte. Éste es el mismo valor que se indicaba como
último parámetro de la función {start_mode7()}; su valor inicial será el que
se indicó en la llamada a esta función. La utilidad de esta variable es el poder hacer que
suba o baje el horizonte en cada visualización (imagen) del juego según las necesidades
de éste.

Al variar la {altura del horizonte} se conseguirá en la {ventana de modo 7}
el efecto de "{mirar hacia arriba}" y "{mirar hacia abajo}".

{/}

{focus} - Focal para la cámara. Esta variable controla la perspectiva de la
cámara; por defecto, su valor es 256 pero se puede poner cualquier valor entre
{0} y {512}, consiguiendo diversos efectos de deformación del plano
tridimensional.

Es decir, este campo controla el ángulo que capta el foco de la cámara; cuanto
mayor sea este valor, más cerca se verán todos los objetos (procesos) situados
en el plano abatido.

{/}

{z} - Prioridad de impresión del modo-7, aquí se indica en qué plano de profundidad
se debe pintar esta ventana, respecto al resto de procesos. Por defecto, esta
variable valdrá {256} lo cual quiere decir que, como los procesos por defecto
tienen su variable {#1125,local z} a {0}, la ventana de modo-7 se pintará en un plano
de profundidad mayor, más al fondo, visualizándose los gráficos de los procesos
por encima de la ventana. Para variar esta situación se puede modificar la
variable {z} de la ventana (por ejemplo ponerla a{ -1}) o la variable {z} de
los procesos (por ejemplo ponerla a {257}).

{/}

{color} - Color para el exterior del modo-7. Cuando en la llamada a la función {start_mode7()}
no se especifique ningún {gráfico exterior} (se ponga a {0} el cuarto
parámetro de llamada), esta variable controlará de qué color se quiere pintar
el exterior, es decir, de qué color debe ser la pantalla más allá del gráfico
que se está abatiendo (más alla de sus límites).

Este campo está inicializado por defecto a {0} que, normalmente, es el color
negro en la paleta de colores, por lo que, si no se asigna a este campo otro
valor (y no se define un gráfico exterior) se verá la pantalla en negro más
allá del plano principal.

{/}Ver: {#1200,Datos globales} - {#162,start_mode7()} - {#165,stop_mode7()}

# ─────────────────────────────────────────────────────────────────────────────

{.1103,GLOBAL STRUCT joy}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT joy;}·
    {left;}    // Control izquierda·
    {right;}   // Control derecha·
    {up;}      // Control arriba·
    {down;}    // Control abajo·
    {button1;} // Primer botón·
    {button2;} // Segundo botón·
    {button3;} // Tercer botón·
    {button4;} // Cuarto botón·
{END}·

Esta estructura global sirve para controlar el {joystick} (palanca de
juegos); contiene una serie de campos lógicos relacionados con la programación
de este dispositivo que son el estado de los botones (si se encuentran pulsados
o no) y el estado de las cuatro direcciones de control principales.

Para acceder a estos campos se debe preceder el nombre del campo
por la palabra {joy} y el símbolo {#1063,. (punto)}, por ejemplo, para
acceder al campo {left} (que indica si se está pulsando el control izquierda)
se debe utilizar {joy.left}.

{/}

{left} - Este campo estará a {1} cuando el {joystick} esté orientado hacia la
{izquierda}, y a {0} en caso contrario.

{right}  - Este campo estará a {1} cuando el {joystick} esté orientado hacia la
{derecha}, y a {0} en caso contrario.

{up}  - Este campo estará a {1} cuando el {joystick} esté orientado hacia
{arriba}, y a {0} en caso contrario.

{down}  - Este campo estará a {1} cuando el {joystick} esté orientado hacia
{abajo}, y a {0} en caso contrario.

Por ejemplo, para realizar en un programa una acción {cuando se mueva
el joystick hacia la derecha} ({joy.right}) se debe incluir en el código
una sentencia como la siguiente:

  {IF (joy.right)}·
    // Acción a realizar (sentencias)·
  {END}·

Para las posiciones en diagonal se deben comprobar los dos campos que
conforman esa diagonal; por ejemplo, para realizar una acción cuando el
{joystick} esté en la diagonal superior derecha se utilizará la siguiente
sentencia:

  {IF (joy.up AND joy.right)}·
    // Acción a realizar (sentencias)·
  {END}·

{/}

{button1}, {button2}, {button3} y {button4} - Estos campos indican el estado
de hasta cuatro botones del joystick, estando a {1} cuando el botón respectivo
esté pulsado, y a {0} cuando no lo esté.

Algunos joystick sólo tienen 2 botones; en este caso, serán los botones
número 0 y 1. En ordenadores con dos joystick conectados el segundo joystick
tendrá los botones número 2 y 3.

{/}

{Nota:} Cuando se requiera una lectura analógica del {joystick} (conocer las
coordenadas exactas en las que está situada la "palanca" del joystick), se
deberá utilizar la función {#122,get_joy_position()}. Obviamente, esta función
será util únicamente en {joystick} analógicos, no funcionando en los digitales.

{/}Ver: {#1200,Datos globales} - {#122,get_joy_position()} - {#121,get_joy_button()}

# ─────────────────────────────────────────────────────────────────────────────

{.1104,GLOBAL STRUCT setup}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT setup;}·
    {card;}     // Tipo de tarjeta·
    {port;}     // Puerto de acceso·
    {irq;}      // Interrupción requerida·
    {dma;}      // Canal de acceso a memoria·
    {dma2;}     // Canal de acceso de 16 bit·
    {master;}   // Volumen maestro (general)·
    {sound_fx;} // Volumen de los efectos·
    {cd_audio;} // Volumen de música CD·
{END}·

Esta estructura de datos es de nivel muy avanzado y no es en absoluto
necesaria para crear ningún juego, por complejo que éste sea, ya que el
gestor de procesos de DIV Games Studio se encargará, normalmente, del hardware
de sonido de forma transparente.

Todos los campos referentes al hardware de sonido se actualizan de manera
automática por el programa si se tiene una tarjeta de sonido, siempre y
cuando se tenga la variable de entorno {BLASTER} o {GRAVIS} debidamente
inicializada.

Esta estructura de un único registro contiene una serie de campos divididos
en dos grupos: los primeros para activar nuevos parámetros del hardware de
sonido instalado en el ordenador y los segundos para ajustar los diferentes
controles de volumen gestionados por el mezclador ({mixer}) del sistema de
sonido.

{/}

{Importante:}

Para activar los nuevos parámetros del hardware de sonido que se introduzcan
en esta estructura (en los campos {card}, {port}, {irq}, {dma} y {dma2}) se debe
llamar a la función {#175,reset_sound()}.

Para activar los nuevos niveles de volumen que se introduzcan en la estructura
(en los campos {master}, {sound_fx} y {cd_audio}) se debe llamar a la función
{#178,set_volume()}.

Esta estructura se utiliza generalmente dentro de los programas de configuración
del sistema de sonido (ver {#1093,setup_program}).

{Nota:} Para acceder a estos campos se debe preceder el nombre del campo
por la palabra {setup} y el símbolo {#1063,. (punto)}; por ejemplo, para
acceder al campo {master} (que indica el nivel de volumen general del mezclador)
se debe utilizar {setup.master}.

{/}

Se muestra, a continuación, una descripción algo más detallada de cada uno
de los campos de esta estructura.

{card} - Indica el tipo de tarjeta de sonido instalada en el ordenador.
El programa admite tarjetas de las familias {Sound Blaster} (tm) y {Gravis Ultra
Sound} (tm) y todas las que sean compatibles {100%} con éstas.

Los valores que puede tomar este campo son los siguientes, depediendo del tipo
de tarjeta de sonido:

    Sin tarjeta o sin sonido = {0}·
    Sound Blaster 1.5        = {1}·
    Sound Blaster 2.0        = {2}·
    Sound Blaster Pro        = {3}·
    Sound Blaster 16         = {4}·
    Sound Blaster AWE        = {5}·
    Gravis Ultra Sound       = {6}·
    Gravis Ultra Sound MAX   = {7}·

{/}

{port} - Indica el puerto de comunicaciones del ordenador en el cual se
deben escribir y leer los datos de la tarjeta de sonido.

Los valores que puede tomar este campo son los siguientes, dependiendo del
puerto asignado al hardware de sonido:

    0x210 = {0}·
    0x220 = {1}·
    0x230 = {2}·
    0x240 = {3}·
    0x250 = {4}·
    0x260 = {5}·

{/}

{irq} - Este campo indica el número de interrupción o IRQ (Interrupt request)
asignado a la tarjeta de sonido activa.

Los valores que puede tomar este campo son, dependiendo de la interrupción
utilizada por la tarjeta, los siguientes:

    IRQ 2   = {0}·
    IRQ 3   = {1}·
    IRQ 5   = {2}·
    IRQ 7   = {3}·
    IRQ 10  = {4}·
    IRQ 11  = {5}·
    IRQ 12  = {6}·
    IRQ 13  = {7}·
    IRQ 14  = {8}·
    IRQ 15  = {9}·

{/}

{dma} - En este campo se debe indicar el número de canal de acceso directo
a memoria (DMA) que utiliza la tarjeta de sonido.

Este campo puede tomar valores de 0 a 10, dependiendo directamente del número
de canal.

{/}

{dma2} - Algunas tarjetas de sonido tienen disponible un segundo canal de
acceso directo a memoria más rápido que el anterior, de 16 bits, denominado
comúnmente HDMA, DMA2 o DMA16.

Como el campo anterior de esta estructura, éste podrá tomar valores del 0
al 10 dependiendo del número de canal de 16 bits utilizado por la tarjeta.

{/}

{master} - Este campo contiene el volumen general o maestro de salida de la
tarjeta. Aquí se debe indicar un número entre 0 (volumen mínimo) y 15 (volumen
máximo). El valor por defecto es {15}, el volumen máximo.

Si se disminuye el volumen maestro afectará tanto al volumen de los efectos
de sonido como al volumen de reproducción de la música de cd audio.

{/}

{sound_fx} - Este campo controla el volumen al que los efectos de sonido que
se ejecutan con la función {#159,sound()} son reproducidos.

Este volumen es independiente del utilizado con las funciones de sonido
siendo, este volumen, general para todos los efectos de sonido y el indicado
en las funciones el específico para cada sonido.

Este campo también puede oscilar entre 0 (volumen mínimo) y 15 (volumen
máximo), siendo el valor por defecto el volumen máximo.

{/}

{cd_audio} - Este campo controla el volumen de la música que será reproducida
a partir de pistas de audio de un CD ROM o de un Compact Disc.

Al igual que los dos campos anteriores, este campo también puede oscilar
entre 0 (volumen mínimo) y 15 (volumen máximo) siendo el valor por defecto
el volumen máximo.

{/}Ver: {#1200,Datos globales} - {#175,reset_sound()} - {#178,set_volume()}

# ─────────────────────────────────────────────────────────────────────────────

{.1105,GLOBAL timer[]}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{timer[9];} // Contadores de tiempo{/}.

Ésta es una tabla global con 10 posiciones, desde {timer[0]} hasta {timer[9]},
y cada una de estas 10 posiciones es un contador de {centésimas de segundo} que
se va incrementando automáticamente.

Al comienzo del programa estos 10 contadores serán puestos a cero. Se utilizan
para cronometrar tiempos dentro de un programa, para lo que pueden ser puestos
a cero en cualquier momento.

Se dispone de 10 contadores para que el usuario pueda dedicar cada uno de ellos
a realizar una cuenta diferente dentro del juego; es indiferente cuáles de los
10 contadores se utilicen. Normalmente, si el programa necesita un solo contador
(en la mayoría de ocasiones) se suele utilizar el número {0} ({timer[0]}), ya
que el lenguaje permite omitir el cero entre corchetes en este caso, es decir,
si únicamente se necesita un contador, se puede utilizar simplemente {timer}.

Por ejemplo, para implementar un proceso que a los 5 segundos del inicio de
su ejecución (de haberlo llamado) realizara una acción determinada, se
construiría el mismo de una forma similar a ésta (utilizando, por ejemplo,
el contador timer[9]):

 {PROCESS proceso_ejemplo();}·
 {BEGIN}·
     {timer[9]=0;}·
     // ...·
     {LOOP}·
         {IF (timer[9]>=500)}·
             // Acción a realizar ...·
         {END}·
         // ...·
         {FRAME;}·
     {END}·
 {END}·

{/}

{Nota 1:} Como la cuenta se realiza en centésimas de segundo, en cada imagen del juego
estos contadores se pueden incrementar en {1} centésima, {2}, {3}, {4}, etc., es decir,
en un ejemplo como el anterior no se puede esperar a que {timer[9]} sea
exactamente igual a {500}, ya que una imagen podría indicar {497} centésimas
transcurridas (desde su puesta a cero con {timer[9]=0;}) y la siguiente
imagen {502} centésimas, sin haber pasado por el valor {500}.

{/}

{Nota 2:} Es también importante resaltar que se deben tomar precauciones para que no
haya en el programa varios procesos utilizando el mismo contador para diferentes
fines.

Si, por ejemplo, se creara un {proceso_ejemplo()} (como el anterior), en cada imagen del juego
éstos no llegarían nunca a ejecutar la acción de los cinco segundos, ya que
cada uno de ellos pondría a {0} el contador {timer[9]} al comienzo de su
ejecución invalidando, de esta forma, la cuenta de los procesos anteriores.

Teniendo en cuenta que el contador timer[9] es {#1006,GLOBAL}, es decir, es el mismo para todos los
procesos del juego, si un proceso lo pone a {0}, lo pondrá a {0} para
el resto de los procesos.

{/}

{Nota 3:} Por último se debe tener cuidado con las condiciones similares
a la del ejemplo anterior ({IF (timer[9]>=500) ... }) ya que estas condiciones
no se activarán únicamente {una vez a los 5 segundos}, sino que se activarán
{todas las veces después de los primeros 5 segundos}.

Para poder comprender mejor el problema, se muestra a continuación un proceso
que realiza una acción, {únicamente una vez}, a los cinco segundos de haberse
iniciado su ejecución.

 {PROCESS proceso_ejemplo();}·

 {PRIVATE}·
     {acción_realizada=FALSE;}·

 {BEGIN}·
     {timer[9]=0;}·
     // ...·
     {LOOP}·
         {IF (timer[9]>=500) AND NOT acción_realizada)}·
             // Acción a realizar ...·
             {acción_realizada=TRUE;}·
         {END}·
         // ...·
         {FRAME;}·
     {END}·
 {END}·

Se utiliza una variable privada denominada {acción_realizada} que, en un
principio, será {falsa}. Para realizar la acción ahora se requerirá que
hayan pasado más de cinco segundos y que {no se haya realizado ya la acción}.
Tras realizar ésta, se pondrá por tanto la variable {acción_realizada} a {cierto}.

Para que el ejemplo anterior ejecutara la acción {cada cinco segundos}
(indefinidamente), bastaría con volver a poner la sentencia {timer[9]=0;}
tras la {acción a realizar}, no siendo necesaria, en esta caso, la variable
privada {acción_realizada} ya que se necesitarían otros {5} segundos para
que {timer[9]} fuera otra vez mayor o igual que {500}.

{/}Ver: {#1200,Datos globales}

# ─────────────────────────────────────────────────────────────────────────────

{.1106,GLOBAL text_z}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{text_z=-256;} // Plano de profundidad de los textos{/}.

En esta variable global se indica el plano de profundidad en el que deben
aparecer los textos en pantalla, esto es, qué debe aparecer por encima de
los textos y qué por debajo.

Los planos de profundidad pueden ser cualquier número entero dentro
del rango ({#1177,min_int} ... {#1178,max_int}) y, cuanto mayor sea el
número, más al fondo se situará el texto o gráfico.

Los gráficos de los procesos tienen su variable {#1125,local z} a {0} por
defecto, los textos {text_z} a{ -256} y el puntero del ratón tiene
{#1100,mouse.z} a{ -512} por defecto.

Esto quiere decir que, por defecto, si no se no modifican estos valores,
aparecerán los textos sobre los gráficos de los procesos y el puntero del
ratón sobre los textos.

Si, por ejemplo, se quisiera que aparecieran los textos sobre el puntero
del ratón (al revés de lo establecido por defecto), se podrían hacer dos cosas:

{a)} Situar el plano del puntero más abajo que el plano de los textos (un
número mayor), como por ejemplo: {mouse.z=-200;} (ya que{ -200} es un número
mayor que{ -256}).

{b)} Situar el plano de los textos más arriba que el plano del puntero, como
por ejemplo {text_z=-600;} ya que{ -600} es un número menor que{ -512} y,
por tanto, un plano de profundidad menor (menos profundo).

{/}

{Nota 1:} La variable {text_z} es {#1006,GLOBAL} para todos los textos, es decir, no
se pueden definir textos en diferentes planos de profundidad.

{Nota 2:} Los textos únicamente pueden imprimirse con la función {#171,write()}
(textos alfanuméricos) o con la función {#172,write_int()} (valores numéricos de variables).

{/}Ver: {#1200,Datos globales} - {#171,write()} - {#172,write_int()}

# ─────────────────────────────────────────────────────────────────────────────

{.1107,GLOBAL fading}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{fading=FALSE;} // Indicador de fundido de pantalla{/}.

Esta variable global indica si se está realizando un fundido de pantalla
(una variación gradual de la paleta de colores del juego) en un momento
determinado, cuyo valor será:

{#1152,false (0)} - Si {no} se está realizando un fundido.

{#1151,true (1)} - Si se está realizando un fundido.

La finalidad de esta variable es poder determinar cuándo ha finalizado un
fundido de pantalla iniciado con las funciones {#110,fade()} o {#112,fade_on()}.

Al utilizar estas funciones se iniciará un fundido de los colores de la paleta
que se irán acercando gradualmente a los colores definitivos en las siguientes
imágenes del juego, es decir, cada sentencia {#1029,FRAME} se realizará una
parte del fundido.

Cuando se inicie un fundido, la variable {fading} pasará automáticamente a
valer {cierto} (1) y al finalizar éste, volverá de nuevo a su valor original,
{falso} (0).

{/}

{Nota 1:} Generalmente, esta variable se utiliza para controlar a la función {#110,fade()},
y comprobar si ha terminado de ejecutarse (si ha terminado de realizarse
el fundido); cuando se quiera, por ejemplo, detener la ejecución del programa
hasta que finalice el fundido, lo que se puede hacer con una sentencia como
la siguiente (justo a continuación de la llamada a la función {#110,fade()}):

  {WHILE (fading)}·
      {FRAME;}·
  {END}·

Literalmente esta sentencia define: "{mientras continúe realizándose el
fundido, se debe visualizar otra nueva imagen}".

{Nota 2:} Todos los programas realizan un fundido ({#112,fade_on()}) al
inicio de su ejecución (automáticamente), por lo que esta variable se
pondrá a {cierto (1)} al inicio de todos los programas hasta que finalice este
fundido inicial (mientras dure el "{encendido}" de pantalla).

{/}Ver: {#1200,Datos globales} - {#110,fade()} - {#112,fade_on()}

# ─────────────────────────────────────────────────────────────────────────────

{.1108,GLOBAL shift_status}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{shift_status=0;} // Estado de las teclas especiales{/}.

En esta variable global predefinida se indica el estado de distintas
teclas especiales como pueden ser las teclas [{ALT}], [{CONTROL}], etc.

Cada una de estas teclas tiene asignado un código que es el siguiente:

Tecla SHIFT o mayúsculas derecho          = {1}·
Tecla SHIFT o mayúsculas izquierdo        = {2}·
Teclas CONTROL                            = {4}·
Teclas ALT y/o ALT GR                     = {8}·
Tecla BLOQ DESPL o bloqueo desplazamiento = {16}·
Tecla BLOQ NUM o de bloque numérico       = {32}·
Tecla BLOQ MAYUS o bloqueo de mayúsculas  = {64}·
Tecla INSERT o inserción                  = {128}·

La variable {shift_status} contendrá la {suma de todos los códigos de las
teclas que estén pulsadas o activadas}.

Por ejemplo, si estuviera pulsada la tecla [{ALT}] y activada la tecla
[{BLOQ MAYUS}], la variable {shift_status} tendría el valor {72} (8+64).

Para comprobar si una tecla como [{ALT}] está pulsada, no se puede comprobar
que {shift_status} sea igual a {8}, ya que ésto implicaría que [{ALT}] es
la {única} tecla especial que está pulsada o activada.

Para realizar esta comprobación correctamente se debería realizar de la
siguiente forma:

  {IF (shift_status AND 8 == 8)}·
      // Está pulsada la tecla [ALT] ...·
  {END}·

{/}

{Nota:} Normalmente, para comprobar si una tecla está pulsada, se utiliza la
función {#128,key()}. Pero con esta función no se puede determinar si
teclas como {BLOQ MAYUS} están activadas, únicamente si están pulsadas o no.

Existen dos variables que contienen el código de la última tecla que se ha pulsado;
{#1110,scan_code} (código {scan} de la última tecla pulsada) y {#1109,ascii}
(código {ascii} de la última tecla pulsada).

{/}Ver: {#1200,Datos globales} - {#128,key()} - {#1109,ascii} - {#1110,scan_code}

# ─────────────────────────────────────────────────────────────────────────────

{.1109,GLOBAL ascii}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{ascii=0;} // Código ASCII de la última tecla pulsada{/}.

Esta variable global indica siempre el código ASCII de la {última tecla
pulsada} en la última imagen del juego.

La variable {ascii} estará a {0} si no se ha pulsado ninguna tecla en la
imagen anterior del juego.

Los códigos ASCII son una relación de carácteres (letras, números y símbolos)
enumerados del {0} al {255} que se han convertido en estándar. Los códigos
inferiores al 32 son los denominados carácteres de control, del 32 al
127 son el juego de carácteres internacional y, a partir del número 128,
aparece el juego de carácteres extendido (según el estándar de PC). A
continuación, se muestran los carácteres ASCII internacionales y extendidos.

{Resumen de códigos ASCII estándar del PC.}{/}033 21{ !}│097 61{ a}│161 A1{ í}│225 E1{ ß}·
034 22{ "}│098 62{ b}│162 A2{ ó}│226 E2{ Γ}·
035 23{ #}│099 63{ c}│163 A3{ ú}│227 E3{ π}·
036 24{ $}│100 64{ d}│164 A4{ ñ}│228 E4{ Σ}·
037 25{ %}│101 65{ e}│165 A5{ Ñ}│229 E5{ σ}·
038 26{ &}│102 66{ f}│166 A6{ ª}│230 E6{ µ}·
039 27{ '}│103 67{ g}│167 A7{ º}│231 E7{ τ}·
040 28{ (}│104 68{ h}│168 A8{ ¿}│232 E8{ Φ}·
041 29{ )}│105 69{ i}│169 A9{ ⌐}│233 E9{ Θ}·
042 2A{ *}│106 6A{ j}│170 AA{ ¬}│234 EA{ Ω}·
043 2B{ +}│107 6B{ k}│171 AB{ ½}│235 EB{ δ}·
044 2C{ ,}│108 6C{ l}│172 AC{ ¼}│236 EC{ ∞}·
045 2D{ -}│109 6D{ m}│173 AD{ ¡}│237 ED{ φ}·
046 2E{ .}│110 6E{ n}│174 AE{ «}│238 EE{ ε}·
047 2F{ /}│111 6F{ o}│175 AF{ »}│239 EF{ ∩}·
048 30{ 0}│112 70{ p}│176 B0{ ░}│240 F0{ ≡}·
049 31{ 1}│113 71{ q}│177 B1{ ▒}│241 F1{ ±}·
050 32{ 2}│114 72{ r}│178 B2{ ▓}│242 F2{ ≥}·
051 33{ 3}│115 73{ s}│179 B3{ │}│243 F3{ ≤}·
052 34{ 4}│116 74{ t}│180 B4{ ┤}│244 F4{ ⌠}·
053 35{ 5}│117 75{ u}│181 B5{ ╡}│245 F5{ ⌡}·
054 36{ 6}│118 76{ v}│182 B6{ ╢}│246 F6{ ÷}·
055 37{ 7}│119 77{ w}│183 B7{ ╖}│247 F7{ ≈}·
056 38{ 8}│120 78{ x}│184 B8{ ╕}│248 F8{ °}·
057 39{ 9}│121 79{ y}│185 B9{ ╣}│249 F9{ ∙}·
058 3A{ :}│122 7A{ z}│186 BA{ ║}│250 FA{ ∙}·
059 3B{ ;}│123 7B{ {{}}│187 BB{ ╗}│251 FB{ √}·
060 3C{ <}│124 7C{ |}│188 BC{ ╝}│252 FC{ ⁿ}·
061 3D{ =}│125 7D{ {}}}│189 BD{ ╜}│253 FD{ ²}·
062 3E{ >}│126 7E{ ~}│190 BE{ ╛}│254 FE{ ■}·
063 3F{ ?}│127 7F{ }│191 BF{ ┐}│255 FF{  }·
064 40{ @}│128 80{ Ç}│192 C0{ └}·
065 41{ A}│129 81{ ü}│193 C1{ ┴}·
066 42{ B}│130 82{ é}│194 C2{ ┬}·
067 43{ C}│131 83{ â}│195 C3{ ├}·
068 44{ D}│132 84{ ä}│196 C4{ ─}·
069 45{ E}│133 85{ à}│197 C5{ ┼}·
070 46{ F}│134 86{ å}│198 C6{ ╞}·
071 47{ G}│135 87{ ç}│199 C7{ ╟}·
072 48{ H}│136 88{ ê}│200 C8{ ╚}·
073 49{ I}│137 89{ ë}│201 C9{ ╔}·
074 4A{ J}│138 8A{ è}│202 CA{ ╩}·
075 4B{ K}│139 8B{ ï}│203 CB{ ╦}·
076 4C{ L}│140 8C{ î}│204 CC{ ╠}·
077 4D{ M}│141 8D{ ì}│205 CD{ ═}·
078 4E{ N}│142 8E{ Ä}│206 CE{ ╬}·
079 4F{ O}│143 8F{ Å}│207 CF{ ╧}·
080 50{ P}│144 90{ É}│208 D0{ ╨}·
081 51{ Q}│145 91{ æ}│209 D1{ ╤}·
082 52{ R}│146 92{ Æ}│210 D2{ ╥}·
083 53{ S}│147 93{ ô}│211 D3{ ╙}·
084 54{ T}│148 94{ ö}│212 D4{ ╘}·
085 55{ U}│149 95{ ò}│213 D5{ ╒}·
086 56{ V}│150 96{ û}│214 D6{ ╓}·
087 57{ W}│151 97{ ù}│215 D7{ ╫}·
088 58{ X}│152 98{ ÿ}│216 D8{ ╪}·
089 59{ Y}│153 99{ Ö}│217 D9{ ┘}·
090 5A{ Z}│154 9A{ Ü}│218 DA{ ┌}·
091 5B{ [}│155 9B{ ¢}│219 DB{ █}·
092 5C{ \}│156 9C{ £}│220 DC{ ▄}·
093 5D{ ]}│157 9D{ ¥}│221 DD{ ▌}·
094 5E{ ^}│158 9E{ ₧}│222 DE{ ▐}·
095 5F{ _}│159 9F{ ƒ}│223 DF{ ▀}·
096 60{ `}│160 A0{ á}│224 E0{ α}{/}

Un código ASCII hace referencia, por tanto, al {carácter que ha sido producido
con la última pulsación del teclado} (o combinación de pulsaciones, en casos
como los de las letras acentuadas).

{/}

{Importante:} Existe otra variable global predefinida, denominada {#1110,scan_code}, que
también contiene el código de la última tecla pulsada pero, a diferencia de {ascii},
ésta última guarda el {código de rastreo} (scan code) de la tecla, es decir,
indica {qué tecla ha sido pulsada} y no {qué carácter ha sido generado} por
la misma (como {ascii}).

Existe una serie de constantes que designan estos {#1176,códigos de teclas} (códigos
de rastreo del teclado). Acceda a la ayuda sobre estos {#1176,códigos de teclas}
para observar, además, un {programa ejemplo} con las variables {ascii} y {scan_code}.

Normalmente, para comprobar si una tecla está siendo pulsada, se utiliza
simplemente la función {#128,key()} del lenguaje, que recibe como parámetro
uno de estos {#1176,códigos de teclas}, y devuelve {0} si la tecla no está
pulsada o {1} cuando sí lo está.

{/}Ver: {#1200,Datos globales} - {#1110,scan_code} - {#128,key()}

# ─────────────────────────────────────────────────────────────────────────────

{.1110,GLOBAL scan_code}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{scan_code=0;} // Código de rastreo de la última tecla pulsada{/}.

Esta variable global indica siempre el código de rastreo (scan code) de la
{última tecla pulsada} en la última imagen del juego.

La variable {scan_code} estará a {0} si no se ha pulsado ninguna tecla en la
imagen anterior del juego.

Se utiliza muchas veces esta variable para esperar en un programa a que el
usuario pulse una tecla (cualquiera), con una sentencia como la siguiente:

  {WHILE (scan_code == 0)}·
      {FRAME;}·
  {END}·

Esta sentencia indica que mientras no se haya pulsado una tecla en la
imagen anterior (mientras {scan_code} sea igual a {0}), se deben seguir
visualizando imágenes del juego.

Los {códigos de rastreo} son simplemente una relación numérica de las
teclas del PC; estos códigos pueden variar ligeramente (en alguna tecla)
de un teclado a otro, ya que hay teclados de diferentes idiomas, con un
número variado de teclas, etc.

Sin embargo, se mantienen constantes casi todos los códigos de las principales
teclas. Hay predefinida una lista de constantes (sinónimos para estos códigos)
en el lenguaje que se puede ver accediendo a la ayuda sobre {#1176,códigos de
teclas} (o códigos de rastreo del teclado); son, precisamente, estos valores
numéricos los que serán asignados a la variable {scan_code} cuando las
respectivas teclas sean pulsadas en el programa.

{/}

{Importante:} Existe otra variable global predefinida, denominada {#1109,ascii}, que
también contiene el código de la última tecla pulsada pero, a diferencia de {scan_code},
ésta última guarda el {código ASCII} (carácter) generado por la tecla, es decir,
indica {qué carácter ha generado la última tecla pulsada} y no qué {tecla
ha sido pulsada} (como {scan_code}).

Acceda a la ayuda sobre los {#1176,códigos de teclas} para observar un
{programa ejemplo} con las variables {ascii} y {scan_code}.

Normalmente, para comprobar si una tecla está siendo pulsada se utiliza
simplemente la función {#128,key()} del lenguaje, que recibe como parámetro
uno de estos {#1176,códigos de teclas}, y devuelve {0} si la tecla no está
pulsada o {1} cuando si lo está.

{/}Ver: {#1200,Datos globales} - {#1109,ascii} - {#128,key()}

# ─────────────────────────────────────────────────────────────────────────────

{.1111,GLOBAL joy_filter}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{joy_filter=10;} // Filtro aplicado al joystick{/}.

Esta variable global se utiliza para definir el filtro aplicado a las
coordenadas leídas del joystick.

Se define como un porcentaje de {0 %} a {99 %}; por defecto {joy_filter}
valdrá {10} (se aplicará un filtro de un 10%).

La utilidad de aplicar este filtro a las coordenadas del joystick es para
suavizar los movimientos del mismo y evitar posibles "{picos}" en la lectura
de las coordenadas; dichas coordenadas del joystick se deben obtener con la
función {#122,get_joy_position()}. La variable {joy_filter} únicamente será
de utilidad cuando se esté utilizando ésta última función.

Cuanto mayor sea el filtro aplicado más se suavizarán los movimientos del
mismo, pero también se retardará su respuesta.

Dado que la función cometida por este "{filtro}" es algo difícil de comprender,
se muestra a continuación un ejemplo.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_joy_filter;
BEGIN
    write(0, 0, 0, 0, "joy_filter=");
    write_int(0, 70, 0, 0, offset joy_filter);
    write(0, 160, 180, 1, "El gráfico se muestra en las coordenadas del joystick");
    write(0, 160, 190, 1, "Utilice las teclas arriba/abajo para variar el filtro");
    load_fpg("help\help.fpg");
    put_screen(0, 1);
    graph=100;
    LOOP
        IF (scan_code==_up AND joy_filter<99)
            joy_filter++;
        END
        IF (scan_code==_down AND joy_filter>0)
            joy_filter--;
        END
        x=get_joy_position(0);
        y=get_joy_position(1);
        FRAME;
    END
END
{-}

Este programa imprime el gráfico de una bola en las coordenadas devueltas
por el joystick principal mediante la función {#122,get_joy_position()}.

Se puede observar como, para valores pequeños de {joy_filter}, se producen
muchos "{picos}" (irregularidades) en la lectura, y como para valores muy
grandes (como 95%) se produce una lectura de las coordenadas mucho más suave
y regular, pero ligeramente retardada.

{Nota:} Es imprescindible tener un joystick (o gamepad) conectado al ordenador
para que esta variable tenga utilidad. Si el joystick se conecta durante la
ejecución del programa, el sistema no lo detectará (debe estar conectado desde
el inicio). Ver la variable global {#1112,joy_status}.

{/}Ver: {#1200,Datos globales} - {#122,get_joy_position()} - {#1112,joy_status}

# ─────────────────────────────────────────────────────────────────────────────

{.1112,GLOBAL joy_status}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{joy_status=0;} // Estado del joystick{/}

En esta variable gobal se indica el estado del joystick (o gamepad) conectado
al ordenador. Los valores que toma esta variable por defecto son:

{0} - Si el sistema de lectura del joystick está desactivado. Este valor
quiere decir que no se ha encontrado un joystick conectado al ordenador al
inicio de la ejecución del programa, o bien que éste ha sido desconectado.

{1} - Si el sistema de lectura del joystick está activo. Éste es el valor
inicial por defecto, pero si se desconecta el joystick (o no se encuentra
ninguno conectado), se desactivará el sistema de lectura (indicando un {0}
en la variable joy_status).

Si el sistema está desactivado, se puede volver a activar simplemente asignando
de nuevo un {1} a {joy_status} (con la sentencia {joy_status=1;}), pero si
pasado un tiempo límite no se detecta un joystick, el sistema se volverá
a desactivar.

{/}

Existe un {modo especial} en el que el sistema de lectura del joystick {no
se desactivará nunca}; este modo se define simplemente {asignando un 2 a
joy_status}.

  {joy_status=2;} // Activa modo especial·

No obstante, se debe tener cuidado ya que si el sistema de lectura del
joystick está activado de este modo, sin haber un joystick conectado al ordenador, {puede
ralentizarse la ejecución del juego}.

{/}

{Nota:} La lectura del joystick suele realizarse en los programas accediendo
a la {#1103,estructura global joy} que indica, siempre, la dirección del mismo
y el estado de sus botones (si están pulsados o no).

{/}Ver: {#1200,Datos globales} - {#1103,Estructura joy} - {#1111,joy_filter}

# ─────────────────────────────────────────────────────────────────────────────

{.1113,GLOBAL restore_type}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{restore_type=complete_restore;} // Tipo de restauración{/}.

Esta variable global indica el tipo de restauración que se debe realizar
tras cada imagen en la pantalla.

Se llama {restauración del fondo} a recuperar las zonas de pantalla
en las que se han pintado gráficos o escrito textos en la imagen anterior,
es decir, "{despintar}" los gráficos y "{desescribir}" los textos (borrarlos).

Hay tres tipos de restauración aplicables que se corresponden, directamente,
con tres constantes que pueden ser asignadas a la variable {restore_type}.

{#1172,no_restore}       - El más rápido, no se restaura el fondo (-1)·
{#1173,partial_restore}  - Medio, restauraciones parciales (0)·
{#1174,complete_restore} - El más lento, restauración completa (1)·

Por defecto, el valor de {restore_type} es {complete_restore}, es decir,
que si no se indica otro valor en esta variable se realizará una restauración
completa de pantalla tras cada imagen del juego.

Esta modalidad de restauración (completa) es la más lenta de las tres, por lo
que seguramente se podrá ganar velocidad de ejecución en el juego (para que vaya
más fluido en los ordenadores lentos), si se le asigna otro valor a esta variable.
Por ejemplo, para indicar una restauración parcial, se debe utilizar la siguiente
sentencia:

  {restore_type=partial_restore;}

Con ella se indicaría al gestor de procesos de DIV Games
Studio que, tras las siguientes imágenes del juego, se debe restaurar
parcialmente el fondo de la pantalla (únicamente las zonas de pantalla
sobre las que se hayan puesto gráficos o textos).

La modalidad más rápida es {no_restore} (no restaurar el fondo de la pantalla);
sin embargo, ésta es aplicable solamente cuando el juego se desarrolle dentro de
una ventana de scroll o de modo 7 que ocupe toda la pantalla. En caso
contrario los gráficos dejarán rastros (de las imágenes anteriores) al moverse
por pantalla.

Se puede cambiar la modalidad de restauración durante la ejecución de un
programa tantas veces como sea necesario, según los requerimientos de las
fases (o secciones) que se ejecuten en cada momento.

{/}

{Nota:} Existe otra variable global relacionada también con la gestión que DIV
Games Studio realiza de la pantalla; ésta es {#1114,dump_type} que define
el tipo de {volcado} de imágenes que debe realizarse (qué información
debe enviarse al monitor tras cada imagen del juego).

{/}Ver: {#1200,Datos globales} - {#1114,dump_type}

# ─────────────────────────────────────────────────────────────────────────────

{.1114,GLOBAL dump_type}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{dump_type=complete_dump;} // Tipo de volcado{/}

Esta variable global indica el tipo de volcado de imágenes a pantalla
que se debe realizar en cada imagen del juego.

Se denomina {volcado} a cuando se envían las imágenes del juego
al monitor (a la memoria de vídeo de la tarjeta gráfica).

{/}

Hay dos tipos de volcado aplicables que se corresponden, directamente,
con dos constantes que pueden ser asignadas a la variable {dump_type}.

{#1170,partial_dump} - Se realizarán {volcados parciales} si se indica
con la siguiente sentencia:

  {dump_type=partial_dump;}

En este modo, sólo se volcarán en pantalla los gráficos que se actualicen,
que hayan variado respecto a la imagen anterior. Este volcado conviene activarlo
{para ganar velocidad} cuando se programe un juego (o una sección del
mismo) sin una ventana de scroll o modo 7 que ocupe toda la pantalla,
es decir, cuando el juego muestre movimientos de gráficos sobre un
fondo fijo, o bien cuando las ventanas activas de scroll o modo 7 sean
más pequeñas que la pantalla.

{#1171,complete_dump} - Se realizarán {volcados completos} si se indica
con la siguiente sentencia:

  {dump_type=complete_dump;}

En este modo, se volcará toda la pantalla sin importar si los gráficos han
cambiado o no. Éste es más lento que el {volcado parcial}, sin embargo es
el que se debe utilizar cuando el juego tenga una ventana de scroll o modo 7
que ocupe toda la pantalla.

{/}

Por defecto, el valor de {dump_type} es {complete_dump}, es decir,
que si no se indica otro valor en esta variable se realizarán {volcados
completos} de la pantalla tras cada imagen del juego (lo que suele ser
{más lento} que realizar volcados parciales).

Se puede cambiar la modalidad de volcado durante la ejecución de un
programa tantas veces como sea necesario, según los requerimientos de las
fases (o secciones) que se ejecuten en cada momento.

{/}

{Nota:} Existe otra variable global relacionada también con la gestión que DIV
Games Studio realiza de la pantalla; ésta es {#1113,restore_type} que define
el tipo de {restauración} que debe realizarse en la pantalla tras cada imagen
del juego (qué gráficos o qué textos deben ser borrados).

{/}Ver: {#1200,Datos globales} - {#1113,restore_type}

# ─────────────────────────────────────────────────────────────────────────────

{.1115,GLOBAL max_process_time}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{max_process_time=500;} // Tiempo máximo de ejecución{/}.

Los programas están dotados de un mecanismo {anti-bloqueo} que
hará que el gestor de procesos de DIV Games Studio interrumpa su
ejecución cuando un proceso supere el {tiempo máximo de ejecución}
en una imagen del juego.

Este tiempo máximo es el que se indica en la variable global
{max_process_time} en {centésimas de segundo}; su valor por
defecto es de {500 centésimas} ({5 segundos}).

Es decir, cuando un proceso tarde más tiempo del aquí indicado en
ejecutar una sentencia {#1029,FRAME} (que indica que el proceso
está ya preparado para la siguiente imagen del juego), se producirá
un error de ejecución.

{Nota:} La utilidad que tiene la posibilidad de cambiar esta variable, asignándole
un nuevo valor, es para que en los programas en los que exista un
proceso, que deba estar realizando cálculos durante bastante tiempo,
no se produzca este error.

Para indicar al gestor de procesos, por ejemplo, que no se debe
interrumpir un proceso, a no ser que esté más de 30 segundos de
ejecución en una imagen se debe utilizar una sentencia como la
siguiente:

  {max_process_time=3000;}

Ya que 30 segundos son 3000 centésimas de segundo.

{/}

{Importante:} Se debe tener en cuenta que no todos los ordenadores
tardan lo mismo en realizar los cálculos del programa, por lo que hay que definir este valor
con cierto margen, para que no se supere el {tiempo máximo de ejecución}
cuando el juego sea ejecutado en ordenadores más lentos.

{/}Ver: {#1200,Datos globales} - {#1029,Sentencia FRAME}

# ─────────────────────────────────────────────────────────────────────────────

{.1116,LOCAL STRUCT reserved}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{STRUCT reserved;}·
    {process_id;}    // Identificador del proceso·
    {id_scan;}       // Indice de procesos·
    {process_type;}  // Tipo de proceso·
    {type_scan;}     // Indice de tipos·
    {status;}        // Estado del proceso·
    {param_offset;}  // Dirección de los parámetros·
    {program_index;} // Contador de programa·
    {is_executed;}   // proceso ejecutado·
    {is_painted;}    // proceso pintado·
    {distance_1;}    // Reservado modo 7·
    {distance_2;}    // Reservado modo 7·
    {frame_percent;} // Porcentaje de imagen·
    {box_x0, box_y0;} // Inicio del gráfico del proceso·
    {box_x1, box_y1;} // Final del gráfico del proceso·
{END}·

En esta estructura se guardan distintas {variables de uso interno}
(utilizadas por el {gestor de procesos de DIV Games Studio}).

Son variables locales reservadas para el sistema. No es necesario
conocer estas variables ya que la gran mayoría no son de utilidad
en la creación de programas.

{Importante:} Modificar los valores de estas variables provocará,
muy probablemente, un {bloqueo} del ordenador, un funcionamiento
indebido del {gestor de procesos} o problemas al utilizar muchas
de las funciones internas. No se asume ninguna responsabilidad
por tanto, sobre los posibles problemas derivados del uso indebido
de la estructura {reserved}.

{/}

Se mostrará, por tanto, una {breve descripción} de cada uno de estos
campos, únicamente con fines documentativos.

{process_id} - {#1039,Código identificador} del proceso; este valor se
obtiene normalmente con la palabra reservada {#1092,ID} y no se
debe modificar el valor de este campo.

{id_scan} - Se utiliza internamente al detectar las colisiones para
guardar registro del {#1039,código identificador} del último proceso que ha
colisionado con el proceso actual.

{process_type} - Tipo del proceso actual, que se
obtiene normalmente con el operador {#1042,TYPE}, indicando el nombre
del proceso a continuación (ver {#1042,Tipos de procesos}).

{type_scan} - Se utiliza internamente para detectar colisiones
u obtener códigos identificadores de procesos de un tipo determinado.

{status} - Estado actual del proceso. Los valores que puede
adoptar este campo son los siguientes:

  {0} - proceso inexistente.·
  {1} - proceso que ha recibido una señal {s_kill}.·
  {2} - proceso vivo o despierto (s_wakeup).·
  {3} - proceso dormido (s_sleep).·
  {4} - proceso congelado (s_freeze).·

{param_offset} - Dirección de la memoria del ordenador en la que
están situados los parámetros que ha recibido el proceso.

{program_index} - Contador de programa. Dirección de la memoria del
ordenador en la que se encuentra la primera sentencia que debe
ejecutar el proceso en la siguiente imagen.

{is_executed} - Indica si este proceso ha sido ya ejecutado en la
imágen actual.

{is_painted} - Indica si el gráfico del proceso ha sido ya pintado
en la imagen actual del juego.

{distance_1} - Distancia vertical del proceso (reservado para procesos
que se visualicen en una ventana de modo 7).

{distance_2} - Distancia horizontal del proceso (ocurre lo mismo que en la
sentencia anterior).

{frame_percent} - Porcentaje de la siguiente imagen completado por
el proceso; éste valor será de utilidad cuando se utilice la sentencia
{#1029,FRAME} indicando un porcentaje. En caso contrario valdrá simplemente
0 (0%) cuando el proceso no ha sido ejecutado y 100 (100%) cuando ya lo
haya sido.

{box_x0, box_y0} - Coordenada superior izquierda del gráfico en la
imagen anterior del juego (donde se situó el gráfico en coordenadas
de pantalla).

{box_x1, box_y1} - Coordenada inferior derecha del gráfico en la
imagen anterior del juego.

{/}Ver: {#1201,Datos locales} - {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1117,LOCAL father}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{father;} // {#1039,Código identificador} del proceso padre{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {father}.

Esta variable contiene siempre el {#1039,código identificador} del proceso
que creó (llamó) al proceso actual (el que posee esta variable), es
decir, indica qué proceso fue el que lo invocó.

Dentro del lenguaje se denomina proceso padre al que llama a otro
proceso, y proceso hijo al que ha sido llamado. Para más información
ver las {#1041,jerarquías de procesos} en el lenguaje.

El {gestor de procesos} de DIV es el proceso denominado {div_main}
y es el encargado de crear el proceso principal del programa ({PROGRAM})
al comienzo de la ejecución del juego. Por lo tanto, éste será el padre
del programa principal, así como el padre de todos los procesos
que queden huérfanos (procesos cuyo padre haya muerto o finalizado
antes que ellos, ver {#1040,estados de un proceso}).

{/}

{Nota:} El {#1039,código identificador} del proceso hijo se indica
en la variable local predefinida {#1118,son}.

{/}Ver: {#1201,Datos locales} - {#1039,Código identificador} - {#1041,Jerarquias de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.1118,LOCAL son}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{son=0;} // {#1039,Código identificador} del proceso hijo{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {son}.

Esta variable contiene siempre el {#1039,código identificador} del
{último} proceso que ha creado (llamado) el proceso actual, es decir,
indica cuál es el {último} proceso invocado.

Dentro del lenguaje se denomina proceso padre al que llama a otro
proceso, y proceso hijo al que ha sido llamado. Para más información
ver las {#1041,jerarquías de procesos} en el lenguaje.

Esta variable estará por defecto a {0} hasta que el proceso realice
una llamada a otro proceso, momento en el cual se creará el nuevo proceso
indicando su {#1039,código identificador} en {son}.

{/}

{Nota:} El {#1039,código identificador} del proceso padre se indica
en la variable local predefinida {#1117,father}.

{/}Ver: {#1201,Datos locales} - {#1039,Código identificador} - {#1041,Jerarquías de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.1119,LOCAL smallbro}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{smallbro=0;} // {#1039,Código identificador} del hermano menor{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {smallbro}.

Esta variable contiene siempre el {#1039,código identificador} del
siguiente proceso que creó el padre del proceso actual tras él, es
decir, cuando el proceso que invocó al actual invocara a algún otro
después, esta variable indicará cuál.

A este proceso se le denomina {hermano menor} dentro del lenguaje.
Para más información ver las {#1041,jerarquías de procesos} en el lenguaje.

Esta variable estará por defecto a {0} hasta que el proceso padre
realice una llamada a otro proceso, momento en el cual se creará el
nuevo proceso (el hermano menor de éste), indicando su {#1039,código
identificador} en {smallbro} (de "small brother").

{/}

{Nota:} El {#1039,código identificador} del {hermano mayor} se indica
en la variable local predefinida {#1120,bigbro}.

{/}Ver: {#1201,Datos locales} - {#1039,Código identificador} - {#1041,Jerarquías de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.1120,LOCAL bigbro}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{bigbro=0;} // {#1039,Código identificador} del hermano mayor{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {bigbro}.

Esta variable contiene siempre el {#1039,código identificador} del
proceso que creó el padre justo antes de crear al proceso actual, es
decir, cuando el proceso que invocó al actual hubiera creado otro
antes, ésta variable indicará cuál.

A este proceso se le denomina {hermano mayor} dentro del lenguaje.
Para más información ver las {#1041,jerarquías de procesos} en el
lenguaje.

Esta variable estará a {0} si el proceso padre (el que invocó al
proceso actual) no hubiera creado ningún otro antes. En caso de
que hubiera creado uno, o más de uno, {bigbro} (de "big brother")
indicaría el {#1039,código identificador} del último de ellos.

{/}

{Nota:} El {#1039,código identificador} del {hermano menor} se indica
en la variable local predefinida {#1119,smallbro}.

{/}Ver: {#1201,Datos locales} - {#1039,Código identificador} - {#1041,Jerarquías de procesos}

# ─────────────────────────────────────────────────────────────────────────────

{.1121,LOCAL priority}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{priority=0;} // Nivel de prioridad del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {priority}.

En la preparación de cada imagen todos los procesos serán ejecutados en
el orden de prioridad establecido por la variable local {priority}.

Cuanto mayor sea el valor de {priority} en un proceso, antes será
procesado éste en cada imagen. El valor de priority puede fijarse
como cualquier número entero dentro del rango ({#1177,min_int} ...
{#1178,max_int}); por ejemplo, para establecer el nivel de prioridad
de un proceso a {10} se debe utilizar la siguiente sentencia:

  {priority=10;}

Todos los procesos activos en el programa que tengan {el mismo nivel
de prioridad} serán ejecutados en un {orden indeterminado} que,
además, puede variar de unas ejecuciones del juego a otras.

Por defecto la variable local {priority} estará inicializada a {0}
en todos los procesos creados en el programa, por lo que éstos
podrán ser ejecutados en cualquier orden, si no se define el valor
de esta variable.

Si se fija la {priority} de un solo proceso a un
número positivo, como 1, éste será ejecutado antes que el resto
de los procesos, y si se fija a un número negativo, como -1, entonces
será ejecutado tras el resto (suponiendo que la variable {priority}
del resto no se ha modificado, por lo que sigue valiendo {0}).

{Cuando se debe fijar la prioridad de los procesos}{/}

Cuando un proceso necesite utilizar en sus cálculos datos de otro
proceso, suele ser conveniente que se ejecute tras él, definiendo
su prioridad más baja, para que al leer los datos del otro proceso,
éstos ya estén actualizados.

Por ejemplo, si el proceso {B} debe situar su gráfico 8 puntos más
abajo que el gráfico del proceso {A}, se debe fijar la prioridad
de {A} mayor que la de {B}, para que éste se ejecute primero.

De esta forma, cuando el proceso {B} obtenga su coordenada {y} sumando
8 a la del proceso {A}, se realice este cálculo con la coordenada {y} del proceso {A}
ya actualizada para la siguiente imágen (para asegurar que en cada imagen
primero se fijará la coordenada {y} del proceso {A} y después la
del proceso {B}).

Para conseguir ésto, como ambas prioridades estarán por defecto a {0}, bastaría con
definir la prioridad de {A} como {1}, o bien definir la prioridad
de {B} como{ -1}.

{/}

{Nota:} El nivel de prioridad del proceso no tiene nada que ver
con el plano de profundidad en el que aparece su gráfico en pantalla,
ya que éste se indica en la variable {#1125,local z}. Es decir, que
un gráfico se procese antes no implica que su gráfico se pinte antes.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1122,LOCAL ctype}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{ctype=c_screen;} // Sistema de coordenadas{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {ctype}.

En esta variable se indica el {sistema de coordenadas} utilizado por
el proceso, es decir, cómo deben ser interpretadas las coordenadas
del proceso (contenidas en las variables locales {#1123,x} e {#1124,y}).

Se pueden utilizar tres sistemas de coordenadas diferentes,
que se corresponden directamente con tres constantes que pueden ser asignadas
a la variable {ctype}.

  {#1167,c_screen} - Coordenadas de pantalla·
  {#1168,c_scroll} - Coordenadas de scroll·
  {#1169,c_m7}     - Coordenadas de modo 7·

{El valor por defecto de ctype es} {#1167,c_screen}, el utilizado para que
las coordenadas del gráfico del proceso se interpreten como referidas
a la pantalla, donde la esquina superior izquierda es la (0, 0).

Se asignará {#1168,c_scroll} a {ctype} con la siguiente sentencia:

 {ctype=c_scroll;}

Para que las coordenadas del
gráfico del proceso se interpreten como referidas a una ventana de
scroll, a coordenadas sobre el gráfico del primer plano.

Se asignará {#1169,c_m7} a {ctype} con la siguiente sentencia:

 {ctype=c_m7;}

Para que las coordenadas del
gráfico del proceso se interpreten como referidas a una ventana de
modo 7, a coordenadas sobre el gráfico principal, abatido tridimensionalmente
en dicha ventana.

{/}

{Nota:} Existe otra variable local que también afecta al modo en el
que deben ser interpretadas las coordenadas del proceso; ésta es
{#1135,resolution} y establece la resolución (escala) en la que se
definen las coordenadas.

{/}Ver: {#1201,Datos locales} - {#1167,c_screen} - {#1168,c_scroll} - {#1169,c_m7}

# ─────────────────────────────────────────────────────────────────────────────

{.1123,LOCAL x}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{x=0;} // Coordenada horizontal del gráfico{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {x}.

La variables locales {x} e {#1124,y} de los procesos definen dónde
debe situarse el gráfico de los mismos (definido en la variable local
{#1126,graph}).

La variable local {x} define la {coordenada horizontal} del proceso,
que se puede definir como un número entero dentro del rango ({#1177,min_int} ...
{#1178,max_int}), situándose las coordenadas positivas hacia la derecha
y las negativas hacia la izquierda.

Por defecto, estas coordenadas se especificarán en {puntos} (píxeles),
referidos a coordenadas de pantalla, donde la esquina superior izquierda
es el punto situado en ({0}, {0}).

{Tipo de coordenadas.}{/}

Hay varios sistemas de coordenadas que pueden ser utilizados por los
procesos y que se definen con la variable local {#1122,ctype}, el
sistema por defecto son las coordenadas relativas a la pantalla.

{Resolución de las coordenadas.}{/}

La variable local {#1135,resolution} indica la precisión de las coordenadas
del proceso; por defecto, esta variable valdrá {0} y las coordenadas ({x}, {#1124,y})
se especifican en puntos.

Cuanto mayor sea el valor de {#1135,resolution}, más pequeña (y precisa) será
la unidad en la que se interpretan las coordenadas, a continuación se
muestran algunos ejemplos:

{resolution=1;} - Las coordenadas se especifican en puntos.

{resolution=10;} - Se especifican en décimas de puntos.

{resolution=100;} - Se especifican en centésimas de puntos.

{resolution=2;} - Se especifican en mitades de punto.

...

{/}

{Nota:} Se puede definir para cada proceso un tipo y resolución de coordenadas
diferente, así como cambiarlos en tiempo de ejecución cuando sea
necesario.

{/}

{Importante:} Cuando se sitúa un gráfico en unas coordenadas determinadas,
normalmente será el {centro} del gráfico el que se sitúe en dichas
coordenadas.

Esto se puede cambiar definiendo en el {editor gráfico} el {#1136,punto
de control} número {0} del gráfico del proceso (cuyo {código de gráfico}
se indica en la variable {#1126,graph}).

Si se ha definido el punto de control, será éste el que se sitúe en
las coordenadas especificadas.

Por ejemplo, si se sitúa el punto de control {0} en la esquina
superior izquierda del gráfico y, posteriormente, se pone el gráfico
en las coordenadas (100, 100), se posicionará la esquina superior
izquierda del gráfico en dichas coordenadas.

{/}Ver: {#1201,Datos locales} - {#1122,ctype} - {#1135,resolution}

# ─────────────────────────────────────────────────────────────────────────────

{.1124,LOCAL y}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{y=0;} // Coordenada vertical del gráfico{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {y}.

La variables locales {#1123,x} e {y} de los procesos definen dónde
debe situarse el gráfico de los mismos (definido en la variable local
{#1126,graph}).

La variable local {y} define la {coordenada vertical} del proceso,
que se puede definir como un número entero dentro del rango ({#1177,min_int} ...
{#1178,max_int}), situándose las coordenadas positivas hacia abajo
y las negativas hacia arriba.

Por defecto, estas coordenadas se especificarán en {puntos} (píxeles),
referidos a coordenadas de pantalla, donde la esquina superior izquierda
es el punto situado en ({0}, {0}).

{Tipo de coordenadas.}{/}

Hay varios sistemas de coordenadas que pueden ser utilizados por los
procesos y que se definen con la variable local {#1122,ctype}, el
sistema por defecto son las coordenadas relativas a la pantalla.

{Resolución de las coordenadas.}{/}

La variable local {#1135,resolution} indica la precisión de las coordenadas
del proceso; por defecto, ésta variable valdrá {0} y las coordenadas ({#1123,x},{y})
se especifican en puntos.

Cuanto mayor sea el valor de {#1135,resolution}, más pequeña (y precisa) será
la unidad en la que se interpretan las coordenadas, a continuación se
muestran algunos ejemplos:

{resolution=1;} - Las coordenadas se especifican en puntos.

{resolution=10;} - Se especifican en décimas de puntos.

{resolution=100;} - Se especifican en centésimas de puntos.

{resolution=2;} - Se especifican en mitades de punto.

...

{/}

{Nota:} Se puede definir para cada proceso un tipo y una resolución de coordenadas
diferente, así como cambiarlos en tiempo de ejecución cuando sea
necesario.

{/}

{Importante:} Cuando se sitúa un gráfico en unas coordenadas determinadas,
normalmente será el {centro} del gráfico el que se sitúe en dichas
coordenadas.

Ésto se puede cambiar definiendo en el {editor gráfico} el {#1136,punto
de control} número {0} del gráfico del proceso (cuyo {código de gráfico}
se indica en la variable {#1126,graph}).

Si se ha definido el punto de control, será éste el que se sitúe en
las coordenadas especificadas.

Por ejemplo, si se sitúa el punto de control {0} en la esquina
superior izquierda del gráfico y, posteriormente, se pone el gráfico
en las coordenadas (100, 100), se posicionará la esquina superior
izquierda del gráfico en dichas coordenadas.

{/}Ver: {#1201,Datos locales} - {#1122,ctype} - {#1135,resolution}

# ─────────────────────────────────────────────────────────────────────────────

{.1125,LOCAL z}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{z=0;} // Plano de profundidad del gráfico del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {z}.

La variable local {z} define en qué plano de profundidad debe situarse
el gráfico del proceso en la pantalla (el gráfico se define en la variable
local {#1126,graph}). Es decir, qué debe aparecer por encima del gráfico
del proceso y qué por debajo.

Los planos de profundidad pueden ser cualquier número entero dentro
del rango ({#1177,min_int} ... {#1178,max_int}), y cuanto mayor sea el
número, más al fondo se situará el gráfico (a mayor profundidad).

{/}

Por defecto, los planos de profundidad están dispuestos de la siguiente
forma:

{ (+) Mayor profundidad}

{ +512} - Ventanas de scroll (ver {#1101,scroll[].z})·
{ +256} - Ventanas de modo 7 (ver {#1102,m7[].z})·
{  0}   - Gráficos de los procesos (local {z})·
{ -256} - Textos (ver {#1106,text_z})·
{ -512} - Puntero del ratón (ver {#1100,mouse.z})·

{ (-) Menor profundidad}

Es decir, la variable local {z} que define el plano de profundidad
de los gráficos de los procesos estará inicializada a {0}. Los gráficos
de los procesos se situarán debajo del puntero del ratón
y los textos, y sobre las ventanas de scroll y modo 7 (si no se
modifican los valores por defecto).

{/}

Todos los objetos (textos, gráficos, ventanas, ...) que se sitúen
en el mismo plano de profundidad aparecerán en pantalla (al superponerse
unos sobre otros) en un {orden indeterminado}, que puede variar de
unas ejecuciones del programa a otras.

Si se quisiera, por ejemplo, que el gráfico de un proceso apareciera
sobre todos los objetos del programa, se podría fijar para el mismo
un plano de profundidad por encima del resto (como -1000}, con la
siguiente sentencia:

  {z=-1000;}

Inicialmente, todos los procesos tienen su variable {z} igual a {0},
luego los gráficos de los procesos aparecerán en cualquier orden
si no se define en qué plano debe situarse cada uno.

Se puede variar el plano de profundidad de un proceso (asignando un
nuevo valor a su variable {z}) tantas veces como sea necesario dentro
de un programa.

Los planos de profundidad del resto de objetos (ventanas, textos
y puntero del ratón) también pueden variarse en cualquier momento
del programa.

{/}

{Nota 1:} Los procesos que pertenezcan a una {ventana de scroll} (que tengan
su variable {#1122,ctype}{=}{#1168,c_scroll}) se pintarán en el
{plano de profundidad de la ventana de scroll}; no obstante, dentro
de dicha ventana, todos los gráficos de los procesos aparecerán
{ordenados por su plano de profundidad}.

Es decir, el plano de profundidad del proceso (indicado como siempre
en la variable {z}) será entonces {relativo a la ventana de scroll}
en la que aparece el proceso (ver {#163,start_scroll()}).

{/}

{Nota 2:} Los procesos que pertenezcan a una {ventana de modo 7} (que tengan
su variable {#1122,ctype}{=}{#1167,c_m7}) aparecerán en dicha ventana
{ordenados por estricto orden de profundidad en el plano tridimensional}
ignorándose el valor de su variable local {z}.

El único sentido que tiene la variable local {z} en procesos de un
{modo 7} es definir el orden en el que deben superponerse los
procesos que estén {exactamente} en las mismas coordenadas del plano
abatido, es decir, si se sitúan dos procesos en el plano tridimensional
en las mismas coordenadas entonces se podrá, con la variable {z},
definir cuál de ellos debe aparecer sobre el otro (ver {#162,start_mode7()}).

{/}Ver: {#1201,Datos locales} - {#1100,mouse.z} - {#1101,scroll[].z} - {#1102,m7[].z} - {#1106,text_z}

# ─────────────────────────────────────────────────────────────────────────────

{.1126,LOCAL graph}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{graph=0;} // Código del gráfico del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {graph}.

Normalmente, la mayoría de procesos se corresponden con un objeto
gráfico visualizado en pantalla que se situará en las coordenadas
indicadas en las variables locales {#1123,x} e {#1123,y}. Se debe
definir qué gráfico es el correspondiente a dicho proceso asignando
un {código de gráfico} a la variable local {graph}.

Por defecto, esta variable valdrá {0} lo que implica que no se
visualizará ningún gráfico para este proceso.

Los gráficos se deben crear primero en el {editor gráfico} de DIV
Games Studio (con la opción "{Nuevo...}" del menú de mapas) y, después,
se pueden guardar en un {archivo MAP} (que contendrá este gráfico),
o en un {fichero FPG} junto a otros gráficos (se puede crear un
fichero nuevo con la opción "{Nuevo...}" del menú de ficheros).

Es decir, los gráficos utilizados en un programa pueden provenir de
un {archivo MAP} (que contiene un sólo gráfico) o de un {fichero FPG}
(que puede contener muchos gráficos).

{Nota:} Un mismo gráfico puede ser utilizado por muchos procesos a
la vez en un programa.

{Archivos MAP}{/}

Para utilizar en el programa un gráfico de un {archivo MAP} se debe
cargar este llamando a la función {#174,load_map()}, que devolverá
el {código del gráfico} que se debe ser asignado a la variable {graph}.

Normalmente se utiliza una variable {#1006,GLOBAL} para guardar este
{código de gráfico} y después se asigna ésta a la variable {graph}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_graph;

GLOBAL
    gráfico1;

BEGIN
    gráfico1=load_map("help\help.map");

    graph=gráfico1; // Se define el gráfico del proceso.

    LOOP
        x=mouse.x;
        y=mouse.y;
        FRAME;
    END
END
{-}

Si bien en el ejemplo anterior se podría haber prescindido de la variable
global {gráfico1} y haber asignado directamente el código devuelto
por la función {#174,load_map()} a la variable {graph} con la siguiente
sentencia:

  {graph=load_map("help\help.map");}

los {códigos de gráfico} que devuelve esta función son simplemente
números enteros a partir de {1000}.

{Ficheros FPG}{/}

Para incluir un gráfico que se ha realizado en el {editor gráfico}
en un {fichero FPG} de debe {arrastrar la ventana del gráfico a la
ventana del fichero} (pulsar en el gráfico, moverse hasta el fichero
y soltar), entonces el programa pedirá el {código del gráfico}, con lo que se
debe introducir aquí un número entero entre {1} y {999}.

Para utilizar entonces el gráfico en un programa, se debe primero
cargar el {fichero FPG} que lo contiene con la función {#132,load_fpg()}
y, después, asignar el {código del gráfico} a la variable {graph}.

Se muestra, a continuación, un ejemplo es necesario saber antes que
un gráfico de una {bola marrón} se introdujo en el {fichero HELP.FPG}
indicando el {código de gráfico 100}.

{#9999,Programa ejemplo:}
PROGRAM ejemplo_graph;
BEGIN
    load_fpg("help\help.fpg");

    graph=100; // Se define el gráfico del proceso.

    LOOP
        x=mouse.x;
        y=mouse.y;
        FRAME;
    END
END
{-}

Se pueden cargar {varios ficheros FPG} en un programa; en ese caso
se deberá indicar, además del {código del gráfico} en la variable local
{graph}, el {código de fichero} que devuelve la función {#132,load_fpg()}
en la variable local {#1131,file}.

Si sólo se carga un fichero ésto no será necesario, ya que la variable
{#1131,file} vale {0} por defecto en todos los procesos y {0} será siempre
el {código del primer fichero} que se cargue en el programa.

{/}

Existen más variables locales relacionadas con el gráfico de un
proceso, las principales son las siguientes:

  {graph}  - Código del gráfico·
  {#1131,file}   - Código del fichero·
  {#1123,x}, {#1124,y}   - Coordenadas del gráfico·
  {#1125,z}      - Plano de profundidad·
  {#1129,angle}  - ángulo del gráfico·
  {#1128,size}   - Tamaño del gráfico·
  {#1127,flags}  - Espejados y transparencias·
  {#1130,region} - Ventana de visualización·

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1127,LOCAL flags}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{flags=0;} // Indicador de espejados y transparencia{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {flags}.

La variable local {flags} indica los espejados y transparencias con
los que se imprimirá el gráfico del proceso; los posibles valores son:

 {0}-Gráfico normal.·
 {1}-Espejado horizontal.·
 {2}-Espejado vertical.·
 {3}-Espejado horizontal y vertical (180°).·
 {4}-Gráfico transparente.·
 {5}-Transparente y espejado horizontal.·
 {6}-Transparente y espejado vertical.·
 {7}-Transparente, espejado horizontal y vertical.·

El valor por defecto de la variable {flags} es {0}, es decir, que si
no se modifica el gráfico se mostrará opaco (sin transparencia) y
sin espejar.

Se definen a continuación los términos de {espejado} y {transparencia}:

- {Espejado horizontal}, el gráfico se invertirá horizontalmente, es
decir, si estaba mirando hacia la izquierda, mirará a la derecha y
viceversa.

- {Espejado vertical}, el gráfico se invertirá verticalmente, es
decir, si estaba mirando hacia arriba, mirará hacia abajo y
viceversa.

- {Transparencia} (o {ghost-layering}), el gráfico se mostrará semitransparente,
es decir, se podrá ver lo que haya detrás del gráfico, como si éste
fuera una cristalera de colores, en contraposición a los gráficos
opacos que se muestran normalmente.

Por ejemplo, para que el gráfico de un proceso se muestre transparente
se debe utilizar la siguiente sentencia:

  {flags=4;}

{/}

{Nota:} El gráfico de un proceso se debe indicar asignando un {código
de gráfico} a la variable local {#1126,graph}.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1128,LOCAL size}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{size=100;} // Tamaño (en porcentaje) del gráfico{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {size}.

La variable local {size} define el tamaño en el que se debe ver el
gráfico del proceso, en un porcentaje relativo a su tamaño original.

El valor por defecto de esta variable será {100} (100%) para todos
los procesos, y cuando sea modificado el gráfico se {escalará}
(reduciéndose o ampliándose) para ajustarse al nuevo tamaño.

Es decir, para mostrar el gráfico al {doble} de su tamaño se deberá
especificar un {200%}, lo que se hará con la siguiente sentencia:

  {size=200;}

Por lo tanto, si este valor es menor que {100} el gráfico se verá
más pequeño, y si es mayor, más grande.

En un principio no hay ningún límite para el tamaño del gráfico, pero
si se pone la variable local {size} a {0} (0%), entonces no se verá
el gráfico del proceso.

{/}

{Nota:} El gráfico de un proceso se debe indicar asignando un {código
de gráfico} a la variable local {#1126,graph}.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1129,LOCAL angle}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{angle=0;} // ángulo del gráfico del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {angle}.

La variable local {angle} define el ángulo en el que se debe ver el
gráfico del proceso, indicando un ángulo respecto al gráfico original
en {milésimas de grado} (ver {#1044,Uso de ángulos en el lenguaje}).

El valor por defecto de esta variable será {0} (0 grados) para todos
los procesos, pero cuando sea modificado el gráfico se {rotará} para
ajustarse al nuevo ángulo.

El ángulo puede definirse como cualquier número entero dentro del
rango ({#1177,min_int} ... {#1178,max_int}).

Se muestran a continuación algunos ejemplos de los ángulos que
definen ciertos valores en la variable local {angle} (se recuerda
que los ángulos se expresan en {milésimas} de grado):

      ...·
 { -180000} - {#1044,Angulo} hacia la izquierda·
 {  -90000} - {#1044,Angulo} hacia abajo·
 {  -45000} - {#1044,Angulo} de la diagonal abajo/derecha·
 {       0} - {#1044,Angulo} hacia la derecha·
 {  +45000} - {#1044,Angulo} de la diagonal derecha/arriba·
 {  +90000} - {#1044,Angulo} hacia arriba·
 { +180000} - {#1044,Angulo} hacia la izquierda·
 { +270000} - {#1044,Angulo} hacia abajo·
      ...·

{Importante:} Cuando se pretenda rotar el gráfico de un proceso,
{es conveniente dibujarlo orientado hacia la derecha}, ya que así es
como se mostrará por defecto (con la variable local {angle} igual
a {0}).

De esta forma, cuando se especifique otro ángulo, el gráfico
aparecerá orientado exactamente hacia él.

Por ejemplo, para que un gráfico que ha sido dibujado hacia la
derecha se vea orientado hacia arriba (hacia el ángulo de 90 grados),
bastará con indicar la siguiente sentencia:

  {angle=90000;} // 90 milésimas de grado (90 grados).

Es decir, si un gráfico se dibujara orientado hacia otro ángulo,
por ejemplo hacia abajo, quedaría orientado hacia abajo por defecto,
{en el ángulo 0}, lo que puede provocar confusiones a la hora de
orientar el gráfico hacia otro ángulo.

{/}

Para hacer que el gráfico de un proceso avance sus coordenadas ({#1123,x}, {#1124,y})
hacia su ángulo (el especificado en la variable local {angle} del proceso)
una distancia determinada, se puede utilizar la función {#101,advance()}.

{/}

{Nota:} El gráfico de un proceso se debe indicar asignando un {código
de gráfico} a la variable local {#1126,graph}.

{/}Ver: {#1201,Datos locales} - {#1044,Uso de ángulos en el lenguaje}

# ─────────────────────────────────────────────────────────────────────────────

{.1130,LOCAL region}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{region=0;} // Región de pantalla asignada al proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {region}.

La variable local {region} define en qué zona de pantalla debe ser
visible el gráfico del proceso, indicando el {número de región}.

Una región es una zona rectangular de pantalla, como una ventana,
que está asociada a un número.

Por defecto, esta variable valdrá {0} en todos los procesos haciendo
referencia a la {región número 0} que es {la pantalla entera}.

Es decir, que por defecto los gráficos de los procesos serán visibles
en toda la pantalla (en cualquier punto de la misma en el que estén).

En un principio, únicamente está definida la {región numero 0}.
Para definir nuevas regiones de pantalla se debe utilizar la función
{#106,define_region()}.

{/}

Por ejemplo, para que el gráfico de un proceso fuera visible sólo
dentro de una caja de 100 por 100 puntos situada en la esquina superior
izquierda de la pantalla (en las coordenadas 0, 0), primero se debería
definir la nueva región la siguiente forma, suponiendo que se defina
la región número {1}:

  {define_region(1, 0, 0, 100, 100);}

y, después, se debería asignar el número de región ({1}) a la variable
local {region} del proceso con la siguiente sentencia:

  {region=1;}

Las regiones pueden redefinirse en cualquier momento dentro de un
programa; esto es, se pueden cambiar de posición o de tamaño siempre
que sea necesario.

{/}

{Nota:} El gráfico de un proceso se debe indicar asignando un {código
de gráfico} a la variable local {#1126,graph}.

{/}Ver: {#1201,Datos locales} - {#106,define_region()}

# ─────────────────────────────────────────────────────────────────────────────

{.1131,LOCAL file}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{file=0;} // Código del fichero del gráfico del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {file}.

La variable local {file} indica, en los casos en los que se hayan cargado
varios {ficheros FPG} de gráficos en un programa, cuál es el fichero
que contiene el gráfico que está utilizando el proceso.

El gráfico de un proceso se debe indicar asignando un {código
de gráfico} a la variable local {#1126,graph}.

Si únicamente se ha cargado un fichero en el programa, no será necesario
asignar ningún valor a {file}, ya que el {código del primer fichero cargado}
será el {0} y éste es el valor por defecto de la variable.

Si el gráfico se ha cargado con la función {#174,load_map()}, tampoco
será necesario asignar ningún valor a {file}, ya que los gráficos cargados
con esta función se utilizan como si pertenecieran al fichero número {0}
(al primero que se cargue en el programa).

Cuando se cargue más de un fichero, se debe indicar en cada proceso
en cuál de ellos se encuentra su gráfico; esto se debe hacer asignando
el {código de fichero} que ha devuelto la función {#132,load_fpg()}
(al cargar dicho {fichero FPG}) a la variable local {file}.

{Nota:} Normalmente, si se cargan varios ficheros en un programa secuencialmente,
el primero tendrá el código {0}, el segundo el {1}, el tercero el {2} y, así sucesivamente.

{/}

En general, es una buena práctica, si se utilizan varios ficheros,
tener el mismo número de variables globales (denominadas por ejemplo
{fichero1}, {fichero2}, ...) que contengan el código de cada uno de
los ficheros, para utilizarlas en los procesos a la hora de definir
su variable {file} (el {fichero FPG} que se debe emplear).

Las variables se definirían dentro de la sección {#1006,GLOBAL} de la
siguiente forma:

  {GLOBAL}·
      {fichero1;} // Código del primer fichero·
      {fichero2;} // Código del segundo·
      ...

Después, se les asignaría a estas variables los {códigos de fichero}
al cargar éstos con la función {#132,load_fpg()} de la siguiente
forma (suponiendo que el nombre de los ficheros es {nombre1.fpg},
{nombre2.fpg}, etc.):

  {fichero1=load_fpg("nombre1.fpg");} // Carga de ficheros·
  {fichero2=load_fpg("nombre2.fpg");}·
  ...

Generalmente, esta carga de ficheros se realiza al inicio del programa;
posteriormente, dentro de cada proceso, solamente habría que definir
el fichero utilizado con la siguiente sentencia (suponiendo que el proceso
utilice gráficos contenidos en el fichero {nombre1.fpg}):

  {file=fichero1;} // Se utiliza el primer fichero·

{/}

{Nota:} Se recuerda que definir la variable local {file} no sirve para nada,
a no ser que también se asigne un {código de gráfico} a la variable local
{#1126,graph}.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1132,LOCAL xgraph}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{xgraph=0;} // OFFSET de la tabla gráfica del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {xgraph}.

Esta variable es de nivel avanzado, por lo que requiere cierta experiencia
para su utilización.

La variable local {xgraph} ({extended graphic}) sirve para utilizar
{gráficos múltiples}. Para definir el gráfico de un proceso como un
{conjunto de gráficos} de los cuales se debe ver {el más acorde con
el ángulo del proceso} (especificado en la variable local {#1129,angle}).

Es decir, si se define la variable {xgraph}, {se ignorará la }variable local
{#1126,graph} que normalmente define el gráfico del proceso y se
utilizará un gráfico u otro en función de la variable {#1129,angle}.

Por lo tanto, al cambiar el ángulo del proceso {ya no aparecerá
el gráfico del proceso rotado}, sino que utilizará este ángulo como
seleccionador del gráfico del proceso (dentro del conjunto definido).

Por defecto la variable {xgraph} valdrá {0} en todos los procesos,
lo que indica que éstos no van a utilizar {gráficos múltiples}.

{/}

La utilidad de los gráficos múltiples reside en poder realizar juegos
en {perspectiva}, donde un cambio de ángulo en un proceso no implica
una rotación de su gráfico, sino el cambio del gráfico por otro dibujado
con otra {perspectiva} (dibujado con otro ángulo dentro de dicha perspectiva).

{Forma de empleo de los gráficos múltiples.}{/}

1 - En primer lugar se deben realizar los diferentes dibujos que van
a representar al gráfico del proceso con diferentes ángulos en la
perspectiva. Éstos serán un número finito de vistas del gráfico, como
puede ser {4}, {8}, {12}, etc., (o cualquier otro número entero mayor que {1}).

Se debe tener en cuenta que si se definen 4 vistas, se estará definiendo
una vista diferente cada 90 grados, si se definen 8 vistas, cada 45
grados, etc.

2 - Se deben ordenar dichos gráficos según su ángulo; primero el gráfico
que se corresponderá con el ángulo 0 (hacia la derecha) y, después,
el resto en sentido contrario a las agujas del reloj.

3 - Se debe crear una tabla, generalmente {#1006,GLOBAL}, inicializada
con los siguientes valores:

  {Número de vistas del gráfico},·
  {Código del gráfico para el }ángulo {0 (primera vista)},·
  {Código del siguiente ángulo (segunda vista)},·
  ...

Es indiferente el nombre que se le de a dicha tabla, por ejemplo,
si se define un gráfico múltiple con 4 vistas, que deben ser los
gráficos con el código 10, 11, 12, y 13, la definición de la tabla
podría ser:

  {GLOBAL}·
      {tabla_gráfico1[]=4, 10, 11, 12, 13;}·
      ....

4 - Por último, se debe asignar la dirección de esta tabla dentro
de la memoria del ordenador a la variable local {xgraph} del proceso,
lo que se haría con la siguiente sentencia (dentro del proceso en cuestión):

  {xgraph=OFFSET tabla_gráfico1;}

El operador {#1085,OFFSET} sirve para obtener la dirección en la
memoria de un dato del programa.

{/}

Una vez definido el {gráfico múltiple}, el sistema utilizará en
cada imagen del juego el gráfico correspondiente al ángulo {que
más se aproxima al ángulo del proceso} (el indicado en su variable
{#1129,angle}).

Para desactivar el sistema de {gráficos múltiples} en un proceso,
simplemente se debe volver a poner a {0} la variable {xgraph}.

{Importante:} Si dentro de la tabla que define el conjunto de gráficos
se pone algún código de gráfico con {signo negativo}, entonces aparecerá
este gráfico {espejado horizontalmente}, es decir, si el gráfico
estaba mirando hacia la derecha, aparecerá mirando hacia la izquierda,
y viceversa.

{/}

{Nota:} El sistema de gráficos múltiples se suele utilizar en las
{ventanas de modo 7}, ya que en el plano tridimensional abatido los
gráficos se deben ver de distinta forma según el ángulo desde el que
se miren.

Para más información sobre esta técnica, ver la función {#162,start_mode7()}
utilizada para activar una {ventana de modo 7} en el programa.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1133,LOCAL height}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{height=0;} // Altura del gráfico (en el modo 7){/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {height}.

La variable local {height} se utiliza {exclusivamente} en los procesos
que pertenecen a {ventanas de modo 7}, es decir, procesos que tienen
su sistema de coordenadas dentro de una ventana tridimensional (su
variable local {#1122,ctype}={#1169,c_m7}).

Se utiliza para definir la altura a la que deben situarse los gráficos
de los procesos sobre el plano tridimensional. No se utiliza para esto
la variable {#1125,local z}, porque ésta sigue utilizándose para definir
el plano de profundidad de los gráficos (aunque ahora únicamente sea
útil para procesos situados en las mismas coordenadas).

La altura del proceso puede definirse como cualquier número entero dentro
del rango ({#1177,min_int} ... {#1178,max_int}), si bien se suelen
utilizar normalmente números positivos, ya que la altura ({height})
del suelo es la {0} y los procesos se sitúan por encima de éste.

El valor por defecto de la variable {height} es {0} para todos los
procesos, lo que quiere decir que si no se especifica otro valor,
los gráficos de los procesos aparecerán justo sobre el suelo del
{modo 7} (sobre el plano tridimensionalmente abatido).

En un principio se situará en la altura indicada en {height} la {base
del gráfico} del proceso, a no ser que se defina el {#1136,punto de
control} número {0}, en cuyo caso será este punto el que se sitúe
en esa altura.

{Nota:} Para más información sobre las {ventanas de modo 7} y cómo situar
gráficos dentro de estas ventanas, se debe ver la ayuda sobre la función
{#162,start_mode7()} que es la utilizada para activarlas en el programa.

{/}

En los procesos que no son de {modo 7} se puede utilizar esta variable
con cualquier otra finalidad, ya que el sistema la ignorará por completo.

{/}Ver: {#1201,Datos locales} - {#162,start_mode7()}

# ─────────────────────────────────────────────────────────────────────────────

{.1134,LOCAL cnumber}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{cnumber=0;} // Números de ventanas de scroll o modo 7{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {cnumber}.

La variable local {cnumber} se utiliza {exclusivamente} cuando en un juego
aparezcan varias {ventanas de scroll} o varias {ventanas de modo 7}
simultáneamente en pantalla.

- Para más información sobre las {ventanas de scroll}, se debe ver la
ayuda sobre la función {#163,start_scroll()}, que es la utilizada para
activarlas en el programa.

- Para más información sobre las {ventanas de modo 7}, se debe ver la
ayuda sobre la función {#162,start_mode7()}, que es la utilizada para
activarlas en el programa.

{/}

La utilidad de {cnumber} reside en indicar {en cuáles de estas ventanas
debe verse el gráfico del proceso}. Evidentemente, esta variable se
debe definir sólo en procesos visibles dentro de las {ventanas
de scroll} o de las {ventanas de modo 7}; para el resto de procesos
(los procesos de pantalla o los que no tengan gráfico) esta variable
carece de utilidad.

{Si el proceso debe verse en todas las ventanas}, entonces no será
necesario modificar esta variable, ya que el valor por defecto de
{cnumber} (que es {0}) indica precisamente esto.

Puede activarse hasta {10} ventanas, tanto de un tipo como del otro,
con los números del {0} al {9}. Existen diez constantes predefinidas
que se utilizan para definir el valor de {cnumber}; estas son
{#1175,c_0, c_1, c_2, ..., c_9} y se corresponden directamente con
las {10} posibles ventanas de estos tipos.

Se debe asignar a {cnumber la suma de las constantes} correspondientes
a las {ventanas en las que el proceso debe ser visible}.

Por ejemplo, si en un programa hay {4 ventanas de scroll} que son
las número {0}, {1}, {2} y {3}, y se quiere definir que un proceso determinado
debe ser visible tan solo dentro de las ventanas {0} y {2}, se
debe utilizar para esto la siguiente sentencia:

  {cnumber=c_0+c_2;}

El valor de {cnumber} puede variarse durante la ejecución del proceso
siempre que sea necesario.

{/}

{Nota:} Se recuerda que para que el gráfico del proceso se vea en
todas las ventanas no es necesario hacer nada, ya que ésta es la
opción por defecto.

{/}Ver: {#1201,Datos locales} - {#1175,c_0...c_9}

# ─────────────────────────────────────────────────────────────────────────────

{.1135,LOCAL resolution}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{resolution=0;} // Resolución de las coordenadas del proceso{/}.

Esta variable predefinida es {#1007,LOCAL}, lo que significa que cada
proceso tendrá su propio valor en su variable {resolution}.

Normalmente, las coordenadas de un proceso (indicadas en las variables
locales {#1123,x} e {#1124,y}) se definen en puntos (de pantalla).

La variable local {resolution} se debe utilizar cuando se quieran definir
las coordenadas en {unidades más pequeñas} que el punto.

Es decir, que esta variable indica la precisión de las coordenadas
del proceso.

Por defecto la variable valdrá {0} y las coordenadas se
especificarán en puntos.

Cuanto mayor sea el valor de {#1135,resolution}, más pequeña (y precisa)
será la unidad en la que se interpretan las coordenadas; a continuación
se muestran algunos ejemplos:

{resolution=1;} - Las coordenadas se especifican en puntos (al igual
que con {resolution=0}, que es el valor por defecto).

{resolution=10;} - Se especifican en décimas de puntos.

{resolution=100;} - Se especifican en centésimas de puntos.

{resolution=2;} - Se especifican en mitades de punto.

...

Por ejemplo, un proceso situado en {160}, {100} con {resolution} igual a
{0} (o {1}), estará en la misma posición que un proceso situado en
{1600}, {1000} y con {resolution} igual a {10}.

El valor de {resolution} se define normalmente como un {número
entero positivo múltiplo de 10} (10, 100, 1000, ...).

{/}

En resumen, cuando se defina el valor de {resolution}, el gestor de
procesos de DIV Games Studio {dividirá} las coordenadas de los procesos
entre {resolution} a la hora de pintar los gráficos de los mismos
en pantalla.

{/}

{Importante:} Se deben extremar las precauciones cuando en un programa
existan varios procesos con diferentes resoluciones de coordenadas,
ya que algunas funciones, como {#117,get_dist()} (para obtener la
distancia entre dos procesos), devolverán {resultados incorrectos}
cuando se esté accediendo a dos procesos que utilicen diferente
resolución de coordenadas.

Suele ser conveniente que todos los procesos activos en el juego,
al menos todos los que interactúen entre ellos (se detecten, modifiquen
o puedan colisionar) utilicen la misma resolución.

{/}Ver: {#1201,Datos locales}

# ─────────────────────────────────────────────────────────────────────────────

{.1136,Puntos de control.}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

{+200,0}Los {puntos de control} se definen dentro del {editor gráfico}
con la barra de puntos de control, indicada con este icono.{-}{+201,1}{-}{/}

Para acceder al {editor gráfico} basta con hacer "{doble-click}" con
el ratón (dos pulsaciones seguidas del botón izquierdo del ratón)
sobre un gráfico dentro del entorno (sobre una ventana de un mapa).

Los {puntos de control} son simplemente puntos que pueden localizarse
dentro de un gráfico, para diferentes funciones.

La {barra de puntos de control} permite situar hasta {1000} puntos
diferentes dentro de un gráfico, cada uno será identificado por su
número (del {0} al {999}).

Para situar uno de estos puntos, basta con seleccionar el {número de
punto} con los {iconos flecha izquierda} y {flecha derecha} y, después,
pulsar sobre el gráfico.

Para {borrar} (deseleccionar) un punto de control, se debe volver a
pulsar sobre el mismo en el gráfico una segunda vez.

{/}

El único {punto de control} que utiliza el sistema es el punto de
control número {0} (el primero); éste es el punto que define cuál
es el {centro virtual del gráfico} y que tiene múltiples aplicaciones
dentro del lenguaje.

Cuando no se defina el {punto de control número 0}, el sistema
actuará como si el centro virtual del gráfico fuera el {centro real
del mismo} (un punto situado en la mitad del ancho y la mitad del
alto del gráfico).

{/}

{Nota:} Una vez definidos los puntos de control, para que éstos tengan
efecto dentro de un programa, debe grabarse el {archivo MAP} o volverse
a incluir el gráfico en el {fichero FPG} arrastrándolo hasta el mismo
(según cuál de ambos se cargue en el programa).

# ─────────────────────────────────────────────────────────────────────────────

{.1150,Modos de vídeo}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constantes: {m320x200} ... {m1024x768}
{/}

Esta constantes sirven para indicar el modo de vídeo en la función
{#157,set_mode()}. La lista completa de constantes es la siguiente:

    m320x200·
    m320x240·
    m320x400·
    m360x240·
    m360x360·
    m376x282·
    m640x400·
    m640x480·
    m800x600·
    m1024x768·

Cada constante indica el modo de vídeo de la siguiente manera: primero,
la letra {m} y, luego, la resolución horizontal y vertical del modo separadas por
una {x}.

Los valores definidos para dichas constantes son los siguientes.

    m320x200  = 320200·
    m320x240  = 320240·
    m320x400  = 320400·
    m360x240  = 360240·
    m360x360  = 360360·
    m376x282  = 376282·
    m640x400  = 640400·
    m640x480  = 640480·
    m800x600  = 800600·
    m1024x768 = 1024768·

{/}Ver: {#1202,Constantes} - {#157,set_mode()}

# ─────────────────────────────────────────────────────────────────────────────

{.1151,true}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {true}
{/}

Esta constante se utiliza para indicar valores {ciertos}, para inicializar variables lógicas o
definir parámetros lógicos, es decir, que deben ser evaluados como una condición.

Su valor es {1}, y como en el lenguaje se interpretan como {ciertos} todos
los números {impares}, ésta constante será evaluada como una condición
que siempre se cumple ({cierta}).

{/}

La constante {#1152,false} es la opuesta a ésta: la utilizada para
indicar valores lógicos {falsos}.

{/}Ver: {#1202,Constantes} - {#1152,false}

# ─────────────────────────────────────────────────────────────────────────────

{.1152,false}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {false}
{/}

Esta constante se utiliza para indicar valores {falsos}, para inicializar variables lógicas o
definir parámetros lógicos, es decir, que deben ser evaluados como una condición.

Su valor es {0}, y como en el lenguaje se interpretan como {falsos} todos
los números {pares}, esta constante será evaluada como una condición
que nunca se cumple ({falsa}).

{/}

La constante {#1152,true} es la opuesta a ésta: la utilizada para
indicar valores lógicos {ciertos}.

{/}Ver: {#1202,Constantes} - {#1151,true}

# ─────────────────────────────────────────────────────────────────────────────

{.1153,s_kill}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_kill}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {0}.

Esta señal transmite a los procesos la orden imperativa {kill}
(muerte). Se utiliza para eliminar procesos en el programa
(para hacer desaparecer ciertos objetos del juego).

Es decir, al enviarle una señal {s_kill} a un proceso, éste será
eliminado y ya no aparecerá en las siguientes imágenes del juego.

Una constante relacionada directamente con ésta es {#1157,s_kill_tree}, con la
diferencia de que, al enviar esta señal, se eliminará al proceso indicado y
a sus {hijos}, que son los procesos que éste hubiera creado.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa, es:

    {s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1157,s_kill_tree}

# ─────────────────────────────────────────────────────────────────────────────

{.1154,s_wakeup}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_wakeup}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {1}.

Esta señal transmite a los procesos la orden imperativa {wakeup}
(despierta). Se utiliza para devolver al estado normal los procesos
que han sido dormidos (con la señal {#1155,s_sleep}), o congelados
(con la señal {#1156,s_freeze}).

Es decir, al enviarle una señal {s_wakeup} a un proceso, éste será
reactivado en las siguientes imágenes del juego (se volverá a ver
y a procesar).

Una constante relacionada directamente con ésta es {#1158,s_wakeup_tree}, con la
diferencia de que, al enviar esta señal, se despertará al proceso indicado y
a sus {hijos}, que son los procesos que éste hubiera creado.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa, es:

    {#1153,s_kill}·
    {s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·


{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1158,s_wakeup_tree}

# ─────────────────────────────────────────────────────────────────────────────

{.1155,s_sleep}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_sleep}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {2}.

Esta señal transmite a los procesos la orden imperativa {sleep}
(duerme). Se utiliza para dormir a un proceso. Un proceso dormido
no aparecerá en las siguientes imágenes del juego, pero no será
eliminado, como con la señal {#1153,s_kill}, sino que podrá volver
a {despertarse} en cualquier momento con una señal {#1154,s_wakeup}.

Es decir, al enviarle una señal {s_sleep} a un proceso, éste dejará
de aparecer en las siguientes imágenes del juego (hasta que sea
despertado o eliminado).

Una constante relacionada directamente con ésta es {#1159,s_sleep_tree}, con la
diferencia de que, al enviar esta señal, se dormirá al proceso indicado y
a sus {hijos}, que son los procesos que éste hubiera creado.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa, es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1159,s_sleep_tree}

# ─────────────────────────────────────────────────────────────────────────────

{.1156,s_freeze}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_freeze}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {3}.

Esta señal transmite a los procesos la orden imperativa {freeze}
(congelar). Se utiliza para congelar (inmovilizar) a un proceso.
Un proceso congelado seguirá apareciendo en las siguientes imágenes
del juego, pero no será procesado, por lo que permanecerá inmóvil.
Este proceso podrá volver a {activarse} en cualquier momento si se
le envía una señal {#1154,s_wakeup}.

Es decir, al enviarle una señal {s_freeze} a un proceso, éste dejará
de procesar (interpretar sus sentencias) en las siguientes imágenes
del juego (hasta que sea activado o eliminado con {#1153,s_kill}).

Una constante relacionada directamente con ésta es {#1160,s_freeze_tree}, con la
diferencia de que, al enviar esta señal, se congelará al proceso indicado y
a sus {hijos}, que son los procesos que éste hubiera creado.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1160,s_freeze_tree}

# ─────────────────────────────────────────────────────────────────────────────

{.1157,s_kill_tree}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_kill_tree}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {100}.

Esta señal se utiliza para que un proceso y todos los procesos
que éste haya creado sean {eliminados} enviándoles la orden imperativa
{kill} (muerte). Es una versión de la señal {#1153,s_kill}, que
elimina al proceso, pero no a los procesos que éste haya creado.

Es decir, con {s_kill_tree} se {eliminará} al proceso y a toda su
descendencia, con lo que ya no aparecerá ninguno de ellos en las
siguientes imágenes del juego.

La lista completa de las constantes que utilizadas como señales, pueden
ser enviadas a los diferentes procesos de un programa es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1153,s_kill}

# ─────────────────────────────────────────────────────────────────────────────

{.1158,s_wakeup_tree}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_wakeup_tree}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {101}.

Esta señal se utiliza para que un proceso y todos los procesos
que éste haya creado sean {despertados} enviándoles la orden imperativa
{wakeup} (despertar). Es una versión de la señal {#1154,s_wakeup}, que
despierta al proceso, pero no a los procesos que éste haya creado.

Es decir, con {s_wakeup_tree} se {despertará} al proceso y a toda su
descendencia, volviendo todos estos procesos a su estado normal en las
siguientes imágenes del juego.

Se puede despertar (reactivar) a procesos que han sido {dormidos}
con la señal {#1159,s_sleep_tree} o {congelados} con la señal
{#1160,s_freeze_tree}.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1154,s_wakeup}

# ─────────────────────────────────────────────────────────────────────────────

{.1159,s_sleep_tree}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_sleep_tree}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {102}.

Esta señal se utiliza para que un proceso y todos los procesos
que éste haya creado sean {dormidos} enviándoles la orden imperativa
{sleep} (dormir). Es una versión de la señal {#1155,s_sleep}, que
duerme al proceso, pero no a los procesos que éste haya creado.

Es decir, con {s_sleep_tree} se {dormirá} al proceso y a toda su
descendencia, desapareciendo todos estos procesos en las
siguientes imágenes del juego (pero sin ser eliminados).

Se puede despertar (reactivar) a estos procesos {dormidos}
con la señal {#1158,s_wakeup_tree}.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {s_sleep_tree}·
    {#1160,s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1155,s_sleep}

# ─────────────────────────────────────────────────────────────────────────────

{.1160,s_freeze_tree}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {s_freeze_tree}
{/}

Esta constante se utiliza como parámetro de la función
{#158,signal()} (para mandar señales a los procesos).
Su valor es {103}.

Esta señal se utiliza para que un proceso y todos los procesos
que éste haya creado sean {congelados} (inmovilizados) enviándoles la orden imperativa
{freeze} (congelar). Es una versión de la señal {#1156,s_freeze}, que
congela al proceso, pero no a los procesos que éste haya creado.

Es decir, con {s_freeze_tree} se {congelará} al proceso y a toda su
descendencia, dejando de procesar todos estos procesos en las
siguientes imágenes del juego (quedarán inmovilizados, pues no
ejecutarán sus sentencias).

Se puede descongelar (reactivar) a estos procesos {congelados}
con la señal {#1158,s_wakeup_tree}.

La lista completa de las constantes que utilizadas como señales pueden
ser enviadas a los diferentes procesos de un programa es:

    {#1153,s_kill}·
    {#1154,s_wakeup}·
    {#1155,s_sleep}·
    {#1156,s_freeze}·
    {#1157,s_kill_tree}·
    {#1158,s_wakeup_tree}·
    {#1159,s_sleep_tree}·
    {s_freeze_tree}·

{/}Ver: {#1202,Constantes} - {#158,signal()} - {#1156,s_freeze}

# ─────────────────────────────────────────────────────────────────────────────

{.1161,all_text}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {all_text}
{/}

Esta constante se usa como parámetro de la función {#107,delete_text()},
para eliminar {todos} los textos visualizados en el programa con las
funciones {#171,write()} y {#172,write_int()}.

Es decir, para que desaparezcan todos los textos que aparecen en
pantalla se debe ejecutar la siguiente sentencia:

  {delete_text(all_text);}

El valor que tiene asignado esta constante es {0}.

{/}Ver: {#1202,Constantes} - {#107,delete_text()}

# ─────────────────────────────────────────────────────────────────────────────

{.1162,all_sound}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {all_sound}
{/}

Esta constante se usa como parámetro de la función {#167,stop_sound()},
para parar {todos} los efectos de sonido previamente activados con la
función {#159,sound()}.

Es decir, para detener todos los canales de sonido activos en un momento
determinado se debe ejecutar la siguiente sentencia:

  {stop_sound(all_sound);}

El valor que tiene asignado esta constante es{ -1}.

{/}Ver: {#1202,Constantes} - {#167,stop_sound()} - {#159,sound()}

# ─────────────────────────────────────────────────────────────────────────────

{.1163,g_wide}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {g_wide}
{/}

Esta constante se usa como parámetro de la función {#126,graphic_info()},
para pedir información sobre el {ancho} (en puntos) de un gráfico determinado.
Su valor es {0}.

Las constantes que pueden utilizarse como parámetros de esta función son:

    {g_wide}·
    {#1164,g_height}·
    {#1165,g_x_center}·
    {#1166,g_y_center}·

{/}Ver: {#1202,Constantes} - {#126,graphic_info()}

# ─────────────────────────────────────────────────────────────────────────────

{.1164,g_height}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {g_height}
{/}

Esta constante se usa como parámetro de la función {#126,graphic_info()},
para pedir información sobre el {alto} (en puntos) de un gráfico determinado.
Su valor es {1}.

Las constantes que pueden utilizarse como parámetros de esta función son:

    {#1163,g_wide}·
    {g_height}·
    {#1165,g_x_center}·
    {#1166,g_y_center}·

{/}Ver: {#1202,Constantes} - {#126,graphic_info()}

# ─────────────────────────────────────────────────────────────────────────────

{.1165,g_x_center}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {g_x_center}
{/}

Esta constante se usa como parámetro de la función {#126,graphic_info()},
para pedir información sobre el {centro horizontal} de un gráfico determinado.
Su valor es {2}.

El {centro horizontal} de un gráfico será la mitad del ancho (en puntos),
si no se ha definido en la herramienta de dibujo el {#1136,punto de control}
número {0} (centro del gráfico).

Las constantes que pueden utilizarse como parámetros de esta función son:

    {#1163,g_wide}·
    {#1164,g_height}·
    {g_x_center}·
    {#1166,g_y_center}·

{/}Ver: {#1202,Constantes} - {#126,graphic_info()}

# ─────────────────────────────────────────────────────────────────────────────

{.1166,g_y_center}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {g_y_center}
{/}

Esta constante se usa como parámetro de la función {#126,graphic_info()},
para pedir información sobre el {centro vertical} de un gráfico determinado.
Su valor es {3}.

El {centro vertical} de un gráfico será la mitad del alto (en puntos),
si no se ha definido en la herramienta de dibujo el {#1136,punto de control}
número {0} (centro del gráfico).

Las constantes que pueden utilizarse como parámetros de esta función son:

    {#1163,g_wide}·
    {#1164,g_height}·
    {#1165,g_x_center}·
    {g_y_center}·

{/}Ver: {#1202,Constantes} - {#126,graphic_info()}

# ─────────────────────────────────────────────────────────────────────────────

{.1167,c_screen}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {c_screen}
{/}

Esta constante se utiliza para asignarla a la variable local predefinida
{#1122,ctype} que sirve para definir el tipo de coordenadas que
tendrá un proceso. Su valor es {0}.

{Este es el valor por defecto de} {#1122,ctype}, el utilizado para que
las coordenadas del gráfico del proceso se interpreten como referidas
a la pantalla, donde la esquina superior izquierda es la (0, 0).

Existen otras constantes utilizadas para otros sistemas de coordenadas,
la lista completa es la siguiente:

    {c_screen} - Coordenadas de pantalla·
    {#1168,c_scroll} - Coordenadas de scroll·
    {#1169,c_m7}     - Coordenadas de modo 7·

{/}Ver: {#1202,Constantes} - {#1122,ctype}

# ─────────────────────────────────────────────────────────────────────────────

{.1168,c_scroll}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {c_scroll}
{/}

Esta constante se utiliza para asignarla a la variable local predefinida
{#1122,ctype} que sirve para definir el tipo de coordenadas que
tendrá un proceso. Su valor es {1}.

Éste es el valor asignado a {#1122,ctype} para que
las coordenadas del gráfico del proceso se interpreten como referidas
a una ventana de scroll, a coordenadas sobre el gráfico
del primer plano.

Para más información sobre las {ventanas de scroll}, se puede acceder
a la función {#163,start_scroll()} utilizada para activarlas.

Existen otras constantes utilizadas para otros sistemas de coordenadas,
la lista completa es la siguiente:

    {#1167,c_screen} - Coordenadas de pantalla·
    {c_scroll} - Coordenadas de scroll·
    {#1169,c_m7}     - Coordenadas de modo 7·

{/}Ver: {#1202,Constantes} - {#1122,ctype} - {#163,start_scroll()}

# ─────────────────────────────────────────────────────────────────────────────

{.1169,c_m7}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {c_m7}
{/}

Esta constante se utiliza para asignarla a la variable local predefinida
{#1122,ctype} que sirve para definir el tipo de coordenadas que
tendrá un proceso. Su valor es {2}.

Éste es el valor asignado a {#1122,ctype} para que
las coordenadas del gráfico del proceso se interpreten como referidas
a una ventana de modo 7, a coordenadas sobre el gráfico
principal, abatido tridimensionalmente en dicha ventana.

Para más información sobre las {ventanas de modo 7}, se puede acceder
a la función {#162,start_mode7()}, utilizada para activarlas.

Existen otras constantes utilizadas para otros sistemas de coordenadas,
la lista completa es la siguiente:

    {#1167,c_screen} - Coordenadas de pantalla·
    {#1168,c_scroll} - Coordenadas de scroll·
    {c_m7}     - Coordenadas de modo 7·

{/}Ver: {#1202,Constantes} - {#1122,ctype} - {#162,start_mode7()}

# ─────────────────────────────────────────────────────────────────────────────

{.1170,partial_dump}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {partial_dump}
{/}

Esta constante se utiliza para asignarla a la variable global predefinida
{#1114,dump_type} que sirve para definir el tipo de volcado que se hará a
pantalla. Su valor es {0}.

Se utiliza en la siguiente sentencia:

  {dump_type=partial_dump;}

Con esta sentencia se indica al gestor de procesos de DIV Games
Studio que los siguientes volcados deben ser {parciales}.

Se denomina {volcado} al procedimiento de enviar las imágenes del juego
al monitor (a la memoria de vídeo de la tarjeta gráfica).

Hay dos tipos de volcados:

{Parcial}: Sólo se volcarán en pantalla los gráficos que se actualicen,
que hayan variado respecto a la imagen anterior. Este volcado conviene activarlo
{para ganar velocidad} cuando se programe un juego (o una sección del
mismo) sin una ventana de scroll o modo 7 que ocupe toda la pantalla,
es decir, cuando el juego muestre movimientos de gráficos sobre un
fondo fijo, o bien cuando las ventanas activas de scroll o modo 7 sean
más pequeñas que la pantalla.

{Completo}: Se volcará toda la pantalla, sin importar si los gráficos han
cambiado o no. Éste es el volcado por defecto y {es más lento que el
volcado parcial}, sin embargo, es el que se debe utilizar cuando el
juego tenga una ventana de scroll o modo 7 que ocupe toda la pantalla.

{/}

La otra constante que se utiliza para designar el tipo de volcado es
{#1171,complete_dump} que, al contrario de ésta, define un volcado {completo}.

{/}Ver: {#1202,Constantes} - {#1114,dump_type} - {#1171,complete_dump}

# ─────────────────────────────────────────────────────────────────────────────

{.1171,complete_dump}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {complete_dump}
{/}

Esta constante se utiliza para asignarla a la variable global predefinida
{#1114,dump_type} que sirve para definir el tipo de volcado que se hará a
pantalla. Su valor es {1}.

Éste es el {valor por defecto} de la variable {#1114,dump_type}.
Para establecer este valor se debe utilizar la siguiente sentencia:

  {dump_type=complete_dump;}

Con esta sentencia se indica al gestor de procesos de DIV Games
Studio que los siguientes volcados deben ser {completos}.

Se denomina {volcado} al proceso de enviar las imágenes del juego
al monitor (a la memoria de vídeo de la tarjeta gráfica).

Hay dos tipos de volcados:

{Parcial}: Sólo se volcarán en pantalla los gráficos que se actualicen,
que hayan variado respecto a la imagen anterior. Este volcado conviene activarlo
{para ganar velocidad} cuando se programe un juego (o una sección del
mismo) sin una ventana de scroll o modo 7 que ocupe toda la pantalla,
es decir, cuando el juego muestre movimientos de gráficos sobre un
fondo fijo, o bien cuando las ventanas activas de scroll o modo 7 sean
más pequeñas que la pantalla.

{Completo}: Se volcará toda la pantalla, sin importar si los gráficos han
cambiado o no. Éste es el volcado por defecto y {es más lento que el
volcado parcial}, sin embargo, es el que se debe utilizar cuando el
juego tenga una ventana de scroll o modo 7 que ocupe toda la pantalla.

{/}

La otra constante que se utiliza para designar el tipo de volcado es
{#1170,partial_dump} que, al contrario de ésta, define un volcado {parcial}.

{/}Ver: {#1202,Constantes} - {#1114,dump_type} - {#1170,partial_dump}

# ─────────────────────────────────────────────────────────────────────────────

{.1172,no_restore}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {no_restore}
{/}

Esta constante se utiliza para asignarla a la variable global predefinida
{#1113,restore_type} que sirve para definir el tipo de restauración
que se debe aplicar al fondo de la pantalla tras cada imagen del juego.
Su valor es{ -1}.

Se denomina {restauración del fondo} a recuperar las zonas de pantalla
en las que se han pintado gráficos o escrito textos en la imagen anterior,
es decir, "{despintar}" los gráficos y "{desescribir}" los textos (borrarlos).

Para establecer este valor se debe utilizar la siguiente sentencia:

  {restore_type=no_restore;}

Con esta sentencia se indica al gestor de procesos de DIV Games
Studio que tras las siguientes imágenes del juego {no es necesario
que se restaure el fondo de pantalla}.

Si no se restaura el fondo, se {ganará velocidad} de ejecución en
el juego (irá más fluido en los ordenadores lentos). Pero esta
modalidad de restauración ({no_restore}) es aplicable únicamente
en juegos o secciones de los mismos, en los que {exista una ventana
de scroll o de modo 7 que ocupe la pantalla completa}.

Los tres tipos de restauración aplicables se corresponden con
estas tres constantes:

{no_restore}       - El más rápido, no se restaura el fondo·
{#1173,partial_restore}  - Medio, restauraciones parciales·
{#1174,complete_restore} - El más lento, restauración completa·

{/}Ver: {#1202,Constantes} - {#1113,restore_type}

# ─────────────────────────────────────────────────────────────────────────────

{.1173,partial_restore}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {partial_restore}
{/}

Esta constante se utiliza para asignarla a la variable global predefinida
{#1113,restore_type} que sirve para definir el tipo de restauración
que se debe aplicar al fondo de la pantalla tras cada imagen del juego.
Su valor es{ 0}.

Se denomina {restauración del fondo} a recuperar las zonas de pantalla
en las que se han pintado gráficos o escrito textos en la imagen anterior,
es decir, "{despintar}" los gráficos y "{desescribir}" los textos (borrarlos).

Para establecer este valor se debe utilizar la siguiente sentencia:

  {restore_type=partial_restore;}

Con esta sentencia se indica al gestor de procesos de DIV Games
Studio que, tras las siguientes imágenes del juego, {se deben restaurar
únicamente las zonas de pantalla en las que se hayan pintado
gráficos o escrito textos}.

Esta modalidad de restauración ({partial_restore}) es más rápida que una restauración
completa (opción por defecto), pero debe aplicarse únicamente en
juegos, o secciones de los mismos, en los que {NO exista una ventana
de scroll o de modo 7 que ocupe la pantalla completa}.

Los tres tipos de restauración aplicables se corresponden con
estas tres constantes:

{#1172,no_restore}       - El más rápido, no se restaura el fondo·
{partial_restore}  - Medio, restauraciones parciales·
{#1174,complete_restore} - El más lento, restauración completa·

{/}Ver: {#1202,Constantes} - {#1113,restore_type}

# ─────────────────────────────────────────────────────────────────────────────

{.1174,complete_restore}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {complete_restore}
{/}

Esta constante se utiliza para asignarla a la variable global predefinida
{#1113,restore_type} que sirve para definir el tipo de restauración
que se debe aplicar al fondo de la pantalla tras cada imagen del juego.
Su valor es{ 1}.

Se denomina {restauración del fondo} a recuperar las zonas de pantalla
en las que se han pintado gráficos o escrito textos en la imagen anterior,
es decir, "{despintar}" los gráficos y "{desescribir}" los textos (borrarlos).

{Éste es el valor por defecto de la variable} {#1113,restore_type} y,
de las tres modalidades de restauración disponible, es la {más lenta}.
Para establecer este valor se debe utilizar la siguiente sentencia:

  {restore_type=complete_restore;}

Con esta sentencia se indica al gestor de procesos de DIV Games
Studio que tras las siguientes imágenes del juego {se debe restaurar
completamente el fondo de la pantalla}.

Esta modalidad de restauración ({complete_restore}) es la más
lenta de todas (y es la opción por defecto), por lo que puede
cambiarse por otra para {ganar velocidad} de ejecución en el juego
(con lo que irá más fluido en los ordenadores lentos).

En realidad, esta modalidad interesa únicamente en juegos, o secciones
de los mismos, que {no} tengan una ventana de scroll o de modo 7 que ocupe
toda la pantalla, pero que tengan una gran cantidad de gráficos
moviéndose por pantalla.

Los tres tipos de restauración aplicables se corresponden con
estas tres constantes:

{#1172,no_restore}       - El más rápido, no se restaura el fondo·
{#1173,partial_restore}  - Medio, restauraciones parciales·
{complete_restore} - El más lento, restauración completa·

{/}Ver: {#1202,Constantes} - {#1113,restore_type}

# ─────────────────────────────────────────────────────────────────────────────

{.1175,Números de ventana}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constantes: {c_0} ... {c_9}
{/}

Estas constantes se utilizan para asignarlas a la variable local predefinida
{#1134,cnumber} que sirve para definir las ventanas de scroll o modo 7
en las que debe aparecer el gráfico de un proceso.

{Ésto será necesario solamente cuando se hayan activado varias ventanas
de scroll o varias ventanas de modo 7, y NO se quiera que el gráfico
del proceso se visualice en todas ellas.}

Pueden definirse hasta 10 ventanas de estos tipos, con los números
del {0} al {9}, y que se corresponderán directamente con las constantes
{c_0}, {c_1}, {c_2} ... {c_9}.

Para que el gráfico de un proceso aparezca sólo en una de estas
ventanas, se debe asignar la constante correspondiente a su variable
local {#1134,cnumber}. Por ejemplo, si se quisiera que el gráfico
de un proceso apareciera únicamente en la ventana número 3 (de scroll
o modo 7), se debería incluir en su código la siguiente sentencia:

  {cnumber=c_3;}

Si se quiere que el gráfico de un proceso aparezca en varias ventanas
de estas ventanas, entonces se deberán sumar las constantes.
Por ejemplo, para que un proceso aparezca en las ventanas 0, 4, y 5
se realizará la siguiente asignación:

  {cnumber=c_0+c_4+c_5;}

Para que el gráfico aparezca en todas las ventanas, basta con asignar
un {0} a la variable {#1134,cnumber}. Aspecto que no será necesario si
esta variable no se ha modificado, pues ése es su valor por defecto.

Los valores a los que equivalen estas constantes se corresponden
con las siguientes potencias de 2:

    {c_0} = 1   scroll / modo-7 número 0·
    {c_1} = 2   scroll / modo-7 número 1·
    {c_2} = 4   scroll / modo-7 número 2·
    {c_3} = 8   scroll / modo-7 número 3·
    {c_4} = 16  scroll / modo-7 número 4·
    {c_5} = 32  scroll / modo-7 número 5·
    {c_6} = 64  scroll / modo-7 número 6·
    {c_7} = 128 scroll / modo-7 número 7·
    {c_8} = 256 scroll / modo-7 número 8·
    {c_9} = 512 scroll / modo-7 número 9·

{/}Ver: {#1202,Constantes} - {#1134,cnumber}.

# ─────────────────────────────────────────────────────────────────────────────

{.1176,Códigos de las teclas}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constantes: {Códigos de las teclas}
{/}

Estas constantes se utilizan normalmente como parámetro de la
función {#128,key()}, para indicar qué tecla es la que se desea
saber si está pulsada.

También se pueden utilizar para comparar la variable global
{#1110,scan_code}, que contiene el código de la última tecla que
se ha pulsado, con estos valores.

Normalmente, para designar a cada constante se suele usar el carácter {_}
(subrayado) seguido del nombre de la tecla, por ejemplo para la tecla [{A}],
la constante referida a su código será {_a}.

La lista completa de estas constantes, con sus respectivos valores,
es la siguiente (según la disposición estándar del teclado):

{_esc}         = 1   [ESC] o escape·
{_f1}          = 59  [F1] o función 1·
{_f2}          = 60  [F2] o función 2·
{_f3}          = 61  [F3] o función 3·
{_f4}          = 62  [F4] o función 4·
{_f5}          = 63  [F5] o función 5·
{_f6}          = 64  [F6] o función 6·
{_f7}          = 65  [F7] o función 7·
{_f8}          = 66  [F8] o función 8·
{_f9}          = 67  [F9] o función 9·
{_f10}         = 68  [F10] o función 10·
{_f11}         = 87  [F11] o función 11·
{_f12}         = 88  [F12] o función 12 (TRAZADOR)·
{_prn_scr}     = 55  [IMPR PANT] o impresión pantalla·
{_scroll_lock} = 70  [BLOQ DESPL] o bloqueo desplazamiento·

{_wave}        = 41  Tecla [º] o [ª]·
{_1}           = 2   Tecla con el número "1"·
{_2}           = 3   Tecla con el número "2"·
{_3}           = 4   Tecla con el número "3"·
{_4}           = 5   Tecla con el número "4"·
{_5}           = 6   Tecla con el número "5"·
{_6}           = 7   Tecla con el número "6"·
{_7}           = 8   Tecla con el número "7"·
{_8}           = 9   Tecla con el número "8"·
{_9}           = 10  Tecla con el número "9"·
{_0}           = 11  Tecla con el número "0"·
{_minus}       = 12  Tecla con el símbolo "?"·
{_plus}        = 13  Tecla con el símbolo "¿"·

{_backspace}   = 14  Tecla de borrado ( <- )·
{_tab}         = 15  Tecla de tabulador [TAB]·
{_q}           = 16  Tecla con la letra "Q"·
{_w}           = 17  Tecla con la letra "W"·
{_e}           = 18  Tecla con la letra "E"·
{_r}           = 19  Tecla con la letra "R"·
{_t}           = 20  Tecla con la letra "T"·
{_y}           = 21  Tecla con la letra "Y"·
{_u}           = 22  Tecla con la letra "U"·
{_i}           = 23  Tecla con la letra "I"·
{_o}           = 24  Tecla con la letra "O"·
{_p}           = 25  Tecla con la letra "P"·
{_l_brachet}   = 26  Tecla [^] o [`]·
{_r_brachet}   = 27  Tecla [*] o [+]·
{_enter}       = 28  [ENTER] (Intro o Retorno)·

{_caps_lock}   = 58  [BLOQ MAYUS] o bloqueo mayúsculas·
{_a}           = 30  Tecla con la letra "A"·
{_s}           = 31  Tecla con la letra "S"·
{_d}           = 32  Tecla con la letra "D"·
{_f}           = 33  Tecla con la letra "F"·
{_g}           = 34  Tecla con la letra "G"·
{_h}           = 35  Tecla con la letra "H"·
{_j}           = 36  Tecla con la letra "J"·
{_k}           = 37  Tecla con la letra "K"·
{_l}           = 38  Tecla con la letra "L"·
{_semicolon}   = 39  Tecla con la letra "Ñ"·
{_apostrophe}  = 40  Tecla [{{}]·
{_backslash}   = 43  Tecla [{}}]·

{_l_shift}     = 42  [SHIFT] o mayúsculas izquierdo·
{_z}           = 44  Tecla con la letra "Z"·
{_x}           = 45  Tecla con la letra "X"·
{_c}           = 46  Tecla con la letra "C"·
{_v}           = 47  Tecla con la letra "V"·
{_b}           = 48  Tecla con la letra "B"·
{_n}           = 49  Tecla con la letra "N"·
{_m}           = 50  Tecla con la letra "M"·
{_comma}       = 51  Tecla [;] o [,]·
{_point}       = 51  Tecla [:] o [.]·
{_slash}       = 51  Tecla [_] o [-]·
{_r_shift}     = 54  [SHIFT] o mayúsculas derecho·

{_control}     = 29  Teclas [CONTROL]·
{_alt}         = 56  Tecla [ALT] o [ALT GR]·
{_space}       = 57  [SPACE] o barra espaciadora·

{_ins}         = 82  [INSERT] o insertar·
{_home}        = 71  [INICIO] o inicio de página·
{_pgup}        = 73  [RE PAG] o retroceso de página·
{_del}         = 83  [SUPR] o suprimir·
{_end}         = 79  [FIN] o fin de página·
{_pgdn}        = 81  [AV PAG] o avance de página·

{_up}          = 72  Cursor para arriba·
{_down}        = 80  Cursor para abajo·
{_left}        = 75  Cursor para izquierda·
{_right}       = 77  Cursor para derecha·

{_num_lock}    = 69  [BLOQ NUM] o bloqueo numérico·
{_c_backslash} = 53  Símbolo [/] del teclado numérico·
{_c_asterisk}  = 55  Símbolo [*] del teclado numérico·
{_c_minus}     = 74  Símbolo [-] del teclado numérico·
{_c_home}      = 71  [INICIO] del teclado numérico·
{_c_up}        = 72  Cursor arriba del teclado numérico·
{_c_pgup}      = 73  [RE PAG] del teclado numérico·
{_c_left}      = 75  Cursor izquierda del teclado numérico·
{_c_center}    = 76  Tecla [5] del teclado numérico·
{_c_right}     = 77  Cursor derecha del teclado numérico·
{_c_end}       = 79  [FIN] del teclado numérico·
{_c_down}      = 80  Cursor abajo del teclado numérico·
{_c_pgdn}      = 81  [AV PAG] del teclado numérico·
{_c_ins}       = 82  [INS] del teclado numérico·
{_c_del}       = 83  [SUPR] del teclado numérico·
{_c_plus}      = 78  Símbolo [+] del teclado numérico·
{_c_enter}     = 28  [ENTER] del teclado numérico·

Resulta indiferente utilizar estas constantes o los valores numéricos
que representan, es decir, se puede llamar a la función {#128,key()},
para comprobar si está pulsada la tecla [{A}], como {key(_a)} o bien
como {key(30)} (se puede comprobar en la lista anterior que {30} es
el valor numérico de la constante {_a}).

{/}

{Importante:} Algunos de estos códigos pueden diferir en ciertos
teclados, en caso de duda se puede ejecutar el siguiente programa
ejemplo, que muestra en pantalla una tabla, correspondiente con la
función {#128,key()} (indicando los {códigos de las teclas que están
pulsadas} en cada momento), además de los valores de las variables
{#1110,scan_code}, {#1109,ascii} y {#1108,shift_status} (relacionados
igualmente con la lectura del teclado).

{#9999,Programa ejemplo:}
PROGRAM ejemplo_códigos_del_teclado;

GLOBAL
    teclas[128];

BEGIN
    write(0, 0, 0, 0, "Códigos de las teclas pulsadas, según key()");
    FROM x=0 TO 127;
        write_int(0, (x%16)*20, (x/16)*10+20, 0, OFFSET teclas[x]);
    END
    write(0, 0, 160, 0, "Código de la última tecla pulsada (scan_code):");
    write_int(0, 320, 160, 2, OFFSET scan_code);
    write(0, 0, 180, 0, "Código ASCII de la última tecla (ascii):");
    write_int(0, 320, 180, 2, OFFSET ascii);
    write(0, 0, 190, 0, "Estado de las teclas especiales (shift_status):");
    write_int(0, 320, 190, 2, OFFSET shift_status);
    LOOP
        FROM x=1 TO 127;
            IF (key(x))
                teclas[x]=x;
            ELSE
                teclas[x]=0;
            END
        END
        FRAME;
    END
END
{-}

Este programa se puede utilizar (pulsando con el ratón sobre el
texto "{Programa ejemplo:}" y después la tecla [{F10}]) para
averiguar el código que tiene alguna tecla en concreto.

Después podrá utilizarse dicho código numérico como parámetro de la
función {#128,key()}, para comprobar en el juego si dicha tecla está
pulsada en un momento determinado.

{/}Ver: {#1202,Constantes} - {#128,key()} - {#1110,scan_code} - {#1109,ascii} - {#1108,shift_status}

# ─────────────────────────────────────────────────────────────────────────────

{.1177,min_int}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {min_int}
{/}

Esta constante define el valor mínimo que puede almacenar cualquier
dato en este lenguaje. Este valor es{ -2147483648}.

Todos los datos son {enteros} con signo de 32 bits en este lenguaje.
Por ello, únicamente se pueden manejar números enteros dentro del rango
({ -2147483648} ...{ [phone]} ).

Cuando el resultado de una operación aritmética exceda dicho rango,
el sistema no advertirá de ningún error, por lo que se deben extremar
las precauciones para que ésto no suceda.

{/}Ver: {#1202,Constantes} - {#1178,max_int}

# ─────────────────────────────────────────────────────────────────────────────

{.1178,max_int}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {max_int}
{/}

Esta constante define el valor máximo que puede almacenar cualquier
dato en este lenguaje. Este valor es{ 2147483647}.

Todos los datos son {enteros} con signo de 32 bits en este lenguaje, de ahí
que, únicamente, se pueden manejar números enteros dentro del rango
({ -2147483648} ...{ [phone]} ).

Cuando el resultado de una operación aritmética exceda dicho rango,
el sistema no advertirá de ningún error, por lo que se deben extremar
las precauciones para que esto no suceda.

{/}Ver: {#1202,Constantes} - {#1177,min_int}

# ─────────────────────────────────────────────────────────────────────────────

{.1179,pi}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

Constante: {pi}
{/}

Esta constante define la equivalencia en {milésimas de grado} de la
constante matemática {pi} (aproximadamente {3.14159265} radianes).

Su valor es {180000} milésimas de grado (180 grados), equivalente a
{pi radianes}.

Se suele utilizar para definir ángulos; por ejemplo, se podría
definir {180 grados} como {pi},{ -90 grados} como{ -pi/2},
{45 grados} como {pi/4}, etc.

{/}Ver: {#1202,Constantes} - {#1044,Uso de ángulos en el lenguaje}

# ─────────────────────────────────────────────────────────────────────────────

{.1200,Datos globales predefinidos}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

A continuación se describe cada uno de los datos globales predefinidos.

{#1100,STRUCT mouse}     - Parámetros del ratón·
{#1101,STRUCT scroll[9]} - Control de las ventanas de scroll·
{#1102,STRUCT m7[9]}     - Control de las ventanas de modo 7·
{#1103,STRUCT joy}       - Parámetros del joystick·
{#1104,STRUCT setup}     - Control de la tarjeta de sonido·
{#1105,timer[9]}         - Contadores de tiempo·
{#1106,text_z}           - Plano de profundidad de los textos·
{#1107,fading}           - Indicador de fundido de pantalla·
{#1108,shift_status}     - Estado de las teclas especiales·
{#1109,ascii}            - Lectura de códigos ASCII del teclado·
{#1110,scan_code}        - Lectura de códigos del teclado·
{#1111,joy_filter}       - Filtro aplicado al joystick·
{#1112,joy_status}       - Estado del joystick·
{#1113,restore_type}     - Tipo de restauración de la pantalla·
{#1114,dump_type}        - Tipo de volcado de la pantalla·
{#1115,max_process_time} - Tiempo máximo de ejecución de un proceso·

{/}Ver: {#1202,Constantes} - {#1201,Datos locales} - {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1201,Datos locales predefinidos}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

A continuación se describe cada uno de los datos locales predefinidos.

{#1116,STRUCT reserved} - Parámetros internos de los procesos·
{#1117,father}          - Identificador de padre del proceso·
{#1118,son}             - Identificador del hijo del proceso·
{#1119,smallbro}        - Identificador del hermano pequeño del proceso·
{#1120,bigbro}          - Identificador del hermano mayor del proceso·
{#1121,priority}        - Prioridad de ejecución del proceso·
{#1122,ctype}           - Tipo de coordenadas utilizadas por el proceso·
{#1123,x}               - Coordenada horizontal del proceso·
{#1124,y}               - Coordenada vertical del proceso·
{#1125,z}               - Plano de profundidad del gráfico del proceso·
{#1126,graph}           - Código del gráfico asignado al proceso·
{#1127,flags}           - Indicadores de espejado y transparencia·
{#1128,size}            - Tamaño del gráfico del proceso·
{#1129,angle}           - ángulo del gráfico del proceso·
{#1130,region}          - Región de pantalla asignada al proceso·
{#1131,file}            - Código del fichero del gráfico del proceso·
{#1132,xgraph}          - OFFSET de la tabla gráfica del proceso·
{#1133,height}          - Altura del proceso en ventanas de modo 7·
{#1134,cnumber}         - Números de ventanas de scroll o modo 7·
{#1135,resolution}      - Resolución de las coordenadas del proceso·

{/}Ver: {#1202,Constantes} - {#1200,Datos globales} - {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────


{.1202,Constantes predefinidas}
Ver: {#4,Glosario} - {#3,Indice} - {#1032,Funciones}{/}

A continuación se describe cada una de las constantes predefinidas.

{#1150,m320x200 .. m1024x768} - Modos de vídeo·
{#1151,true}                  - Valor verdadero·
{#1152,false}                 - Valores falso·
{#1153,s_kill}                - Señal de matar procesos ·
{#1154,s_wakeup}              - Señal de despertar procesos·
{#1155,s_sleep}               - Señal de dormir procesos·
{#1156,s_freeze}              - Señal de congelar procesos·
{#1157,s_kill_tree}           - Señal de matar procesos e hijos·
{#1158,s_wakeup_tree}         - Señal de despertar procesos e hijos·
{#1159,s_sleep_tree}          - Señal de dormir procesos e hijos·
{#1160,s_freeze_tree}         - Señal de congelar procesos e hijos·
{#1161,all_text}              - Indicador de todos los textos·
{#1162,all_sound}             - Indicador de todos los sonidos·
{#1163,g_wide}                - Indicador de ancho·
{#1164,g_height}              - Indicador de alto·
{#1165,g_x_center}            - Indicador de centro horizontal·
{#1166,g_y_center}            - Indicador de centro vertical·
{#1167,c_screen}              - Coordenadas de pantalla·
{#1168,c_scroll}              - Coordenadas de ventana de scroll·
{#1169,c_m7}                  - Coordenadas de ventana de modo7·
{#1170,partial_dump}          - Volcado de fondo parcial·
{#1171,complete_dump}         - Volcado de fondo completo·
{#1172,no_restore}            - Restauración de pantalla desactivada·
{#1173,partial_restore}       - Restauración de pantalla parcial·
{#1174,complete_restore}      - Restauración de pantalla completa·
{#1175,c_0 .. c_9}            - Indicadores de ventanas·
{#1177,min_int}               - Valor mínimo de datos·
{#1178,max_int}               - Valor máximo de datos·
{#1179,pi}                    - Valor matemático de pi·

{#1176,Codigos de teclas}     - Códigos del teclado·

{/}Ver: {#1200,Datos globales} - {#1201,Datos locales} - {#1000,Sintaxis}

# ─────────────────────────────────────────────────────────────────────────────

{.1249,Ayuda sobre el lenguaje de programación.}

Ver: {#3,Indice general}{/}

  {#4,Glosario de términos.}·
  {#1000,Sintaxis de un programa.}·
  {#1017,Relación de sentencias.}·
  {#1032,Lista de funciones.}·

  {#1202,Constantes predefinidas.}·
  {#1200,Datos globales predefinidos.}·
  {#1201,Datos locales predefinidos.}·

  {#1035,Expresiones aritméticas.}·
  {#1037,Condiciones lógicas.}·

  {#1176,Códigos del teclado.}·

# ─────────────────────────────────────────────────────────────────────────────

{.1250,Ayuda sobre el sistema de menús}

Ver: {#3,Indice general}{/}

  {#1251,El menú de programas}·
  {#1252,El menú de edición}·
  {#1253,El menú de paletas}·
  {#1254,El menú de mapas}·
  {#1255,Menú de ficheros}·
  {#1256,Menú de fuentes}·
  {#1257,Menú de sonidos}·
  {#1258,Menú de sistema}·
  {#1259,Opción de ayuda}·
  {#1260,Trazador de programas}·

# ─────────────────────────────────────────────────────────────────────────────

{.1251,El menú de programas}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+68,0}Este menú controla todo lo relacionado con los listados de los programas, su
edición y su ejecución. Permite abrir y guardar listados, ejecutar código o
editarlo.

Se puede ver en "{#1294,Comandos del editor}" la lista completa de teclas disponibles
para editar un programa. Cuando exista más de una ventana de programa, sólo
se podrá editar en la que esté seleccionada; para seleccionar otra se debe
pulsar con el ratón sobre ella.

A continuación se describen cada una de las opciones de este menú.{-}

{/}

{Nuevo...}

Es la opción utilizada para comenzar un nuevo programa (a escribir un
listado). Los primeros pasos se describen en el capítulo número 5 del libro
de DIV Games Studio (Manual de usuario).
Aparecerá un cuadro de diálogo en el que se debe especificar el nombre del
nuevo programa, por lo que se debe especificar el nombre de archivo para el
programa (se pueden utilizar hasta ocho caracteres), la extensión {PRG} se
añadirá automáticamente. Si se especifica el nombre de un archivo ya
existente, el programa preguntará si se desea sobreescribir el programa, si
se responde {Aceptar}, se borrará el programa existente, al crearse
nuevamente. Finalmente, aparecerá una nueva ventana de edición vacía
preparada para el nuevo programa.

{/}

{Abrir programa... (Tecla directa : F4)}

Es la opción para cargar un programa del disco. Se deberá especificar en un
cuadro de diálogo el nombre del archivo (con extensión {PRG}) con el programa,
que se puede seleccionar con el ratón o bien escribir su nombre. Cuando el
programa sea cargado en el entorno, aparecerá una ventana de edición con el
listado del mismo. Para ejecutar el programa se puede pulsar la tecla {F10}.

{/}

{Cerrar}

Cierra la ventana de edición seleccionada. El programa pedirá confirmación;
si ha modificado el programa y no lo ha guardado en el disco, seleccione
{Cancelar} y pulse la tecla {F2} para grabar el programa antes de cerrarlo,
ya que al cerrarse la ventana no se guarda automáticamente el programa. Por
lo tanto, si se modifica un listado y después se cierra sin guardarlo
previamente, se perderán las modificaciones.

{/}

{Guardar (Tecla directa : F2)}

Guarda el contenido de la ventana de edición seleccionada en el archivo de
extensión {PRG} correspondiente del disco, es decir, en el archivo indicado
al crear o abrir el programa. El gráfico del puntero del ratón se convertirá
en un reloj de arena por un instante, para indicar que se está realizando la
operación. Si se pretende guardar el programa con otro nombre, en otro
archivo, se debe utilizar la opción {Guardar como...} de este menú.

{/}

{Guardar como...}

Guarda la ventana de edición seleccionada en otro archivo (con otro nombre).
Se abrirá un cuadro de diálogo en el que se debe especificar el nuevo archivo
con extensión {PRG}. Si se elige un nombre de programa existente
anteriormente, el programa pedirá confirmación antes de sobreescribir el
programa del disco con el contenido de la ventana de edición. En realidad la
extensión {PRG} no es obligatoria, aunque sí conveniente.

{/}

{Menú de edición...}

Esta opción da acceso a un nuevo menú de opciones, el {#1252,menú de edición} de
programas.

{/}

{+69,0}{Ejecutar (Tecla directa : F10)}

Compila y ejecuta el programa de la ventana de edición seleccionada. Si el
programa tuviera algún error, el sistema situará el cursor de edición sobre
el mismo e indicará en un diálogo un mensaje descriptivo del error con dos
opciones:

* {Aceptar}. Se debe pulsar este botón cuando se haya comprendido el mensaje
del error, para volver a la ventana de edición y poder corregirlo.

* {Ayuda}. Cuando no se comprenda el mensaje de error emitido por el sistema,
este botón creará una ventana de ayuda en la que se explicará el error
encontrado mucho más detalladamente.

Si se pulsa {Aceptar}, retornando a la edición del programa, aún se está a
tiempo de obtener ayuda extendida sobre el error pulsando la tecla {F1}.

Cuando el programa no tenga errores, el sistema podrá finalizar la
compilación del mismo y ejecutarlo. Para retornar de un programa siempre se
puede pulsar la combinación de teclas {ALT+X}.{-}

{/}

{Compilar (Tecla directa : F11)}

Compila el programa de la ventana de edición seleccionada. No se ejecutará
el programa: esta opción es únicamente para comprobar si un programa tiene
algún error. Si se encuentra algún error, éste se indicará exactamente igual
que en la opción anterior, pudiendo acceder a la ayuda extendida sobre el
mismo cuando sea necesario.

{/}

{Trazar programa (Tecla directa : F12)}

Traza paso a paso el programa de la ventana de edición seleccionada. Se
denomina {trazar} un programa a ejecutarlo poco a poco, sentencia a sentencia
o imagen a imagen, para poder ir comprobando todo lo que va haciendo, cómo
van creándose los procesos, cambiando de valor las variables, etc.

Esto se lleva a cabo, normalmente, cuando un programa no realiza lo que se
pretendía que hiciera y no se sabe por qué, para poder encontrar de esta
forma el punto exacto en el que se encuentra un error del programa.

Con esta opción se accederá al {#1260,Trazador de programas}. También se puede
acceder a él durante la ejecución convencional de un programa pulsando la tecla
{F12} aunque, en este caso, se trazará el programa no desde el principio, sino
desde el punto en el que haya sido interrumpido.

Dentro del trazador de programas se verá el listado del programa ejecutado,
pero no podrá modificarse. Esta es una herramienta avanzada, que no conviene
utilizar hasta que se hayan comprendido bien las bases de la programación en
DIV.

{/}

{+72,0}{Crear instalación...}

La última opción del menú de programas es la utilizada para crear
automáticamente discos de instalación de los juegos creados en DIV Games
Studio. Con estos discos se podrá distribuir los juegos e instalarlos en
otros ordenadores de forma independiente, {sin requerir DIV Games Studio
para su ejecución}.{-}

{/}

{Sobre los derechos de autor. Importante}

Los juegos podrán ser distribuidos libremente, sin tener Hammer Technologies
derecho a {ningún pago o royaltie} por ello. Es posible utilizar los
programas creados en DIV Games Studio con cualquier fin, incluida la venta de
sus derechos a compañías distribuidoras, venta directa, publicaciones
shareware, freeware, etc.

Asimismo, no se obliga a los autores a la inclusión de ninguna mención en los
juegos a DIV Games Studio ni a Hammer Technologies, pudiendo hacerlo si así
lo desean voluntariamente, incluyendo el logotipo de DIV Games Studio o una
referencia al mismo.

El único componente de DIV requerido en las instalaciones es el archivo
{DIV32RUN.EXE}, que contiene la librería de enlace con las funciones internas
utilizadas en los programas. Este archivo será incluido siempre por el
sistema en las instalaciones realizadas. {DIV32RUN.EXE} es un programa
{freeware} de libre distribución.

También se permite la libre creación y distribución de utilidades o
herramientas auxiliares para este programa, para lo cual se muestra en el
{apéndice E} del libro de DIV Games Studio (Manual de usuario) el formato de
los archivos utilizados por DIV Games Studio.

{/}

Para crear los discos de instalación, el sistema debe, primero, compilar el
programa para cerciorarse de que no tiene errores y generar el archivo
ejecutable del juego (un archivo con extensión {EXE}).

Una vez compilado aparecerá un cuadro de diálogo en el cual se puede
configurar el programa de instalación. En la parte superior del mismo
aparecen dos casillas: la de la derecha nos permite definir si se deben crear
subdirectorios en la instalación (en caso contrario todos los archivos del
juego se instalarán en un solo directorio), y la de la izquierda define si se
debe incluir un programa de configuración del sistema sonido.

Este programa de configuración no suele ser necesario; si se decide
incluirlo, el sistema añadirá el último {SETUP_PROGRAM} compilado en el entorno.
Por defecto este programa es {SETUP.PRG}, que se encuentra en el directorio
{SETUP\} de DIV Games Studio, por si se desea modificar o adaptar a un juego en
concreto.

Tras las dos casillas superiores este diálogo para personalizar la
instalación permitirá, mediante una serie de cajas de texto, introducir la
siguiente información:

* {Nombre del programa instalado.} Por defecto aparecerá el nombre del
archivo PRG.

* {Nombre del programador.} Para introducir cualquier mensaje del tipo
"Programa por ..."

* {Copyright y nombre de la compañía.} Se puede introducir cualquier mensaje.

* {Unidad o directorio donde se deben crear los discos de instalación.}
Normalmente será una unidad de disquetes; se deben tener preparados
suficientes disquetes formateados para poder grabar en ellos el juego
comprimido.

* {Directorio por defecto de instalación.} Es el directorio donde, por
defecto, intentará instalarse el juego, a no ser que los usuarios lo cambien.

* {Mensaje que se utilizará como instrucciones de carga.} El sistema sugerirá
un mensaje apropiado, que indique cómo debe ejecutarse el juego una vez
instalado.

Por último, aparecen los botones de {Aceptar} y {Cancelar} para comenzar a
crear los discos de instalación o salir del diálogo sin crearlos.

Las instalaciones creadas de esta forma utilizarán el {Instalador universal}
de DIV Games Studio, que consiste en un programa {freeware}, de libre
distribución. Si se desea utilizar otros instaladores, la mejor forma de
hacerlo es partir de una copia del juego instalada con este Instalador
universal.

En los programas instalados ya no aparecen las ventanas informativas de
errores de DIV, ni hay acceso al {#1260,Trazador de programas} al pulsar la
tecla {F12}. Si se produce un error de ejecución en un programa instalado, se
detendrá el programa, retornando al sistema.

# ─────────────────────────────────────────────────────────────────────────────

{.1252,El menú de edición}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+17,0}Este menú cuenta con una serie de opciones básicas para la edición, indicando
en todas ellas teclas directas, por lo que una vez que se aprendan no será
necesario acceder a este menú.

Existen más comandos de edición al margen de los aquí mostrados; ver
{#1294,comandos en el editor de programas} (comandos de teclado).
Las opciones que engloba el menú de edición son las siguientes:{-}

{/}

{Borrar línea (Tecla directa : Control+Y)}

Elimina la línea del programa en la que se encuentra el cursor de edición.

{/}

{Marcar bloque (Tecla directa : ALT+A)}

Marca el inicio o el final de un bloque de texto. Para marcar un bloque se
deben marcar ambos extremos con este comando; el orden es indiferente.
También se soporta el marcado de bloques del estándar EDIT, con mayúsculas y
con los cursores.

{/}

{Desmarcar (Tecla directa : ALT+U)}

Desmarca el bloque de texto. Los bloques seleccionados con el comando
anterior son persistentes, es decir, que permanecen hasta que se borren o se
desmarquen. Los bloques del estándar EDIT se desmarcan solos, al mover el
cursor.

{/}

{Copiar (Tecla directa : ALT+C)}

Copia el bloque de texto marcado a partir de la posición actual. Primero se
debe marcar el bloque original y situar el cursor en la posición en la que se
quiere insertar. Se realizará una copia del texto, permaneciendo marcado el
mismo por si se quieren realizar más copias.

{/}

{Mover (Tecla directa : ALT+M)}

Mueve el bloque de texto marcado a la posición actual. Esta operación es
similar a la anterior, salvo que se borrará el texto original tras copiarse a
la posición actual. El texto movido permanecerá también marcado, por lo que
se puede seguir moviendo o copiando.

{/}

{Borrar (Tecla directa : ALT+D)}

Borra el bloque de texto que se ha marcado. Esta operación no podrá
deshacerse, por lo que se debe utilizar con cuidado. Si se borra un bloque
grande por accidente, puede convenir volver a {Abrir} el programa del disco
(sin guardar la copia existente), marcar el bloque borrado en la nueva
ventana cargada, y copiarla a la ventana en la que se haya borrado
accidentalmente.

{/}

{+91,0}{Ir a... (Tecla directa : F5)}

Salta directamente a uno de los procesos del programa, es decir, sitúa el
cursor de edición de la ventana del programa en el inicio de uno de los
procesos.

Al utilizar este comando aparecerá un cuadro de diálogo con la lista de los
procesos encontrados en el programa, pudiéndose seleccionar uno con el ratón,
o bien pulsar la tecla {ESC} para permanecer en la posición actual.

Una casilla permitirá indicar el orden el que se muestra la lista de procesos,
siguiendo el orden en el que aparecen en el programa, o bien en orden
alfabético.

Los procesos son algo similar a las funciones de otros lenguajes, pero en DIV
están orientados hacia el control de los gráficos de los juegos (también
llamados sprites). Es decir, que básicamente se trata de bloques del programa
que rigen el comportamiento de un gráfico, o un tipo de gráficos, del juego.{-}

{/}

{+92,0}{Buscar... (Tecla directa : ALT+F)}

Busca una cadena de texto en el programa. Esta opción se utilizará para
localizar un punto del programa o un nombre dentro del mismo. Aparecerá un
diálogo con un cuadro de texto en el que se debe introducir la secuencia de
caracteres que se pretende localizar.{-}

Este diálogo contiene dos casillas para definir el tipo de búsqueda que se
debe realizar; éstas son las siguientes:

* {Palabra completa.} Indica (cuando está activada) que la cadena introducida
debe buscarse como una palabra completa y no como parte de una palabra mayor
(por ejemplo, que no se debe encontrar 'palabra' si pone 'pala').

* {Mayúsculas/minúsculas.} Indica que el texto se debe encontrar exactamente
como se ha escrito, que se debe diferenciar entre letras mayúsculas y
minúsculas.

Para iniciar la búsqueda del texto se debe pulsar {Aceptar} en este cuadro.
La búsqueda se realizará siempre a partir de la posición actual del cursor de
edición, por lo que si se quiere buscar el texto por todo el programa se
deberá situar primero el cursor al comienzo del mismo, en la línea 1 y
columna 1 (esto se puede hacer pulsando {Control+Re.Pág} y después {Inicio}).

{/}

{Repetir (Tecla directa : ALT+N)}

Repite la última búsqueda. Vuelve a buscar la última cadena de texto que se
buscó, a partir de la posición actual, es decir, busca la siguiente
ocurrencia de la misma en el programa.

Cuando no existan más ocurrencias del texto buscado en las líneas restantes
del programa, el sistema advertirá de ello.

{/}

{+93,0}{Reemplazar... (Tecla directa : ALT+R)}

Reemplaza una cadena de texto por otra en el programa. Esta opción se puede
utilizar, por ejemplo, para sustituir un nombre (de una variable, proceso,
etc.) por otro.

Se mostrará un diálogo similar al utilizado para buscar un texto, pero con
una segunda caja de texto en la que se debe indicar el texto con el que se
debe sustituir el texto indicado en la primera.

Nuevamente aparecen las dos casillas anteriores, cumpliendo la misma función.
Para sustituir un nombre por otro es conveniente activar la casilla de
Palabra completa.

La sustitución de texto se realizará a partir de la posición actual en el
programa del cursor de edición, ignorándose las ocurrencias anteriores.
Cuando se encuentre el texto a reemplazar, antes de hacerlo, el programa
ofrecerá las siguientes opciones en un diálogo (resaltando el texto
encontrado en la ventana del programa):

* {Si.} Para sustituir el texto en la posición resaltada y seguir buscando.

* {No.} Para no sustituir la ocurrencia resaltada, pero seguir buscando.

* {Todo.} Para sustituir automáticamente el resto de las ocurrencias,
incluyendo la actualmente resaltada.

* {Cancelar.} Para cancelar la operación de reemplazo de texto (no se harán
más sustituciones).

Si se pulsa la tecla {ESC} o se cierra este diálogo, el programa lo
interpretará también como que se quiere terminar la operación de reemplazo.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1253,El menú de paletas}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+73,0}Este menú controla las operaciones relacionadas con la paleta de colores que
está usando DIV Games Studio. Permite cargar y grabar archivos de paleta
(con extensión {PAL}), editarla, ordenarla, etc.

Los conceptos básicos sobre la paleta de colores se exponen en
"{#1263,Paletas de colores}". En el entorno siempre hay una única paleta de color activa; para
visualizarla se debe utilizar la última opción de este menú ({paletas \
mostrar paleta}). Tener a la vista la paleta activa en el entorno es
conveniente para orientarse a la hora de realizar operaciones con ella.

Conviene definir al inicio de un nuevo proyecto (juego) cuál es la paleta de
colores que va a utilizar, ya que durante el juego todos los gráficos que se
visualicen en una misma pantalla deben haberse creado con la misma paleta de
colores. En caso contrario, éstos se visualizarían incorrectamente.{-}

{/}

{Abrir paleta...}

Carga la paleta de colores de un archivo. Al activarla se abrirá un cuadro de
diálogo en el que se debe indicar un archivo de uno de los siguientes tipos:
paletas ({PAL}), ficheros de gráficos ({FPG}), mapas gráficos ({MAP, PCX o
BMP}) o fuentes de letra ({FNT}). Si hay gráficos cargados en el escritorio
de DIV Games Studio el sistema preguntará si deben adaptarse a la nueva
paleta cargada: si se responde {Aceptar} pueden perder calidad, por ello, la
alternativa es cerrarlos y volver a abrirlos.

{/}

{Guardar paleta...}

Con esta opción se puede grabar en el disco un archivo con la paleta de
colores utilizada actualmente. Se abrirá un cuadro de diálogo en el que se
debe indicar el nombre del archivo en el que se va a guardar la paleta (se
utilizan para ello archivos con extensión {PAL}). No es posible guardar la
paleta de colores en ficheros de gráficos, mapas o fuentes. En los archivos
de paleta se guarda, además, información sobre las reglas de color definidas
dentro del editor gráfico.

{/}

{+74,0}{Editar paleta...}

Al elegir esta opción se abrirá un cuadro de diálogo con el editor de
paletas. En él se puede modificar la paleta actual del sistema o definir una
nueva. Mientras se edita la paleta pueden aparecer incorrectamente los
colores del escritorio; esto es normal y se solucionará al salir de este
diálogo.

Ocupando la mayor parte del cuadro aparecen todos los colores de la paleta
activa. Un pequeño cuadrado marcará uno de estos colores; éste es el color
seleccionado para edición, para seleccionar otro color se debe pulsar con el
ratón sobre él. En la parte derecha aparece la siguiente información sobre el
color seleccionado:

* Número de orden del color dentro de la paleta, éste aparece en decimal como
un número de 0 a 255, y en hexadecimal, de 00 a FF.

* Las componentes rojo, verde y azul que forman el color, como números de 0 a
63.

* Tres barras de desplazamiento verticales, que se pueden utilizar para
modificar los tres componentes del color, en el mismo orden anterior.

En la parte inferior del cuadro aparecen tres casillas con la siguiente
función:

* {Gama:} Se utiliza para definir una gama gradual de colores; se debe pulsar
sobre el primer color de la gama y definirlo con las barras de
desplazamiento. Después, hacer lo mismo con el último color de la gama y,
finalmente (con el último color seleccionado) seleccionar esta casilla y
pulsar nuevamente sobre el primer color. El sistema definirá los colores
intermedios con una gama gradual.

* {Copiar:} Para copiar un color a otra posición de la paleta se debe primero
seleccionar el color, después esta casilla y finalmente la posición destino.

* {Cambiar:} Funciona de forma similar a copiar, sólo que intercambiará los
colores origen y destino, en lugar de copiar el origen al destino.

Finalmente, tres botones que permiten de izquierda a derecha, validar la
edición de paleta realizada, deshacer la última modificación y cancelar la
edición (deshacer todos los cambios desde que se entró en el editor).{-}

{/}

{+75,0}{Ordenar paleta...}

Permite ordenar paletas de colores. Esta opción es útil para editar mapas que
provengan de otros programas gráficos o de render, y que tengan una paleta de
colores desordenada. Esta operación facilitará el trabajo con estos mapas
dentro del editor gráfico, al poder localizar los colores más fácilmente. Un
cuadro de diálogo mostrará cuatro posibles ordenaciones de los colores de la
paleta, debiendo pulsar con el ratón en la ordenación que se considere más
apropiada. Este diálogo finaliza con dos botones que permiten confirmar la
selección realizada o cancelarla.{-}

{/}

{Fusionar paletas...}

Ésta es una operación avanzada; su utilidad consiste en crear una paleta de
colores a partir de dos. Se debe utilizar cuando se quieran utilizar en un
juego gráficos con paletas diferentes de forma simultánea. Primero, se debe
cargar en el entorno una de las paletas y, después, utilizar esta opción
para seleccionar un archivo con la otra.

El sistema creará una paleta mixta entre ambas; tras esta operación lo mejor
es grabar esta paleta en un archivo de paleta ({PAL}) para tenerla localizada
y no perderla. Tras esto, se deben cargar de nuevo los gráficos con las
paletas de color anteriores indicando que no deben cargarse sus paletas, sino
que deben adaptarse a la paleta del sistema para, finalmente, una vez
verificado que los gráficos de ambas paletas quedan bien con la nueva paleta,
volver a grabarlos en sus respectivos ficheros.

{/}

{+76,0}{Mostrar paleta}

Visualiza la paleta de colores activa en el entorno. Esta opción creará una
nueva ventana en el escritorio, donde se podrá ver en todo momento cuál es la
paleta de colores activa. Θnicamente puede haber una paleta de colores activa
en cada momento.{-}


# ─────────────────────────────────────────────────────────────────────────────

{.1254,El menú de mapas}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+77,0}Este menú controla las operaciones relacionadas con los mapas. Los mapas,
también denominados gráficos o bitmaps (mapas de bits), son simplemente
imágenes de cualquier tamaño que pueden ser utilizadas en los juegos como
fondos, muñecos, objetos, pantallas, etc. Este menú da acceso a la carga y
grabación de mapas en disco, así como al editor gráfico, que es la
herramienta utilizada para crear o modificar estas imágenes.

Se pueden manejar, cargar múltiples mapas en el escritorio, etc, la única
limitación es que todos ellos utilicen la misma paleta de colores. Si dos
mapas deben utilizar paletas diferentes, se debe cerrar uno antes de abrir
el otro.

Al margen de las opciones de este menú, se pueden realizar otras operaciones
con las ventanas de mapas, si se quieren arrastrar se pulsa sobre ellas con
el botón izquierdo y, sin soltarlo, se mueve el ratón hasta la posición
destino. Estas operaciones son las siguientes:

* {Realizar una copia del mapa.} Arrastrar la ventana hasta el tapiz de fondo
del escritorio (a una zona de pantalla en la que no haya ninguna ventana).

* {Pegar un mapa en otro.} Arrastrar una ventana de mapa a otra; se entrará
en el editor gráfico donde se podrá pegar el mapa en la posición y
condiciones deseadas.

* {Cerrar un mapa.} Arrastrar la ventana hasta la papelera (primero se debe
activar la papelera con la opción {sistema \ papelera}). El sistema cerrará
el mapa sin pedir confirmación.

* {Incluir un mapa en un fichero de gráficos.} Arrastrar la ventana del mapa
hasta la ventana del fichero.

Varias opciones de este menú interaccionan únicamente con un mapa, aunque
haya muchos cargados. La acción se realizará sobre el mapa seleccionado entre
todos ellos; para seleccionar un mapa se debe pulsar sobre él con el botón
izquierdo del ratón.{-}

{/}

{+94,0}{Nuevo...}

Crea una nueva ventana con un mapa gráfico. La única información necesaria
para poder crear un mapa nuevo es el ancho y alto en puntos del mismo, que
se pedirá en un cuadro de diálogo. Cualquier tamaño, desde 1x1, es válido
con la única limitación de la memoria disponible en el sistema. Tras
seleccionar el tamaño y pulsar {Aceptar} aparecerá una nueva ventana de mapa
vacía (en negro) en el escritorio. Para editar el contenido de esta ventana
se puede realizar una doble pulsación con el botón izquierdo del ratón sobre
la misma.{-}

{/}

{Abrir mapa...}

Carga un mapa de un archivo del disco. El formato propio de DIV para los
mapas son los archivos de extensión {MAP}, pero pueden importarse con esta
opción archivos con extensión {PCX} y {BMP}, siempre que se trate de imágenes
en {256 colores}.

{/}

{Cerrar}

Cierra una ventana con un mapa. El sistema pedirá confirmación antes de
cerrar una ventana con un mapa. Si se desea guardar el contenido de la
ventana se debe utilizar la opción {Guardar...} previamente, para actualizar el
archivo del disco que contiene la imagen. Una vez cerrado un mapa, la única
forma de recuperarlo es volver a cargar el archivo (si ha sido guardado
previamente).

{/}

{Cerrar todos}

Esta opción cierra todas las ventanas de mapas que hubiera cargadas en el
escritorio, {excepto aquellas que hayan sido minimizadas}. El sistema pedirá
confirmación previamente. Esta opción es útil cuando se tiene el escritorio
lleno de mapas que han sido incluidos en un fichero de gráficos, o mapas del
generador de explosiones, para evitar tener que cerrarlos individualmente.

{/}

{Guardar}

Guarda el contenido actual del mapa seleccionado en su archivo; el puntero
del ratón aparecerá momentáneamente como un reloj de arena, para indicar que
se está realizando la operación. Si el mapa no tuviera un archivo en el
disco, el sistema mostrará un cuadro de diálogo en el que se debe especificar
un nombre para el nuevo archivo. Para guardar un mapa en otro archivo se debe
utilizar la opción {Guardar como...} de este menú.

{/}

{Guardar como...}

Esta opción permite guardar el contenido de la ventana de mapa seleccionada
en un nuevo archivo del disco. Aparecerá un cuadro de diálogo en el que se
debe especificar el nombre del archivo. Se pueden grabar archivos {MAP, PCX}
o {BMP} en función de la extensión que se le dé al nombre de archivo. Por
defecto, se grabarán archivos {MAP}, el formato propio de {DIV}. En los
programas creados en {DIV} únicamente se puede utilizar este formato, no
siendo posible cargar en ellos imágenes de archivos {PCX} o {BMP}.

{/}

{+78,0} {Reescalar...}

Reescala el mapa seleccionado a un nuevo tamaño, es decir, amplia o reduce la
imagen.Aparecerá un cuadro de diálogo en el que se debe introducir el nuevo
tamaño; en este aparecen dos casillas:

* {Porcentajes.} Por defecto, el nuevo tamaño se especificará en puntos, pero
si se activa esta casilla se puede entonces indicar en forma de porcentaje,
como un número entero. Por ejemplo, 100 es el tamaño original, 50 la mitad y
200 el doble.

* {Escala de grises.} La nueva copia del mapa se creará en color por defecto,
pero se puede activar esta casilla para crearla en blanco y negro.

En los cuadros de texto {Ancho} y {Alto} se deben introducir los datos de
reescalado para los ejes horizontal y vertical. Tras indicar estos valores,
se debe pulsar {Aceptar} y el sistema creará el nuevo mapa.{-}

{/}

{Editar mapa}

Edita el mapa seleccionado. Se entrará directamente en el editor gráfico.
Esta operación puede realizarse también con una doble pulsación del botón
izquierdo sobre la ventana del mapa. Para salir de este editor se debe
pulsar el botón derecho del ratón o la tecla {ESC}.

{/}

{+79,0}{Generador de explosiones}

Esta opción da acceso a un cuadro de diálogo para generar automáticamente una
serie de fotogramas para una explosión. Cada uno de los fotogramas (o
imágenes) se creará en un mapa independiente. Los mapas se crearán con la
paleta de colores activa en el entorno, y si, después, no se quieren
conservar los mapas creados puede convenir utilizar la opción {Cerrar todos}
para eliminarlos.

En la parte superior del diálogo aparecen dos cuadros de texto en los que se
debe introducir el {Ancho} y {Alto} en puntos de los mapas que se van a
generar. Cuanto mayores sean estos mapas, más tardará el generador en
completar la secuencia de imágenes que conforman la explosión.

Pulsando sobre los cuadros que aparecen bajo el texto {Color} aparecerá un
diálogo con la paleta de colores, para poder seleccionar de este modo los
colores inicial (el más oscuro), medio y final (el más claro) de la
explosión, respectivamente. El generador utilizará tantos colores intermedios
como encuentre en la paleta activa.

Tres casillas denominadas {Tipo A}, {Tipo B} y {Tipo C} permiten elegir entre
tres algoritmos diferentes para generar la explosión, por orden de
complejidad, siendo el primer tipo el más básico y homogéneo, y el último el
más complejo.

Contiguos a estas casillas aparecen otros dos cuadros de texto. En el
primero, denominado {Imágenes}, se debe introducir el número de fotogramas de
los que debe constar la secuencia completa de la explosión. El segundo cuadro
de texto define el efecto de {Granulado} aplicado a la explosión; cuanto
mayor sea este valor, más "ruido" o "vibración" tendrá la explosión.

Cada vez que se genere una explosión ésta será diferente aunque se
introduzcan exactamente los mismos parámetros en este cuadro de diálogo; por
ello, se recomienda realizar varias pruebas hasta obtener la secuencia
definitiva.

Para visualizar la explosión animada se pueden utilizar las posibilidades de
animación del editor gráfico. Para ello se deberán ordenar las ventanas con
los fotogramas de la explosión (situando unas sobre otras, en orden), editar
la primera (con una doble pulsación del ratón sobre ella) y, una vez dentro
del editor, utilizar las teclas {TAB} y {Mayúsculas+TAB} para ver la
animación. Se puede utilizar la tecla Z para variar la escala a la que se
visualiza la animación y {ESC} para salir del editor gráfico.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1255,Menú de ficheros}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+80,0}Este menú controla las operaciones realizadas con los ficheros de gráficos,
como crear nuevos ficheros, o cargar (abrir) los mapas de los mismos. Los
{ficheros FPG de gráficos} son archivos que contienen librerías o colecciones
completas de mapas.

Las únicas acciones de ficheros que no puede realizarse mediante este menú
son:

* {Añadir mapas a un fichero}, Esto debe realizarse arrastrando las ventanas
de los mapas a la ventana del fichero.

* {Copiar mapas de un fichero a otro.} Para lo que deben arrastrarse desde la
lista de un fichero hasta la del otro.

Los ficheros no se cargan en la memoria del ordenador pues suelen ocupar
mucho espacio, sino que su información permanece siempre en los {archivos con
extensión FPG} del disco que los contienen. Por lo tanto, no existe ninguna
opción para guardar los ficheros, ya que {éstos siempre están guardados}, es
decir, lo que se muestra en pantalla es exactamente lo que hay en el archivo
del disco.

{Importante:} Todos los mapas de un fichero deben usar {la misma paleta de
colores}, debiéndose adaptar a la paleta del fichero aquellos mapas que
utilicen otra diferente, si quieren incluirse en el mismo.{-}

{/}

{Nuevo...}

Crea un nuevo fichero FPG en el disco para contener mapas gráficos con la
paleta activa en el entorno. En un cuadro de diálogo se debe especificar el
nombre del archivo; el sistema le añadirá la extensión {FPG} automáticamente.
Si se especifica un nombre de fichero ya existente, se preguntará si se desea
sobreescribir éste, en cuyo caso se borrarán todos los mapas que contuviera
anteriormente el fichero.

{/}

{Abrir fichero...}

Abre una nueva ventana a partir de un fichero FPG del disco. En el cuadro de
diálogo de manejo de archivos se debe seleccionar el nombre de un archivo con
extensión FPG. Si el fichero tiene una paleta diferente a la activa en el
entorno en ese momento, el sistema ofrecerá como opciones cargar la nueva
paleta o cerrar el fichero. Se puede también abrir el fichero sin cargar su
paleta pero no se recomienda hacerlo, a no ser que sea un usuario experto.

{/}

{Cerrar}

Cierra la ventana de fichero seleccionada. Como el contenido de los ficheros
está siempre guardado en disco, nunca se perderá la información (los mapas)
de los mismos. Por ello, el sistema no pedirá confirmación para cerrar un
fichero, ya que se puede volver a recuperar siempre abriéndolo de nuevo.

{/}

{Guardar como...}

Esta opción permite guardar el fichero seleccionado con otro nombre (en otro
archivo FPG), es decir, que se hará una copia del fichero con un nuevo
nombre. Aparecerá un cuadro de diálogo en el que se debe introducir el nombre
del nuevo archivo FPG. Nuevamente, si se indica el nombre de un archivo ya
existente, se sustituirá su contenido por el contenido del fichero
seleccionado en el entorno.

{/}

{Cargar marcados}

Carga los mapas marcados en el fichero seleccionado al escritorio. Al
utilizar esta opción debe estar marcada la casilla {Marcar/Arrastrar} de la
ventana del fichero para, de esta forma, poder marcar antes los mapas que
quieren cargarse (abrirse) de la lista incluida en el fichero (pulsando con
el ratón sobre ellos). Se pueden desmarcar mapas pulsando nuevamente sobre
ellos. Se crearán tantas ventanas de mapas como se marquen en el fichero.
Esta opción resulta útil para modificar en el editor gráfico estos mapas y,
después, volver a arrastrarlos nuevamente al fichero.

Para cargar mapas individualmente, de uno en uno, se pueden arrastrar estos
directamente desde la ventana del fichero al escritorio.

{/}

{Borrar marcados}

Elimina los mapas marcados en el fichero seleccionado. Esta opción se
utiliza para quitar mapas de un fichero cuando ya no son necesarios. Deben
marcarse previamente los mapas exactamente igual que en la opción anterior.
Estos mapas no podrán recuperarse una vez borrados.

Para borrar mapas individualmente pueden arrastrarse desde la ventana del
fichero hasta la papelera del sistema (ésta se muestra con la opción {sistema
\ papelera}).


# ─────────────────────────────────────────────────────────────────────────────

{.1256,Menú de fuentes}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+81,0}Este menú permite realizar acciones relacionadas con las fuentes de letras de
los juegos (o tipos de letra); entre ellas acceder al generador de fuentes
utilizado para crear nuevas fuentes. Las fuentes de letras se utilizan dentro
del editor gráfico y en los juegos, para escribir textos.

Asimismo, las fuentes se muestran en unas pequeñas ventanas que indican qué
conjuntos de caracteres tienen definidos. Los caracteres se dividen en los
siguientes grupos: dígitos numéricos, letras mayúsculas, letras minúsculas,
símbolos y caracteres extendidos.

Para visualizar una muestra de los caracteres contenidos en una fuente, se
debe pulsar con el botón izquierdo del ratón sobre su ventana.

Las fuentes se guardan en el disco en archivos {FNT} y se adaptan a la paleta
del entorno al cargarse y siempre que se cambie la paleta activa. Para ver
una fuente con su paleta original, se debe utilizar la opción {paletas \
abrir...} indicando el nombre del archivo FNT.

Las ventanas de fuentes siempre se corresponden con un archivo FNT del disco,
por lo tanto, no existe ninguna opción para guardar las fuentes, ya que éstas
{siempre están guardados}, es decir, lo que se muestra en pantalla es
exactamente lo que hay en el archivo del disco.{-}

{/}

{+82,0}{Generar fuente...}

Esta opción creará una nueva ventana con el generador de fuentes de letras.
Con esta herramienta se pueden crear nuevos tipos de letra para los juegos de
forma fácil y rápida. Para generar una nueva fuente se deben seguir los
siguientes pasos:

* Primero, seleccionar el nuevo archivo FNT en el que se debe guardar la
fuente de letra creado. Para ello, se debe pulsar en {Nueva fuente}, en el
botón con puntos suspensivos. Aparecerá un cuadro de diálogo para introducir
el nombre del archivo. Por defecto, la fuente se generará en el archivo
{NUEVOFNT.FNT} válido para realizar pruebas.

* Segundo, elegir el aspecto de la fuente. Pulsando en {Aspecto}, en el botón
con puntos suspensivos, se accederá a un diálogo para seleccionar el aspecto
de la fuente. Se debe seleccionar uno de los archivos con extensión {IFS} de
la lista. Pulsando sobre cualquiera de ellos se podrá ver una muestra en el
propio diálogo. Una vez localizado el aspecto deseado, se debe pulsar el
botón de {Aceptar}.

* En la parte superior derecha del cuadro, dos cajas de texto permiten
definir el tamaño de los caracteres de la fuente. Se debe definir el {Ancho}
y el {Alto} de los mismos como cualquier número entre 16 y 128. Para tamaños
menores a 16x16 se pueden utilizar únicamente los mostrados en la lista
contigua (8x8, 10x10, 12x12 o 14x14) que se pueden seleccionar pulsando
sobre la misma. Para fuentes mayores de 16x16 se pueden indicar dos medidas
diferentes para el ancho y el alto, deformándose el aspecto original.

* En la sección {Fuente} (central izquierda) seleccionar el color de tinta para
la fuente pulsando sobre el cuadro de color, o bien {arrastrar un mapa con la
textura} hasta este cuadro. Si se define de esta forma una textura como
relleno de la fuente de letras, se podrá seleccionar en la casilla {Mosaico}
si dicha textura debe repetirse cíclicamente; por defecto (sin la casilla
activada) la textura se reescalará al tamaño de los caracteres de la fuente.
Es decir, que para utilizar una textura en una fuente se debe primero abrir o
crear el mapa con la textura, y después arrastrarlo al generador de fuentes.

* En la sección {Reborde} (central media) se debe definir si se debe crear un
borde en los caracteres de la fuente; en caso afirmativo se tiene que
especificar en primer lugar el ancho en puntos de este reborde, utilizando
los botones{ -} y{ +}. A continuación, donde aparece una {X} entre otros dos
botones{ -} y{ +} se podrá especificar la dirección de la iluminación del
reborde (el símbolo {X} indica que no se va a iluminar el reborde). Por
último, se especificará el color o textura del reborde de la misma forma que
en la sección anterior.

* En la sección {Sombra} (central derecha) se define la sombra de los
caracteres; primero se debe indicar el desplazamiento horizontal de la misma
(en puntos), teniendo en cuenta que los números positivos están hacia la
derecha, y después el desplazamiento vertical (ahora los positivos están
hacia abajo). Si se dejan ambos desplazamientos a cero, no se crearán
sombras. Después, se debe elegir nuevamente el color o textura para las
sombras. Normalmente se especifica un color oscuro como relleno de las
sombras, pero {no el primer color de la paleta}, ya que éste es el color
transparente y, por lo tanto, no se visualiza.

* Con el botón denominado {Prueba} se puede ver en cualquier momento una
muestra de la fuente resultante para, de esta forma, ajustar mejor los
parámetros anteriores. En el cuadro de texto contiguo a este botón se puede
introducir el texto con el que se debe realizar la prueba.

* Finalmente, se debe pulsar en el botón {Generar} para que el sistema cree
en el {archivo FNT} indicado la nueva fuente de caracteres a color. Aparecerá
entonces un diálogo de confirmación en el que, además, se deben indicar
cuáles de los cinco conjuntos de caracteres se deben incluir en la fuente,
activando las correspondientes {casillas}. Para crear una fuente completa, se
deben activar todas las casillas. Si, por ejemplo, únicamente se van a
utilizar los dígitos numéricos de la fuente es mejor crearlo sólo con esos
caracteres, ya que de esta forma el archivo FNT ocupará mucho menos espacio
en el disco y en la memoria del ordenador.

Terminado el proceso, aparecerá una nueva ventana de fuente en el escritorio
del entorno, permaneciendo el generador de fuentes en el escritorio hasta que
se cierre su ventana.

Para cerrar el generador o cancelar el proceso de creación de una fuente, se
puede pulsar el botón {Cerrar} de la esquina inferior derecha del mismo; no
obstante, si se pretende continuar con el mismo más adelante, será mejor
minimizar la ventana del generador, ya que de esta forma no se perderá la
información introducida en el mismo hasta el momento.{-}

{/}

{Abrir fuente...}

Esta opción permite abrir un archivo FNT del disco con una fuente de
caracteres creada anteriormente para realizar alguna operación con ella o
utilizarlo en el editor gráfico. Un cuadro de diálogo para el manejo de
archivos nos permitirá seleccionar el archivo, entonces se creará una nueva
ventana de fuente en el escritorio. Se podrá visualizar una muestra de la
fuente pulsando con el ratón sobre esta ventana.

{/}

{Cerrar}

Cierra la ventana de fuente seleccionada. No se pedirá confirmación, ya que
el contenido de estas ventanas siempre está actualizado en el disco, por lo
tanto, siempre se podrá volver a recuperar la fuente volviéndolo a cargar del
archivo FNT del disco. Dentro del editor gráfico, en la opción de escribir
texto, se utilizará la fuente del editor de programas cuando no exista
ninguna fuente en el escritorio del entorno.

{/}

{+83,0}{Escribir texto...}

Crea un mapa nuevo con un texto escrito con la fuente seleccionada. Aparecerá
un cuadro de diálogo dentro del cual se debe introducir el texto que debe
contener el mapa gráfico. El sistema creará una nueva ventana de mapa con
este texto escrito. Esta opción no estará disponible si no hay en el
escritorio ninguna ventana de fuente seleccionada.
Esta opción es útil cuando se quiera utilizar una fuente de caracteres en un
juego únicamente para mostrar uno o dos mensajes, ya que ocuparán mucho menos
espacio los gráficos con estos textos que la fuente completa de caracteres.{-}

{/}

{Exportar mapa}

Las opciones de exportar e importar una fuente desde un mapa permitirán
retocar manualmente las fuentes creadas con el generador en el editor
gráfico. Esta opción creará una nueva ventana de mapa con todos los
caracteres de la fuente seleccionada. Para editar, entonces, los caracteres
de la fuente se debe realizar una doble pulsación del botón izquierdo del
ratón sobre la ventana del mapa, entrando en el editor. Es muy importante
respetar los márgenes exteriores de los caracteres, es decir, que se puede
retocar cada carácter pero respetando sus límites. Los caracteres no
incluidos en la fuente estarán representados en este mapa con un punto de
color 0 (el primer color de la paleta, que es el color transparente).

{/}

{Importar mapa}

Esta opción permite volver a obtener el {archivo FNT} a partir del mapa con
los caracteres. Si el mapa no es una fuente con todos sus caracteres, esta
opción no podrá obtener el archivo FNT a partir del mismo.

Los mapas con fuentes tienen un formato que debe ser respetado, con un color
para definir los márgenes exteriores (que puede ser cualquier color no
utilizado en la fuente) y 256 cajas cuadradas con los caracteres definidos en
la fuente ordenadas según su código ASCII, indicándose los caracteres no
definidos como cajas de 1 punto por 1 punto.

Si durante la edición de los caracteres en el editor gráfico se han
modificado los márgenes de los mismos, es posible que esta opción no pueda
volver a obtener la fuente. El sistema comprueba que en este mapa haya un
color exterior y, dentro de éste, 256 cajas ordenadas de izquierda a derecha
con un margen entre ellas de, al menos, un punto (del color exterior).

Si se respetan estas reglas, se puede incluso crear fuentes de letras a
partir de cero en el editor gráfico para, después, importarlas con esta
opción.

# ─────────────────────────────────────────────────────────────────────────────

{.1257,Menú de sonidos}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+84,0}Este menú permite controlar las ventanas de efectos de sonido y realizar las
operaciones básicas con ellas, como cargar efectos, guardarlos con otro
nombre o escucharlos.

Las ventanas de sonidos siempre se corresponden con un archivo PCM del disco.
Por lo tanto, no existe ninguna opción para guardar los sonidos, ya que éstos
{siempre están guardados}, es decir, lo que se muestra en pantalla es
exactamente lo que hay en el archivo del disco.{-}

{/}

{Abrir sonido...}

Carga un efecto de sonido de un archivo del disco. Un cuadro de diálogo
permitirá indicar el nombre de un archivo con extensión {PCM} o {WAV}, no
obstante, cuando se cargue un archivo {WAV}, el sistema creará
automáticamente otro archivo con el mismo nombre pero con extensión (y
formato) {PCM}, ya que éste es el único formato permitido para las ventanas
de sonidos. Se creará entonces la nueva ventana de sonido que mostrará el
contenido del archivo {PCM} al que representa.

{/}

{Cerrar}

Cierra el efecto de sonido seleccionado. No se pedirá confirmación, ya que el
contenido de la ventana está siempre actualizado en el archivo del disco (en
esta primera versión del programa no se pueden editar los efectos de sonido).
Por ello, siempre se podrá recuperar esta ventana volviendo a abrir el
archivo del disco.

{/}

{Guardar como...}

Guarda el efecto de sonido seleccionado en otro archivo del disco, con otro
nombre. Aparecerá un cuadro de diálogo en el que se debe introducir el nombre
del nuevo archivo PCM, no siendo posible exportar sonidos a ficheros WAV. Si
se especifica el nombre de un archivo ya existente, el sistema pedirá
confirmación antes de sobreescribir el contenido de dicho archivo.

{/}

{Probar sonido}

Emite el efecto de sonido por el sistema de audio del ordenador. Se oirá
entonces el efecto de sonido seleccionado del escritorio. Esta acción también
se puede realizar pulsando con el ratón sobre la ventana del sonido.

# ─────────────────────────────────────────────────────────────────────────────

{.1258,Menú de sistema}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

{+85,0}Desde este menú se controlan las acciones relacionadas con el propio entorno
de ventanas. Desde él, se puede configurar su apariencia (modo de vídeo,
fuentes, colores, tapiz de fondo, etc.), acceder a utilidades auxiliares,
solicitar información sobre el sistema o salir del mismo.{-}

{/}

{+86,0}{CDiv Player}

Esta opción mostrará en pantalla el reproductor de CD-Audio. Con esta
herramienta se puede controlar la reproducción de discos compactos de música
con la unidad de CD-ROM del ordenador. En la parte superior de la ventana del
reproductor se muestra información sobre la canción seleccionada y el tiempo.
Los botones de control permiten, de izquierda a derecha: pasar a la canción
anterior, rebobinar, parar la reproducción (stop), iniciar la reproducción
(play), avanzar y pasar a la siguiente canción.

Una vez iniciada la reproducción en una canción, ésta continuará hasta el
final del disco. Si una vez iniciada la reproducción se cierra la ventana del
reproductor, ésta no se detendrá; no obstante, también puede minimizarse el
reproductor.{-}

{/}

{+87,0}{Reloj}

Esta opción mostrará en pantalla un reloj con la hora actual. Éste aparecerá
dentro de una ventana que puede dejarse activa en todo momento, arrastrarse
hasta otra posición o cerrarse. Si se minimiza la ventana, el texto del icono
de la misma seguirá mostrando la hora actualizada.{-}

{/}

{+88,0}{Papelera}

Esta opción mostrará la ventana de la papelera en el escritorio. La papelera
sirve para borrar ventanas de mapas o mapas de ventanas de ficheros que sean
arrastradas hasta ella. No se pedirá confirmación antes de borrar los mapas
que sean arrastrados a la papelera.{-}

{/}

{Modo de vídeo... / Tapiz de fondo... / Configuración}

Estas tres opciones, permiten configurar la apariencia del entorno gráfico
de ventanas.

{Configuración del entorno}

{/}

{Fijando un modo de vídeo}

La opción {Sistema \ Modo de vídeo...} da acceso a un cuadro de diálogo que
permite modificar la resolución utilizada por el entorno gráfico de DIV
Games Studio.

Las resoluciones de vídeo se indican como el número de puntos en horizontal
y vertical existentes en la pantalla en dicho modo y varían entre 320x200
(baja resolución) y 1024x768 (máxima resolución). Para seleccionar una nueva
resolución se debe pulsar sobre la lista que aparecen en el cuadro y después
en el botón de {Aceptar}.

{+33,0}{Importante}: Algunos de estos modos de vídeo pueden visualizarse
incorrectamente en algunos equipos; en estos casos lo primero que debe
hacerse es salir del entorno pulsando la combinación {ESC+Control} y,
después, volver a entrar en DIV en el modo a prueba de fallos. Para ello se
debe, desde la línea de comandos de {MSDOS} y en el directorio (carpeta) en
la que se haya instalado el programa, ejecutar el siguiente comando :

    {D.EXE /SAFE}

De esta forma se entrará en el entorno en baja resolución (en 320x200, el
modo más compatible de todos). Para situarse desde la línea de comandos en el
directorio del programa, se debe ejecutar la siguiente sentencia (suponiendo
que el programa haya sido instalado en la unidad {C}, en la directorio {DIV}
dentro de {UTIL}):

    {C :}·
    {CD \UTIL\DIV}

En aquellos equipos en los que el sistema de vídeo no sea compatible con el
estándar {VESA} debe utilizarse un {driver vesa}. Para esto, debe contactar
con el proveedor o servicio técnico de su equipo hardware (un {driver} es un
pequeño programa que debe instalarse en el ordenador para dar soporte a
algunos dispositivos como, en este caso, el monitor).

Por problemas de incompatibilidad del {driver de ratón} es posible que en
algunos equipos el puntero del ratón se mueva a saltos; en estos casos, se
debe actualizar dicho {driver} o utilizar otro modo de vídeo para el entorno,
ya que en caso contrario no se podrá trabajar correctamente en el editor
gráfico.

Dos casillas permiten seleccionar la fuente utilizada por el sistema,
existiendo dos posibilidades:

{Fuente pequeña}. En este modo todas las ventanas, menús y cuadros se
verán en un tamaño menor, siendo el apropiado para modos de baja
resolución o equipos con un monitor lo suficientemente grande.

{Fuente grande}. Este modo {podrá ser activado únicamente en resoluciones
SVGA} (a partir de 640x480) y es el apropiado para estas resoluciones en
monitores de 14 pulgadas.

La fuente utilizada en los programas y en las ventanas de ayuda se define en
la ventana de configuración descrita más adelante.{-}

{/}

{Configurando el tapiz de fondo}

{+34,0}Para establecer el tapiz de fondo del escritorio se debe acceder a la opción
{Sistema \ Tapiz de fondo...}, que invocará el siguiente cuadro de diálogo:

Primeramente se debe pulsar sobre el botón '...' donde indica '{Apariencia} '
para seleccionar un archivo {MAP} con el gráfico que se quiere utilizar como
fondo. Si se quiere usar como fondo un archivo {PCX} o {BMP}, se debe cargar
primero éste con la opción {Mapas \ Abrir mapa...} y, después, guardarlo
({Mapas \ Guardar como...}) indicando un nombre de archivo con la extensión
{ .MAP}.

Mediante las siguientes casillas se indicará la apariencia de este gráfico.

{Mosaico}. Si se activa esta casilla el dibujo se mostrará a su tamaño
original, sin reescalar y, si es más pequeño que la pantalla, se repetirá
el dibujo hasta completar el fondo de la pantalla. Cuando esté desactivado,
el dibujo se reescalará (ampliándose o reduciéndose) para ajustarse al tamaño
de la pantalla.

{Color / Monocromo}. De estas dos casillas sólo podrá activarse una. La
primera señala que el dibujo se tomará en color, adaptándose a la paleta de
colores activa en el entorno (ésto suele desembocar en una pérdida de calidad
de dicho dibujo). Si se activa la segunda casilla, el dibujo se adaptará a
una gama de colores de la paleta, que se definirá con tres componentes:
{Rojo, Verde y Azul}.

Estos componentes, que pueden variar entre {0} y {9}, se modificarán con
los botones '{ -}' y '{ +}'. Serán aplicados únicamente cuando esté activada la
casilla que indica {Monocromo}, y definen el color más claro de la gama; a
continuación se muestran algunos ejemplos de combinaciones de estos valores y
cuál es el color resultante:

* Rojo=9, Verde=9 y Azul=9 definirán el color {blanco} como el color más
claro de la gama (se mostrará el tapiz de fondo en blanco y negro).

* Rojo=0, Verde=0 y Azul=9 definirán el color {azul puro}, mostrándose el
tapiz en diversos tonos de azul.

* Rojo=4, Verde=0 y Azul=0 definirán como el color más claro de la gama el
{rojo oscuro}, es decir, que el tapiz de fondo se verá en tonalidades oscuras
de rojo.

* Rojo=9, Verde=9 y Azul=0 definirán el color {amarillo} (rojo+verde), con lo
que se verá el fondo en una gama de colores definida entre el negro y el
amarillo.

Las gamas resultantes deben adaptarse a los colores disponibles en la paleta,
por lo que unas quedarán mejor que otras, debiéndose realizar normalmente
varias pruebas antes de encontrar una gama de color compatible con la paleta.

Los cambios realizados en el tapiz no serán visibles hasta que se finalice el diálogo
pulsando en el botón de {Aceptar}.{-}

{/}

{La ventana de configuración}

Mediante la opción {Sistema \ Configuración...} se accederá a un cuadro de
diálogo desde el que se pueden definir múltiples aspectos del entorno
gráfico.

{+35,0}Este cuadro de diálogo está dividido en varias secciones, que se muestran a
continuación. Estas opciones no tomarán efecto hasta que no se finalice el
diálogo.

{Colores de ventanas}. Esta primera sección establece los colores utilizados
por el entorno; se pueden indicar los colores de fondo, tinta y barra. Para
cambiar uno de estos colores se debe pulsar sobre la caja con el color,
apareciendo un cuadro de diálogo que mostrará todos los colores disponibles
en la paleta activa. Dentro de este cuadro se mostrará con una marca el color
seleccionado actualmente; para seleccionar otro color se debe pulsar sobre el
mismo con el ratón y después en el botón de {Aceptar}. El sistema no sólo
utiliza estos tres colores sino que, a partir de ellos, genera otros colores
intermedios para los textos, cursores, botones, etc.

{Editor de programas}. En esta sección es donde se establece la apariencia de
las ventanas de edición de programas. Se pueden seleccionar los tres colores
básicos (fondo de la ventana, tinta de los caracteres y el color del cursor)
y la fuente de edición (el tamaño del tipo de letra) desde 6x8 puntos hasta
9x16 puntos. Todas las fuentes de edición son de espaciado fijo. Para
seleccionar otra fuente se deben utilizar los botones de la barra de
desplazamiento. Los bloques de texto marcados dentro del editor se verán con
los colores de tinta y fondo intercambiados.

{Programa de dibujo}. En esta sección se puede definir la cantidad de memoria
reservada para deshacer opciones en el editor gráfico y el puntero de ratón
empleado en la edición. La cantidad de memoria se especifica en Kbytes, por
defecto es 1088Kb (algo más de un mega), y no es necesario modificar este
valor a no ser que no se pueda realizar una operación en el editor gráfico
por falta de memoria de deshacer (en cuyo caso el programa advertirá de
ello). Cuanta más memoria de deshacer se reserve, menos memoria quedará
disponible en el sistema para el resto de acciones. Se puede seleccionar
entre tres juegos de punteros diferentes pulsando sobre el gráfico del
puntero mostrado en este cuadro.

{Opciones globales}. En la última sección aparecen tres casillas que, cuando
estén activadas, definirán las siguientes características:

{Ventanas emergentes}. Indica que todos los movimientos de ventanas deben
ser visualizados, cuando se abren, se cierren, se minimicen, etc. Si se
desactiva esta opción, el entorno perderá efectismo pero ganará velocidad de
respuesta.

{Mover ventanas completas}. Indica que al arrastrarse las ventanas a una
nueva posición se debe ver en todo momento el resultado final, pasando a
primer plano las ventanas que se vayan destapando y a segundo plano las que
se vayan tapando. Puede ser conveniente desactivar esta opción en los equipos
más lentos.

{Guardar sesión siempre}. Indica que al salir de DIV Games Studio se debe
guardar el estado del escritorio y todos sus objetos (programas, mapas,
sonidos, etc.). Si se desactiva esta opción la entrada y salida del entorno
será más rápida, pero se puede correr el riesgo de perder trabajos que no
hayan sido grabados al salir del entorno.

Si se cierra la ventana de configuración o se pulsa la tecla {ESC} se
perderán todos los cambios realizados en la misma, restableciéndose los
valores de la configuración anterior.{-}

{/}

{+89,0}{Información sistema}

Esta opción mostrará información en un cuadro de diálogo sobre los recursos
disponibles en el sistema. Se informará de la memoria libre disponible, la
memoria ocupada por las ventanas de mapas cargadas y, como tanto por ciento
de recursos, se indica cuántos objetos, mapas y ventanas de cualquier tipo
hay cargados en el escritorio del total que pueden llegar a cargarse.{-}

{/}

{Acerca de ...}

Esta opción muestra el cuadro de diálogo introductor con la información sobre
la versión actual del programa.

{/}

{Shell MS-DOS (Tecla directa: ALT+S)}

Ejecuta una sesión del sistema operativo MS-DOS, sin salir de DIV. Se podrán
utilizar comandos de este sistema y programas que sólo requieran memoria
base. Se debe teclear {EXIT} para finalizar la sesión de este sistema.

{/}

{+90,0}{Salir de DIV (Tecla directa: ALT+X)}

Sale del entorno de DIV Games Studio. El sistema pedirá confirmación antes
de salir definitivamente. Por defecto, el sistema guardará el contenido del
escritorio para las siguientes ejecuciones del entorno, por lo que {no se
perderá la información} que no se haya guardado antes de salir.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1259,Opción de ayuda}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

Desde el menú principal se puede acceder al índice de este hipertexto de
ayuda del entorno seleccionando la última opción.

Las ventanas de ayuda se controlan con el ratón, utilizando la barra de
desplazamiento vertical de su derecha para moverse por cada una de las
páginas de ayuda. Para esto, se pueden utilizar también las siguientes
teclas:

* {Cursor arriba / abajo}. Desplazar el texto una línea hacia arriba o abajo.

* {Re.Pág / Av.Pág}. Desplazar el texto de la ayuda de página en página.

* {Backspace}. Volver a la página de ayuda anterior (esta tecla es la de
borrar el carácter anterior que está situada en el teclado sobre la tecla
{Enter}).

En las ventanas de ayuda se muestra el texto en tres colores:

* {Negro}. Éste es el cuerpo principal de la ayuda, se muestra en color negro
la mayoría del texto en las páginas de ayuda.

* {Gris}. En color gris aparecen aquellos textos que se han querido resaltar
por ser información especialmente relevante (como los textos en {negrita} de
un libro).

* {Blanco}. Aparecen de este color los textos o palabras que hacen referencia
a conceptos o términos que están explicados en otra página de la ayuda. Se
puede pulsar con el ratón sobre los mismos para acceder a esa página y,
después, utilizar la tecla {Backspace} para retornar al punto de la página
anterior en el que se detuvo la lectura.

Además de texto pueden aparecer {imágenes} o {ejemplos} en las ventanas de
ayuda. Los ejemplos son programas que comienzan con una línea en {blanco} y
tienen el texto en {azul oscuro}. Para extraer los ejemplos de las ventanas
de ayuda se debe pulsar sobre la línea en blanco inicial de los mismos.
Después, se podrán compilar y ejecutar pulsando la tecla {F10} y para abortar
la ejecución de los mismos se debe pulsar {ALT+X}.

En la esquina inferior derecha de la ventana de ayuda aparece un botón liso
que puede utilizarse para ampliar o reducir la ventana, pulsando sobre él y
arrastrando hacia arriba o hacia abajo.

# ─────────────────────────────────────────────────────────────────────────────

{.1260,Trazador de programas}
Ver: {#3,Indice} - {#1250,Ayuda sobre el sistema de menús}{/}

El trazador de programas es una herramienta avanzada y para utilizarla es
necesario comprender bien antes todos los conceptos de programación expuestos
a partir del capítulo 5 del libro de DIV Games Studio (Manual de usuario).

{+70,0}El trazador es un cuadro de diálogo que puede activarse durante la ejecución
de los programas por uno de los siguientes motivos:

* Se entró en el programa con la opción {programas \ trazar programa}.

* Se pulsó la tecla {F12} durante la ejecución de un programa.

* Se produjo un {error de ejecución} en el programa.

* Se encontró una sentencia {debug} en el programa ejecutado.

Esta herramienta, también llamada {debugger}, permite ejecutar el programa
sentencia a sentencia, comprobando cada vez que sea necesario el valor que
toman los diferentes datos del programa. Su utilidad principal reside en
poder, al revisar la ejecución del programa paso a paso, encontrar los fallos
que puedan tener los programas.

Por ser un diálogo con mucha información, se describen a continuación cada
una de las secciones del mismo de forma separada.{-}

{/}

{Línea informativa superior}

En la parte superior de la ventana aparecen dos mensajes. A la izquierda uno
que indica el {número de procesos activos en el programa} del {total que
pueden llegar a crearse}. Por ejemplo, si pone 23/3201 quiere decir que hay 23
procesos activos en el programa y que podrían llegar a crearse hasta 3201
antes de que se agotara la memoria disponible para procesos.

El número de procesos máximo varia de unos programas a otros en función del
número de variables locales y privadas de los mismos.

A la derecha se indica el {código identificador} del proceso seleccionado en
la lista, y su estado actual (Normal, muerto, dormido o congelado).

{/}

{Lista de procesos activos}

Esta lista aparece en la parte superior izquierda del trazador con una barra
de desplazamiento a su derecha. Se muestran en ella todos los procesos
activos en el programa; se entiende por activos los procesos que han sido
creados y todavía no han desaparecido. Por cada proceso aparece la siguiente
información:

* El nombre del proceso en el programa.

* Su código identificador entre paréntesis (en ocasiones puede no caber
entero).

* Una letra que indica su estado ({A}-Normal, {K}-Muerto, {S}-Dormido y
{F}-Congelado).

* El porcentaje de ejecución completada para la siguiente imagen.

Para desplazarse por la lista de procesos se debe utilizar la barra de
desplazamiento de la misma.

{Importante}: Uno de los procesos aparece con una punta de flecha de color
blanco señalando su nombre; este proceso es el que {se está ejecutando}
actualmente en el programa. Por lo tanto, la próxima sentencia del programa
será de este proceso.

Uno de los procesos aparece señalizado con una banda negra; éste es el
proceso del cual se muestra información en la parte derecha de la ventana
(al lado de esta lista de procesos). Este proceso puede seleccionarse con el
ratón, pulsando sobre la lista.

Es muy importante diferenciar entre el proceso que se está ejecutando y el
proceso sobre el que se muestra la información, ya que no tienen por qué ser
iguales. Para que se muestre la información sobre el proceso que se está
ejecutando se debe seleccionar al mismo (el de la flecha blanca) pulsando en
la lista con el botón izquierdo del ratón.

{/}

{Cuadro de información sobre el proceso señalizado}

A la derecha de la lista anterior se muestra información sobre el proceso
señalizado con una banda negra en la lista (no el proceso en ejecución). En
la línea superior se mostraba su código identificador y su estado.

En una caja de fondo oscuro se muestra el nombre completo del proceso, y bajo
la misma aparece otra caja con el gráfico de este proceso (éste se muestra
reducido cuando sea más grande para que entre en esta caja).

A la derecha del gráfico aparece el botón {Ver datos} que permite acceder a
otro cuadro de diálogo en el que se pueden consultar y modificar todos los
datos del proceso; éste se explica más adelante en el punto {Inspeccionando
los datos}.

A continuación de este botón se muestran siempre las coordenadas ({x},{y})
del proceso; el sistema de coordenadas empleado por el mismo (referidas a la
{pantalla}, a un {scroll} o a un {modo 7}) y las inversiones o transparencias
aplicadas al gráfico del proceso.

Por último, cuatro botones permiten acceder al proceso padre ({father}, el
proceso que llamó al que está seleccionado), el hijo ({son}, el último
proceso llamado por el seleccionado), el hermano menor ({smallbro}, el último
llamado por el padre antes que él) y el hermano mayor ({bigbro}, el siguiente
llamado por el padre tras él). Cuando estos botones no lleven a ningún otro
proceso, es porque no existe ninguno con dicha relación de parentesco.

{/}

{Controles de ejecución parcial}

Dos botones denominados {Ejec.Proceso} y {Sgte.FRAME} bajo el cuadro de
información anterior permiten ejecutar parcialmente el programa.

{Ejecución del proceso}. Este primer botón permite que el programa continúe
justo hasta que finalice el proceso actualmente en ejecución (el señalizado
en la lista con la flecha blanca). Se ejecutarán todas sus sentencias hasta
que llegue al próximo {FRAME} (hasta que el proceso esté listo para la
próxima imagen del juego).

{Siguiente FRAME}. El segundo botón ejecutará el programa hasta la siguiente
imagen del mismo, ejecutando todos los procesos pendientes primero y
visualizando (al fondo del trazador) la próxima imagen del juego. El trazador
se detendrá en la primera sentencia del primer proceso a ejecutar en la nueva
imagen. Se puede desplazar el cuadro de diálogo con el trazador (arrastrando
su barra de título) para contemplar el resultado de la imagen anterior del
juego.

{/}

{Cuadro de trazado del listado del programa}

En la parte inferior del trazador es donde se muestra el código del programa.
En la esquina superior izquierda aparece el código identificador del proceso
en ejecución (nuevamente, el señalizado con la flecha blanca en la lista).
Debajo aparecen tres botones y a la derecha la ventana de código.

En la {ventana de código}, otra flecha de color blanco indica la línea en la
que se encuentra la próxima sentencia a ejecutar por el proceso. Se puede
observar cómo la sentencia aparece también resaltada del resto del código en
color blanco.

El contenido de esta ventana se puede desplazar con las teclas de los
{cursores}. Se aprecia cómo con una banda negra se pueden señalar las líneas
del programa. No obstante, no es posible modificar el programa desde el
trazador, sino que para modificar el programa se debe finalizar su ejecución
(esto se puede hacer pulsando {ALT+X}) y retornando al editor del entorno.

El primer botón denominado {Proceso} permite saltar en la ventana de código a
uno de los procesos del programa directamente. Aparecerá una lista con todos
los procesos encontrados en el programa, debiéndose seleccionar con el ratón
el proceso deseado. No obstante, esto no alterará el proceso actualmente en
ejecución que seguirá siendo el mismo.

El segundo botón permite establecer un punto de {Ruptura} en el programa;
para ello se debe, primero, seleccionar con la banda negra la línea del
listado en la que se debe detener el programa cuando llegue a ella (con los
cursores) y, después, activar este botón; la línea aparecerá en color rojo.

No en todas las líneas del programa se pueden establecer puntos de ruptura,
sino  únicamente en aquellas para las que se haya generado código ejecutable
(en las que se realice alguna acción).

Se pueden establecer múltiples puntos de ruptura en el programa. Para
ejecutar después el programa hasta que llegue a uno de estos puntos basta
con cerrar el trazador o pulsar la tecla {ESC}.

Para {desactivar} un punto de ruptura se debe volver a seleccionar la línea y
pulsar nuevamente en el mismo botón.

El último botón, {Trazar}, es el que realmente permite trazar sentencia a
sentencia el programa; cada vez que se pulse el mismo se ejecutará una de
las sentencias del programa. Cuando un proceso finalice su ejecución, o
complete una imagen, se pasará a la primera sentencia a ejecutar del
siguiente proceso.

{/}

{Inspeccionando los datos}

{+71,0}Pulsando el botón {Ver datos} del trazador de programas se accede a este otro
cuadro de diálogo, en el que se pueden consultar los valores de los datos del
programa en el punto en el que se encuentra detenido e incluso modificarlos,
normalmente con la finalidad de realizar pruebas en el mismo.

La mayor parte de este cuadro está ocupado por la lista de datos; para cada
uno de ellos se muestra con su nombre y su valor numérico. Esta lista
aparece siempre en orden alfabético.

Mediante una serie de casillas se puede seleccionar el conjunto de datos que
aparecen en esta lista. Las dos casillas superiores definen los dos
siguientes conjuntos.

* {Predefinidos}. Cuando esté activada esta casilla se incluirán en la lista
todos los datos predefinidos en el lenguaje. Se podrá acceder de esta forma
a los datos locales predefinidos (como x, y, angle, size, ...), a los datos
globales predefinidas y a las constantes predefinidas.

* {Definidos por usuario}. Esta casilla selecciona todos los nuevos datos que
han sido definidos en el programa. Estos son las constantes, variables,
tablas y estructuras especificas de cada programa.

Además de poder seleccionar los datos según sean predefinidos o nuevos, se
pueden seleccionar según el ámbito en el que han sido declarados los mismos,
con las siguientes casillas.

* {CONST}. Esta casilla sirve para incluir las constantes en la lista, si
bien las constantes no son datos, sino sinónimos de un valor numérico, por lo
que no podrán ser modificadas.

* {GLOBAL}. Se incluirán en la lista los datos de ámbito global (accesibles
por todos los procesos) en la lista, cuando se active esta casilla.

* {LOCAL}. Con esta casilla activada se incluirán en la lista los datos de
ámbito local, es decir, los datos que tienen todos los procesos del programa.

* {PRIVATE}. Esta casilla selecciona para su inclusión en la lista los datos
específicos del proceso señalizado en la ventana del trazador, es decir, los
datos que tiene exclusivamente este proceso para su uso interno.

La lista de datos se puede desplazar con la barra de desplazamiento vertical
o con las teclas de los {cursores} y las teclas {Re.Pág / Av.Pág}.

El botón {Cambiar} permite modificar el valor del dato seleccionado, siendo
las constantes los únicos que no pueden modificarse. Aparecerá un nuevo
diálogo con una caja de texto en la que se debe introducir el nuevo valor
del dato. Se puede seleccionar cualquier dato de la lista con los {cursores}
o pulsando con el ratón sobre la misma.

Bajo este botón aparecen otros dos con los símbolos{ -} y{ +}; estos se
utilizan para {modificar el índice de tablas y estructuras}, lo que también
puede hacerse con las teclas {cursor derecha} e {izquierda}. Antes debe estar
seleccionada en la lista la tabla o estructura cuyo índice se quiere cambiar.
Esta es la forma de poder observar o modificar cualquier elemento de una
tabla o estructura.

Por último, en la parte inferior de este diálogo aparecen una serie de
botones que permiten visualizar el valor de un dato de una forma concreta,
estos son:

* {Angulo}. Este botón permite visualizar el dato como un ángulo. Los ángulos
se especifican internamente (en los programas) en milésimas de grado. El
valor del dato se visualizará como un ángulo en grados y radianes.

* {Proceso}. Si el dato es el {código identificador} de un proceso, al
seleccionar este filtro de visualización, aparecerá en la lista el nombre de
dicho proceso como valor del dato.

* {Texto}. Cuando el dato sea un texto, o un puntero a un texto (a un literal
del programa), pulsando este botón se mostrará en la lista dicho texto.

* {Lógico}. Si un dato contiene un valor lógico, al aplicarle este filtro se
mostrará en la lista superior si éste es falso ({false}) o cierto ({true}).
En el lenguaje, al evaluarlos como condiciones lógicas se consideran ciertos,
los números impares y falsos, los pares.

Una vez establecido el filtro de visualización de un dato, éste permanecerá
durante el resto de la ejecución del programa. Se debe pulsar dos veces el
mismo botón para volver a visualizar el contenido del dato como un valor
numérico.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1261,Ayuda sobre el editor gráfico.}

Ver: {#3,Indice general}{/}

  {#1262,Conceptos generales}·
  {#1263,Paletas de colores}·
  {#1264,Color transparente}·
  {#1265,Controles básicos}·
  {#1266,Iconos genéricos}·
  {#1267,Gamas de colores}·
  {#1268,Utilización de máscaras de color}·

  {#1270,Barras de punteado y lápiz}·
  {#1271,Barras para líneas y multilíneas}·
  {#1272,Barras para curvas y multicurvas}·
  {#1273,Barras de rectángulos y círculos}·
  {#1274,Barra de spray}·
  {#1275,Barra de relleno}·
  {#1276,Barra de edición de bloques}·
  {#1277,Barra de deshacer}·
  {#1278,Barra de texto}·
  {#1279,Barra de puntos de control}·

  {#1280,Edición de animaciones}·
  {#1281,Trucos y técnicas avanzadas de dibujo}·

# ─────────────────────────────────────────────────────────────────────────────

{.1262,Conceptos generales}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

El editor gráfico es la herramienta para dibujar los gráficos de los juegos.
Con el ratón y los colores de una paleta se puede crear cualquier dibujo con
un poco de habilidad. Dibujar en un ordenador es bastante diferente a dibujar
en un papel; se requiere menos pulso y habilidad pero un poco más de
paciencia.

El editor únicamente trabaja con las ventanas de mapas (las que contiene
cualquier tipo de gráfico), y la manera más fácil de entrar en él es
realizando una doble pulsación con el botón izquierdo del ratón sobre un
mapa del escritorio. Una vez en el editor se ampliará el dibujo, cambiará el
puntero del ratón y aparecerá una barra de herramientas horizontal con varios
iconos y colores. Se puede salir del editor de varias formas: cerrando la
barra de herramientas, pulsando la tecla {ESC} o con el botón derecho del
ratón.

Este editor gráfico es una herramienta bastante completa, no obstante no
puede sustituir a muchos de los programas comerciales que han sido diseñados
específicamente para la creación de gráficos. Por ello, se permite importar
mapas en formato {PCX} o {BMP} (unos formatos ampliamente difundidos entre
las utilidades gráficas) para, de esta forma permitir, a quienes quieren
utilizar otras herramientas para crear los gráficos, utilizar en DIV Games
Studio las imágenes creadas con otros programas.

Aún así, se recomienda la lectura de la ayuda dedicada al editor
gráfico, ya que muchas operaciones resultarán más sencillas y se harán más
rápido desde DIV Games Studio que desde otros programas.

Si usted no dispone de otros programas para la creación de imágenes, no se
preocupe, ya que el editor gráfico de DIV reúne gran cantidad de potentes
herramientas de dibujo, muchas de las cuales superan en prestaciones a las
que ofrecen los programas específicos de dibujo, por lo que no será necesario
utilizar ningún otro programa para crear las imágenes y gráficos de los
juegos.

Antes de acceder a esta página, que describe los conceptos y términos de
dibujo básicos, se debe conocer el manejo de mapas y ficheros de mapas
descrito en el {#1254,menú de mapas} y el {#1255,menú de ficheros}.

Por ejemplo, para realizar las primeras pruebas cargue la paleta de colores
por defecto ({paletas \ abrir...} indicando el archivo {div.pal}) y cree un
mapa nuevo ({mapas \ nuevo...}) de cualquier tamaño en puntos, como pudiera
ser {200x200}, y acceda al editor con una doble pulsación sobre este mapa.

{/}

{Un paseo rápido por el editor}

{+101,0}La barra de herramientas tiene una pequeña barra de título a la izquierda con
la que se puede arrastrar la misma a cualquier posición de pantalla, para que
no tape la zona del dibujo sobre la que se trabaja.

Como primer icono aparece uno con tres puntos (esta es la barra de punteado);
pulse sobre este icono para que se abra un diálogo que muestra los diferentes
iconos de los modos disponibles. Seleccione el icono superior derecho de este
cuadro para utilizar la barra del lápiz.

El dibujo aparecerá en negro; para comenzar a pintar debe seleccionar un color
primero, puede hacerlo en la gama (en este momento de grises) de la barra, o
cualquier color de la paleta si pulsa la tecla {C} (color) para que aparezca
el diálogo de selección de color. En este cuadro puede seleccionar un color
de la paleta principal o, si pulsa en la parte derecha, seleccionar la gama
que debe aparecer en la barra de herramientas.

A la derecha del icono del lápiz aparecen las coordenadas del puntero sobre
el dibujo y, a continuación, un icono con una lupa para variar el nivel de
ampliación del mismo; esto también se puede hacer pulsando la tecla {Z}
(zoom).

Puede probar otros iconos y barras de herramientas; cuando haya dibujado algo
utilice la tecla {Backspace} (la tecla de borrado sobre {Enter}) para
retroceder en la creación del dibujo (deshacer) y después
{Mayúsculas+Backspace} para ir hacia adelante (rehacer).{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1263,Paletas de colores}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

La paleta de colores es la base de todo dibujo, pero en los juegos sólo se
podrán visualizar en pantalla {256 colores diferentes} de forma simultánea.
Estos colores son los que se eligen primero con la paleta de colores. Es muy
importante saber que todos los dibujos que se vayan a utilizar a la vez en un
juego deben haberse creado con la misma paleta de colores. Los juegos pueden
utilizar varias paletas, pero en cada momento {sólo puede haber una activa},
por ello sólo se verán correctamente en ese momento los gráficos que utilicen
la paleta que está activa.

También existe la posibilidad de {adaptar} un gráfico que haya sido creado
con una paleta de colores a otra. El sistema buscará para cada punto del
gráfico original el color más parecido en la nueva paleta y lo sustituirá,
pero debido a que en ocasiones no se encuentran colores parecidos, los
dibujos suelen perder calidad cuando son adaptados a otra paleta.

En el entorno DIV siempre hay también una única paleta activa; todos los
mapas del escritorio deben utilizar esta paleta. Por ello, cuando se intenta
abrir un mapa (o fichero de mapas) que utiliza una paleta diferente el
sistema pregunta primero si se debe activar la nueva paleta.

{+103,0}{Importante}: Si tiene información sin guardar en los mapas cargados,
responda {Cancelar} (no activar la nueva paleta, lo que podría dañar los
mapas cargados), cierre el mapa (o fichero) recién cargado, guarde todos los
mapas cargados en sus respectivos archivos, ciérrelos y entonces vuelva a
abrir el nuevo mapa.

Si responde {Aceptar} y se activa la nueva paleta, el sistema preguntará
entonces si desea adaptar los mapas anteriormente cargados a la nueva paleta;
si no quiere hacerlo, cierre después los mapas cargados, sin guardarlos
previamente (pues se guardarían incorrectamente, con una paleta de colores
que no es la suya). En resumen:

* Para {adaptar el mapa abierto a la paleta activa en el entorno} responda
{Cancelar} a activar la nueva paleta. Si no queda satisfecho con la
adaptación realizada, cierre el nuevo mapa sin guardarlo.

* Para {adaptar los mapas cargados a la paleta del mapa abierto}, responda
{Aceptar} a activar la nueva paleta y {Aceptar} a adaptar los mapas cargados.
Si no queda satisfecho con la adaptación realizada, cierre los mapas
anteriores sin guardarlos.

* Para {no adaptar ningún mapa a otra paleta}, guarde y cierre primero los
mapas cargados en el escritorio y después abra el nuevo respondiendo
{Aceptar} a activar la nueva paleta.

Cada vez que inicie un proyecto, debe decidir qué paleta de colores va a
utilizar para el mismo. Si le es indiferente, entonces use la paleta por
defecto de DIV Games Studio ({div.pal}), en caso contrario debe utilizar el
editor de paletas ({paletas \ editar paleta...}). Tras crear una nueva paleta
es conveniente guardarla en un archivo del disco, por si después se modifica
o cambia la misma accidentalmente, poder recuperarla del mismo.

DIV Games Studio viene con una librería con numerosos gráficos preparados
para crear nuevos juegos, pero debe tener en cuenta que muchos de estos
gráficos utilizan paletas diferentes, por lo que, para juntarlos en un juego,
deberá adaptar unos a la paleta de otros. La mejor opción es, una vez
definida su propia paleta, adaptar los gráficos de la librería a la misma
(los gráficos que quiera utilizar en el juego).

La opción {paletas \ fusionar paletas...} permite crear una paleta a partir
de dos, incluyendo en la paleta resultante los colores más representativos
de ambas. Esta es una muy buena opción para utilizar gráficos con varias
paletas, crear una paleta mixta y después adaptar todos los gráficos a la
misma. También se puede crear una paleta a partir de más de dos,
fusionándolas por parejas hasta que sólo quede una.

Ver el {#1253,menú de paletas}, que permite acceder a éstas y otras opciones.

# ─────────────────────────────────────────────────────────────────────────────

{.1264,Color transparente}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Se hablará más adelante muchas veces del {color transparente}; éste es el
primer color de la paleta. Los colores en la paleta se muestran siempre
ordenados, en 16 filas, desde la fila superior con los colores del 0
(izquierda) al 15 (derecha), hasta la inferior con los colores del 240 al
255. Luego el color transparente es el superior izquierdo de la paleta.

Este color es normalmente {negro} y es el color que tienen todos los puntos
de un mapa al crearse. Esta tonalidad puede modificarse (en el editor de
paletas), pero no es recomendable hacerlo en un principio.

La denominación {transparente} viene de que los puntos de los gráficos que se
pinten (o se dejen de este color) {no aparecerán al pintarse los gráficos en
el juego}. Es decir, con este color se pintan las zonas que {no son opacas}
de los gráficos. Sin un color transparente todos los gráficos deberían ser
cuadrados, como los mapas que los contienen.

Otras utilidades también denominan a este color como {color de fondo o de
máscara}.

En el editor gráfico se puede reconocer el color transparente porque al
{pulsar la tecla B}, este color pasa de negro a un gris medio. Ésta es una
operación que se realiza muchas veces, para poder observar bien los
contornos de los gráficos (para poder reconocer las zonas transparentes de
los mismos). Para devolver el color transparente a negro, se debe pulsar la
tecla {B} otra vez.

Conviene, por tanto, tener {dos colores negros} en la paleta: primeramente,
el color 0 que será el transparente, y un segundo color negro (que puede
situar se en cualquier posición de la paleta) para pintar las zonas de los
gráficos que deban {ser negras de verdad} y no transparentes. Para pintar con
este negro se debe resaltar el color transparente con la tecla {B}
previamente, ya que de lo contrario no se verá nada. Este {negro opaco} es el
número 240 de la paleta por defecto de DIV (el de la esquina inferior
derecha).

Se puede realizar un pequeño experimento para comprobar el efecto del color
transparente y es el siguiente:

* Cree un mapa nuevo y pinte algo en él (unos pocos garabatos de colores).

* Salga del editor y cree una copia de este mapa (arrastre la ventana del
mapa hasta el tapiz de fondo).

* Y, por último, arrastre la copia que se ha creado (la nueva ventana de
mapa) al mapa original.

Se entrará en el editor para copiar el gráfico sobre sí mismo. Al moverlo
con el ratón se podrá observar cómo las zonas que se dejaron en color
transparente no aparecen ahora. Se puede obligar al programa de dibujo que
pinte las zonas de color transparente con su negro original, seleccionando el
icono que tiene el dibujo de un hombrecillo en la barra de herramientas.

En los juegos, el color transparente no se pintará nunca, por lo que se debe
pintar con el color {negro opaco} cuando se quieran mostrar partes de un
gráfico negras.


# ─────────────────────────────────────────────────────────────────────────────

{.1265,Controles básicos}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Casi todas las barras de herramientas disponen de una serie de comandos
comunes; a continuación se describen éstos y el funcionamiento general del
programa de dibujo.

El control se realiza básicamente con el ratón pero en la zona de dibujo,
cuando se requiera {precisión} en los movimientos, se puede mover el puntero
también con los {cursores} o las siguientes teclas:

{Q, A} Mover puntero arriba / abajo.
{O, P} Mover puntero izquierda / derecha.

La {barra espaciadora} puede hacer también las veces del botón izquierdo del
ratón, cuando se controle el puntero con el teclado, es decir que en la
mayoría de barras esta tecla permitirá pintar con el color seleccionado.

El control con teclado se realiza de un punto en un punto; para moverse más
deprisa se debe pulsar simultáneamente la tecla {Mayúsculas}. Si se tiene
activada la tecla {Bloq. Num}. del teclado numérico, los cursores moverán el
puntero de 8 en 8 puntos. Para moverlo de uno en uno se debe desactivar esta
tecla.

En la mayoría de barras se puede {tomar un color del dibujo} si se mantiene
pulsada la tecla {Mayúsculas} mientras se pulsa la {barra espaciadora} o el
{botón izquierdo del ratón} sobre un punto del mapa editado.

Para elegir un color, además del ratón, pueden utilizarse las teclas {W / S}
para elegir un color más claro o más oscuro de la gama seleccionada; si,
además, se mantiene pulsada la tecla {Mayúsculas}, se elegirá la gama que
aparece en la barra, en lugar del color. Estas acciones también pueden
realizarse si se mantiene pulsado {Control} mientras se utilizan los
{cursores}, seleccionando con {izquierda} o {derecha} el color de la gama y
con {arriba} o {abajo} la gama.

Para seleccionar momentáneamente el {color transparente} se puede pulsar la
tecla {0} (cero); si después se vuelve a pulsar se retornará al color
anterior. Esto también se puede hacer pulsando con el ratón sobre el
rectángulo negro situado justo antes de la gama de colores de la barra (a su
izquierda).

Para deshacer acciones ya se mencionó anteriormente la tecla {Backspace}, y
junto con {Mayúsculas} para rehacer nuevamente las acciones deshechas. El
{icono de deshacer} aparece como una flecha hacia la izquierda a continuación
del icono de la lupa (la ampliación o zoom de edición).

También se comentó el uso de la tecla {Z} para cambiar el nivel de ampliación
(se debe {apuntar con el ratón la zona a ampliar} cuando se pulse esta
tecla). Cuando los mapas se editen ampliados, muchas veces no cogerán en
pantalla; para moverse por el mapa completo simplemente se tiene {que
desplazar el ratón hacia fuera de la pantalla}.

Se puede {bloquear el desplazamiento} de pantalla pulsando sobre las
coordenadas de la barra de herramientas; éstas cambiarán su color {gris
claro} por un {gris oscuro}, bloqueando el desplazamiento de la zona
ampliada. Se debe pulsar en las coordenadas nuevamente para desbloquear el
desplazamiento.

Se puede salir de los cuadros de diálogo que se despliegan a partir de las
barras de herramientas de múltiples formas:

* Cerrando el cuadro (con el botón superior izquierdo del mismo).

* Pulsando la tecla {ESC}.

* Pulsando el botón izquierdo del ratón.

* Seleccionando nuevamente el icono que lo activó.

* Pulsando con el ratón sobre el mapa editado.

Un resumen con todas las teclas disponibles en el {editor gráfico} se puede
encontrar en "{#1295,Comandos del editor gráfico}".

# ─────────────────────────────────────────────────────────────────────────────

{.1266,Iconos genéricos}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

{+102,0}El primer icono de todas las barras de herramientas es, como se mencionó
antes, el que indica la modalidad de dibujo. Cada barra se corresponde con
un modo de dibujo y, por lo tanto, tiene su propio icono inicial. Las barras
también se describen individualmente en esta ayuda. Para acceder a estas
barras, además de pulsar sobre el primer icono, se pueden utilizar las {teclas
de función}; a continuación se muestra la lista de teclas y un resumen de la
función de las barras de herramientas.{-}

* {F2}: {Lápiz}, para el trazo a mano alzada de bocetos y contornos.

* {F3}: {Líneas rectas}, para crear esquemas y figuras geométricas.

* {F4}: {Multilínea}, variación de la barra anterior para líneas encadenadas.

* {F5}: {Curvas bézier}, para el trazado de contornos y líneas curvas.

* {F6}: {Multicurva}, variación de la barra anterior para curvas encadenadas.

* {F7}: {Rectángulos}, para crear cajas o marcos cuadrados o rectángulares.

* {F8}: {Círculos}, para crear circunferencias, círculos o elipses.

* {F9}: {Spray}, herramienta para el retoque y el acabado artístico.

* {F10}: {Relleno}, para el relleno de varios tipos de superficies.

* {F11}: {Edición de bloques}, herramienta para la gestión de bloques
gráficos.

* {F12}: {Deshacer}, barra específica para hacer y deshacer acciones.

* {Mayúsculas+F1}: {Texto}, para escribir textos dentro de los mapas
editados.

* {Mayúsculas+F2}:  Barra para situar {Puntos de control} dentro de los
mapas.

* {Mayúsculas+F3}: Barra de {Punteado}, para edición precisa de gráficos
pequeños.

Otro de los iconos común a muchas de las barras es el {Cuentagotas} que
aparece normalmente después de la gama de colores y al pulsarlo, lleva
momentáneamente a otra pequeña barra utilizada para seleccionar un color del
mapa.

{+104,0}En la barra del cuentagotas se muestran las coordenadas, la lupa y el color
sobre el que se sitúa el puntero del ratón en el mapa. Cuando se pulse en el
mapa se tomará este color para dibujar, retornando automáticamente a la barra
anterior.

Se recuerda que para coger un color del mapa también se puede pulsar sobre el
mismo manteniendo pulsada la tecla {Mayúsculas} al mismo tiempo.{-}

Una gran parte de las barras muestran, tras del cuentagotas, el icono de
{porcentaje}; mediante este icono se controla la {cantidad de tinta} que se
añade al dibujo al pintar.

{+105,0}Al pulsar este icono aparecerá un cuadro de diálogo con una regla; se debe
pulsar sobre la misma para establecer el porcentaje. Un porcentaje de 100%
(el valor por defecto de la mayoría de barras) implicará que se pinte con
colores completamente sólidos, es decir, que no se mezclarán con el dibujo
anterior.

Se pueden obtener muy buenos resultados si se aprende a utilizar debidamente
esta técnica, ya que permite retocar, por ejemplo con la barra del lápiz, una
parte de un gráfico {añadiendo} un poco de un color. También resulta útil
pintar con un porcentaje bajo de color {negro} para oscurecer poco a poco
partes del dibujo, o con color {blanco} para aclararlas.{-}

Los iconos que pueden aparecer a continuación de estos dos en las distintas
barras de herramientas son normalmente {iconos de modo}, que ofrecen varias
modalidades de utilización de la herramienta. Generalmente, se despliega al
utilizarlos un nuevo diálogo con nuevos iconos, cada uno de ellos
representando una modalidad de utilización de la herramienta diferente.

Cuando aparezcan en la parte derecha de una barra unas {segundas
coordenadas}, éstas indicarán normalmente el ancho y alto del objeto que se
está dibujando con la herramienta, para poder realizar de esta forma
mediciones precisas.

# ─────────────────────────────────────────────────────────────────────────────

{.1267,Gamas de colores}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Para acceder al cuadro de diálogo de {Creación y selección de gamas de
colores} que se describe a continuación, se debe pulsar la tecla {C} o con el
{botón izquierdo} del ratón sobre el color seleccionado en la barra (es el
rectángulo situado justo después del icono de deshacer y antes del rectángulo
del color transparente). Una {gama de colores} es simplemente una secuencia
de colores de la paleta que se utiliza para dibujar en diversos tonos de un
color (una secuencia de grises, de rojos, etc.).

{+106,1}{-}
Aparecerá un cuadro bastante grande con muchos colores. Para retornar al
dibujo se puede pulsar {C} de nuevo, o pulsar sobre el color seleccionado
otra vez. Este cuadro se divide en tres grandes zonas: la paleta de colores
(superior izquierda), el editor de gamas (inferior) y la lista de gamas de
colores (superior derecha).

{/}

{La paleta de colores}

Esta sección se utiliza simplemente para seleccionar colores de la paleta,
pulsando con el ratón sobre la misma. A la derecha aparece información sobre
el color seleccionado o sobre el color donde se sitúe el ratón, si éste está
dentro de la paleta.

La información es el número de color en decimal, en hexadecimal, una muestra
del color y los niveles de rojo (red), verde (green.) y azul (blue) que
componen el color.

Desde este cuadro {no se puede modificar la paleta}, ya que esto sólo puede
hacerse desde el menú de paletas, fuera del editor gráfico.

{/}

{El editor de gamas}

Se pueden definir hasta 16 gamas de color diferentes para una paleta. La
gama seleccionada es la que aparece en la barra de herramientas y es la que
se puede editar con esta herramienta.

{Nota}: El editor de gamas {no modifica los colores} de la paleta, sino que
sólo los {reordena} para formar con ellos secuencias de colores útiles para
dibujar.

A la izquierda aparece una reproducción exacta de la gama que se encuentra en
la barra de herramientas y a la derecha tres botones rectangulares que
cambian de valor cuando se pulsan; éstas son sus funciones:

* El primero (arriba izquierda) define el número de colores que tiene la
gama, que puede conmutarse entre {8}, {16} o {32} colores.

* El segundo (arriba derecha) define si la gama es {editable} o {fija}, es
decir, si se va a modificar la gama o se quiere dejar tal como está. Cuando
la gama es {editable} aparece en la misma uno o varios pequeños {iconos con
una flecha gris hacia arriba}; éstos son los utilizados para establecer los
colores de la gama.

* El último botón (abajo) define el modo en el que se quiere definir la gama.
Los modos disponibles son los siguientes:

+ Directa de la paleta. En este modo se define el primer color de la gama,
mientras que el resto se toman secuencialmente de la paleta.

+ Editable cada color. En este modo se pueden definir individualmente cada
uno de los colores de la gama, seleccionándolos de la paleta y asignándolos
después a cada posición de la gama.

+ Editable cada dos colores. Este modo es similar al anterior sólo que se
podrá definir únicamente uno de cada dos colores. Los colores intermedios los
definirá el sistema con el color de la paleta más cercano a la media de sus
dos colores adyacentes.

+ Editable cada cuatro o cada ocho colores. Estos dos últimos modos son
prácticamente idénticos al anterior, sólo que definiendo aún menos colores.
Su utilidad consiste en que el sistema busque las gamas intermedias entre
cada dos colores definidos automáticamente.

Una vez definida una gama conviene hacerla {fija} para no correr el riesgo de
perderla accidentalmente. Cuando se guarda la paleta en un archivo, también
se guarda en él la información sobre las gamas de color utilizadas en la
misma.

{/}

{La lista de gamas de colores}

En la parte superior derecha del cuadro de diálogo aparecen las 16 gamas de
colores que pueden definirse. La utilidad de esta lista consiste en poder
seleccionar directamente la gama de color que interese en cada momento para
dibujar.

Se puede observar que una pequeña flecha blanca indica cuál es la gama de
colores seleccionada; ésta es también la que aparece en el editor de gamas y
la barra de herramientas.

A continuación de cada gama se muestran tres valores que resumen sus
características: {número de colores}, {modo de definición}, y si es
{Editable} o {Fija}.


# ─────────────────────────────────────────────────────────────────────────────

{.1268,Utilización de máscaras de color}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

La utilización de máscaras de color es una técnica avanzada. Sirve para
proteger partes del dibujo que no deben modificarse, lo que se puede hacer
seleccionando un conjunto de colores de la paleta sobre los que no se podrá
pintar.

Por ejemplo, si en un mapa en su mayoría con fondo negro y con un dibujo en
el centro se define como máscara el color negro, entonces se protegerá el
color negro de forma que no se pueda pintar sobre él. Por lo tanto, se podrá
pintar posteriormente en el gráfico sin salirse, ya que las herramientas de
dibujo no pintarán fuera del gráfico.

Para acceder al diálogo de definición de máscaras se debe pulsar la tecla {M}
o con el {botón derecho} del ratón sobre el color seleccionado de la regla
(como para activar el diálogo de gamas de colores, pero con el otro botón del
ratón).

{+107,1}{-}
Aparecerá un diálogo con todos los colores de la paleta y dos botones en su
parte inferior. Pulsando con el botón izquierdo del ratón sobre la paleta se
podrán seleccionar y deseleccionar los colores que se quieran enmascarar.
Cuando aparezca un pequeño cuadrado en el centro de un color, querrá decir
que no se puede pintar en el mapa sobre dicho color. Si se seleccionan todos
los colores, no se podrá pintar con ninguna herramienta en el mapa.

También se pueden seleccionar (enmascarar) colores pulsando con el ratón
{sobre el mapa} editado (mientras está el diálogo de máscaras abierto).

Los dos botones de la parte inferior de este diálogo cumplen la siguiente
función:

{Invertir}. Se utiliza para invertir el estado de selección de todos los
colores de la paleta. Si, por ejemplo, se quiere pintar sólo sobre un color,
será más fácil seleccionar ese color y después invertir las selecciones
pulsando este botón que seleccionar todos los demás uno a uno.

{Borrar}. Se utiliza para quitar las máscaras definidas, es decir, para
deseleccionar todos los colores en este diálogo.

{Nota} : Es bastante común, tras enmascarar algunos colores, olvidarse de ello
y más adelante ver que el programa de dibujo no está funcionando
correctamente. Es porque se deben quitar las máscaras primero (lo que se
puede hacer pulsando la tecla {M} y después el botón {Borrar} del diálogo).

{/}

{Un ejemplo práctico}

* Cree un mapa nuevo ({mapas \ nuevo...}), entre en el editor (con una doble
pulsación sobre el mapa), seleccione la herramienta del Spray (que se accede
pulsando {F9}), y pinte algo utilizando varios colores en el centro del mapa.

* Acceda al diálogo de máscaras pulsando {M} y seleccione el {color
transparente} para enmascararlo (el primer color de la paleta, arriba a la
izquierda).

* Salga del editor pulsando {ESC} y cree una copia del mapa arrastrándolo
hacia el tapiz de fondo.

* Arrastre la copia recién creada hasta la ventana con el mapa original, para
copiar el gráfico sobre sí mismo.

Si realiza estos pasos observará cómo, al mover el gráfico, no se imprime el
mismo sobre el fondo negro, ya que se ha enmascarado este color para que no
se pueda modificar. No se olvide quitar la máscara para poder seguir
dibujando normalmente.

# ─────────────────────────────────────────────────────────────────────────────

{.1270,Barras de punteado y lápiz}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Éstas son las dos barras de dibujo básicas para iniciar los dibujos o definir
los detalles pequeños.

{+108,0}La {barra de punteado} se utiliza para poner y quitar puntos en un mapa. Se
entiende por {quitar} puntos, ponerlos nuevamente en color transparente. Este
modo se suele utilizar para crear de forma precisa detalles muy pequeños de
los gráficos.

Se utiliza normalmente controlando el puntero con las teclas (usando uno de
los dos juegos de teclas: {cursores} o {QA,OP}), utilizando el teclado
también para seleccionar los colores (con {control} y los {cursores}, o con
{W,S} si se utiliza el segundo juego de teclas) y para poner y quitar los
puntos ({barra espaciadora}). También se suele emplear la combinación
{Mayúsculas+Barra espaciadora} para tomar un color de propio dibujo.

Esta forma de dibujar punto a punto permite crear gráficos con gran
definición (y paciencia). Para ello, se utiliza la barra de punteado y no la
de lápiz precisamente por la facilidad que ofrece de quitar un punto,
volviendo a pulsar en la misma posición una segunda vez, cuando se ha puesto
éste incorrectamente o por equivocación.{-}

{+109,0}La {barra de lápiz} es bastante menos tortuosa y se suele utilizar ya con el
ratón. Es la herramienta de dibujo básica por excelencia, y la utilizada para
iniciar la mayoría de dibujos o bocetos. Se conseguirán mejores resultados si
se trabaja en un nivel de ampliación bastante alto, ya que, de esta forma,
resulta más fácil prestar atención a los detalles.

No existe la posibilidad de variar el grosor del trazo, siendo éste siempre
de un punto. Los grosores mayores de trazo de otras herramientas no suelen
servir más que para hacer garabatos en lugar de dibujos, creando malos
hábitos de dibujar rápido y mal.{-}

{+110,0}En esta barra aparece ya el icono de {Porcentaje} que permite regular la
cantidad de tinta. Con un buen nivel de ampliación, el trazo de un punto y un
porcentaje de tinta bajo se conseguirán fácilmente buenos resultados. El
{porcentaje} se suele dejar al 100% inicialmente, mientras se define el
dibujo, utilizando porcentajes menores para el acabado final.{-}

Existe otra utilidad accesible con la barra de lápiz y es {difuminar}. Esto
se consigue manteniendo pulsada la tecla {D} mientras se pinta con el lápiz
sobre el dibujo. En este modo {no se pintará con el color seleccionado} (por
lo que da igual cual sea éste) si no que se modificarán gradualmente los
colores del mapa para paliar los cambios bruscos de color y evitar que
algunos puntos puedan destacar en exceso.

No debe intentarse comenzar un dibujo con porcentajes de tinta bajos,
difuminados, sprays, etc.; estos acabados artísticos deben dejarse para el
final. Para comenzar, se deben definir los contornos y secciones del dibujo
con trazos sólidos y limpios para, una vez retocados, comenzar con el
coloreado, brillos, etc.

Para retocar los contornos hasta que queden bien se deben realizar
normalmente varias aproximaciones, borrando (pintando con el color de fondo o
utilizando el {deshacer}) los trazos que hayan salido mal, para poder
corregirlos a tiempo.

# ─────────────────────────────────────────────────────────────────────────────

{.1271,Barras para líneas y multilíneas}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Estas dos barras permiten dibujar líneas rectas y se utilizan para definir
las partes más geométricas de los bocetos iniciales o para acabados muy
puntuales.

{+111,0}Se debe seleccionar primero el color y, después, realizar dos pulsaciones con
el ratón en ambos extremos de la línea. Cuando se ha definido el primer
extremo se verá la línea tal y como va a quedar cuando se defina el segundo;
para cancelar la operación en este momento, pulse el {botón derecho} del
ratón. Para cancelar la línea una vez definidos los dos extremos se debe
utilizar el {icono de deshacer} (o la tecla {Backspace}).

A la derecha de estas barras aparecen dos valores numéricos que son el {ancho
de la línea dibujada} (superior) y el {alto} (inferior). Estos valores
aparecen únicamente cuando se ha definido el primer extremo de la línea, para
ayudar a realizar mediciones. Para los ajustes precisos se suelen utilizar
los {cursores} para posicionar los extremos de la línea.

Estas barras tienen todos los iconos convencionales, entre ellos, el de
{porcentaje} que en este caso sólo se utiliza para realizar algunos retoques
concretos.{-}

{+112,0}La barra de {multilínea} es prácticamente idéntica a la anterior; la única
diferencia estriba en que permite dibujar varias rectas enlazadas unas a
otras. Para finalizar la multilínea se debe pulsar el {botón derecho} del
ratón una vez definido el último extremo.

Por último, también existe la posibilidad de utilizar el {difuminado} con la
tecla {D}, que puede utilizarse para varios efectos, por ejemplo, para
dibujar líneas con antidentado, como se muestra en el siguiente ejercicio
práctico:

* Cree un mapa nuevo, entre en el editor, elija la herramienta de líneas (F3)
y seleccione el color blanco.

* Dibuje una línea de las coordenadas (10,10) hasta las coordenadas (68,47);
utilice los cursores para ajustar las coordenadas. Verá como la línea tiene
un aspecto dentado (se ven mucho los puntos).

* Ahora dibuje una segunda línea de las coordenadas (10,9) hasta las
coordenadas (68,46) (un punto más arriba), pero al definir el segundo
extremo, mantenga pulsada la tecla {D}.

* Realice la misma operación un punto más abajo de la línea original, verá
como al crear dos líneas difuminadas por encima y debajo de la original ha
conseguido disimular el dentado de la misma.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1272,Barras para curvas y multicurvas}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Las barras de curvas permiten realizar trazos curvos en los bocetos iniciales
de forma precisa, sin requerir buen pulso para ello (al contrario de cuando
se realizan con el lápiz).

{+113,0}La {barra de curvas} se utiliza de forma similar a la de líneas, salvo que
crea curvas {bézier} en lugar de rectas. Primero, se deben definir los
extremos inicial y final de la curva, al igual que en las rectas pero,
después, se deben concretar otros dos puntos más. El primero de ellos
definirá la pendiente de la curva en el extremo inicial (hacia donde sale la
curva), pero cuanto más se aleje este punto del extremo inicial, con más
pendiente partirá la curva de este extremo. El segundo especificará la
pendiente del extremo final de igual forma. Tras las cuatro pulsaciones del
botón izquierdo del ratón, la curva quedará definida.{-}

{+114,0}La {barra de multicurvas} funciona de una forma ligeramente distinta. Resulta
bastante práctica a la hora de definir contornos curvos en un gráfico. Se
define una curva compleja por tramos, a base de {esplines}.

El primer tramo se definirá siempre como una {recta} fijando, como siempre,
sus extremos inicial y final. Después, se deben ir definiendo diferentes
puntos a lo largo del recorrido del contorno y el ordenador los irá uniendo
formando una curva continua automáticamente.

Es muy importante utilizar las teclas{ +} y{ -} {del teclado numérico} para
ir variando la {fuerza} con la que la curva sale de cada uno de los puntos
del recorrido. Es decir, para cada nuevo tramo se debe fijar el punto destino
y la pendiente inicial del tramo. Si se disminuye al mínimo la fuerza, esta
herramienta se comportará prácticamente igual que la de multilíneas.

Estas dos barras de curvas permiten también graduar el {porcentaje} de tinta
y utilizar el {difuminado} al igual que en las barras anteriores.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1273,Barras de rectángulos y círculos}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Estas barras permiten dibujar las formas geométricas más básicas. Tienen
varias aplicaciones, entre ellas, las de utilizarlas como filtros de color.

{+115,0}La {barra de rectángulos} se utiliza de forma similar a la de líneas,
seleccionando el color primero, y definiendo las dos esquinas del rectángulo
con dos pulsaciones del botón izquierdo del ratón sobre el mapa. En la parte
derecha de la barra aparece el {ancho} y el {alto} en puntos del rectángulo
que se está definiendo.{-}

{+117,0}Un nuevo icono, a la izquierda de las dimensiones del rectángulo, permite
seleccionar dos modos de funcionamiento de esta barra para dibujar
rectángulos o cajas sólidas (por defecto se dibujarán cajas).

Para dibujar cuadrados (o cajas cuadradas) se debe mantener pulsada la tecla
{Control} mientras se define el segundo extremo; de esta forma se forzará a
que el ancho y alto sean iguales.

Esta barra permite también establecer el {porcentaje} de tinta. Cuando se
dibujen cajas sólidas con un porcentaje de tinta menor al 100% sobre un
dibujo de fondo, se conseguirá el efecto de aplicar un {filtro de color}
sobre dicho dibujo. Según se está definiendo la caja se puede ir variando el
porcentaje de tinta (pulsando sobre el icono de porcentaje) hasta conseguir
el efecto deseado.{-}

{+116,0}La {barra de círculos} funciona prácticamente igual que la de rectángulos, ya
que  permite también dibujar círculos (rellenos) o circunferencias (sin
rellenar), aplicar filtros con el porcentaje, etc.

Los círculos se definen con {dos radios}, uno horizontal y otro vertical,
creando una especie de elipses que no son más que círculos achatados. Para
crear círculos perfectos, con los dos radios iguales, se debe mantener
pulsada la tecla {Control}, al igual que con los rectángulos.{-}

{+118,0}El icono selector de modo de los círculos permite, además de elegir entre
círculos o circunferencias, definirlos de dos modos:

* De esquina a esquina, definiendo la esquina superior izquierda e inferior
derecha de la caja que engloba al círculo.

* Del centro al radio, definiendo el punto central del círculo y después la
longitud de su radio (o las de sus radios, si no se pulsa {Control}).

Los iconos selectores de modo de ambas barras aparecen en un pequeño diálogo
que se despliega de la barra de herramientas, y sus dibujos son
autoexplicativos.{-}


# ─────────────────────────────────────────────────────────────────────────────

{.1274,Barra de spray}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Esta barra de herramientas permite utilizar el equivalente informático de un
spray de pintura (un aerosol o difusor) para realizar acabados artísticos e
irregulares. Es casi tan fácil de utilizar como un spray de verdad, se debe
seleccionar el color y pulsar con el ratón sobre el mapa a la vez que se
desplaza el puntero.

{+119,0}Es {imprescindible} utilizar el icono de {porcentaje} en esta barra para
regular la cantidad de pintura que suelta el spray. Por defecto, está fijado
a un 25% de opacidad. Para conseguir acabados precisos es mejor utilizar
porcentajes muy pequeños (incluso menores que el 25%) para, de esta forma, ir
retocando poco a poco el dibujo.{-}

{+120,0}En esta barra aparece un nuevo icono en el extremo derecho que sirve para
regular el {grosor del trazo} del spray, que ahora sí es necesario. Pulsando
sobre este icono, se extenderá un nuevo diálogo en el que se muestran los
grosores disponibles; se debe seleccionar el deseado pulsando con el ratón
sobre él.

Como siempre, se conseguirán mejores resultados con un nivel de ampliación
grande ({x4} o {x8}) con un spray de los pequeños y un porcentaje de tinta
bajo. También es importante aprender a utilizar las máscaras de color
(descritas en el punto 3.7) junto al spray para no salirse de las zonas en
las que se quiere aplicar el efecto.

El spray tiene varias aplicaciones interesantes, más para el retoque que para
el dibujo, por ejemplo, utilizar el spray sobre un gráfico mientras se
mantiene pulsada la tecla {D}, para {difuminar} de forma irregular el
gráfico.

Otra utilidad consiste en que sobre gráficos ya dibujados, aplicar {brillos
irregulares} con el spray, seleccionando el color blanco o el color negro
(según se quieran luces o sombras) y fijando el porcentaje de tinta al
mínimo.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1275,Barra de relleno}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Ésta es una de las barras más útiles del editor gráfico si se aprende a
utilizar debidamente, lo que requiere un poco de práctica. Tiene una
apariencia muy similar a las barras anteriores, pero una aplicación muy
diferente.

{+121,0}La {barra de relleno} sirve, como su nombre indica, para rellenar de colores
partes de los dibujos. Tiene cuatro modos distintos de funcionamiento que
conviene diferenciar; éstos se activan pulsando sobre el icono que está a la
derecha de la barra y seleccionando el modo de relleno con uno de los iconos
que aparecen.{-}

{/}

{Relleno convencional}

{+122,0}El primer modo (que se corresponde con el icono seleccionado por defecto) es
el relleno que tienen la mayoría de herramientas gráficas. Se selecciona un
color y se pulsa sobre una parte del dibujo; el programa pintará con el color
seleccionado todos los puntos del dibujo que sean del mismo color que el
punto sobre el que se ha pulsado y estén {pegados} o {unidos} a él.

{Ejemplo}: Se puede hacer una prueba en un mapa nuevo, dibujando un contorno
irregular cerrado con la herramienta del lápiz, seleccionando un color de
relleno y pulsando dentro del contorno en este modo de relleno. Si el
contorno está cerrado, se rellenará su interior con el color seleccionado. Se
puede realizar la misma operación también con el exterior.

Ésta es la herramienta utilizada para colorear los bocetos. Se debe tener
cuidado, cuando se vaya a utilizar el relleno, que todas las secciones a
rellenar estén {cerradas}, pues si existe algún hueco o fisura en su
contorno, el relleno también {saldrá al exterior} de la sección.{-}

{/}

{Relleno por diagonales}

{+123,0}Este modo es similar al anterior pero con una diferencia importante. Cuando,
en el relleno convencional, se seleccionan los puntos {unidos} al original
(al punto donde se inicia el relleno) se consideran únicamente los puntos
desde los cuales {se puede llegar al punto original}, sin pasar por un punto
de otro color, y con movimientos individuales en {línea recta} (pasando de
cada punto al siguiente por uno de los cuatro laterales).

Este relleno considera puntos unidos aquellos del mismo color que se unan
por una {diagonal}, además de los unidos por un {lateral}.

{Ejemplo}: En un mapa nuevo, dibuje un cuadrado de cualquier color con la
herramienta de rectángulos (sólo el borde, no una rellena del color). Dibuje
con el mismo color una circunferencia (tampoco rellena) en el interior del
cuadrado. Ahora seleccione otro color este modo de relleno y pulse en el
interior de la circunferencia. Verá como el relleno {se ha escapado} por las
esquinas de la circunferencia (por las diagonales) pero no del cuadrado (ya
que del mismo no puede salir ni por un lateral ni por una diagonal de ningún
punto).

La utilidad de este relleno consiste en poder cambiar de color gráficos de
líneas de puntos, ya que éstos consisten en puntos unidos tanto por laterales
como por diagonales, y el relleno convencional no podría recorrerlos.

{Ejemplo}: En un mapa nuevo dibuje un garabato (cualquiera) con la
herramienta del lápiz (en un solo color). Ahora seleccione otro color y, con
este modo de relleno, pulse sobre un punto del garabato; verá cómo se rellena.
Puede realizar la prueba con el modo de relleno convencional y comprobará
como en ese caso únicamente se consigue rellenar uno de los segmentos que
forman el garabato (ya que el relleno convencional no se escapa por las
diagonales).{-}

{/}

{Relleno hasta un límite}

{+124,0}El tercer modo de relleno es el más fuerte de todos, aunque que no el más
útil. En lugar de rellenar un color con otro (como los dos anteriores),
rellena con un color todos los colores que se encuentre, hasta que se
encuentre con un borde del mismo color.

{Ejemplo}: En un mapa con varios dibujos, seleccione un color que no utilicen
los mismos (un morado, un verde claro, etc.) y, sobre ellos, dibuje con el
lápiz un contorno cerrado, dejando parte de los dibujos dentro del contorno y
parte fuera. Finalmente, con el mismo color, seleccione este modo de relleno y
pulse dentro del contorno. Se rellenará el contorno interior, sin importar
los dibujos que hubiera dentro.

Si en una mapa de fondo negro hay dibujados varios gráficos, se elige este
modo de relleno (con el color negro del fondo seleccionado) y se pulsa en uno
de los gráficos; éste se borrará. Esto sucede porque el programa ha rellenado
con el color negro hasta que se ha encontrado un borde del mismo color (el
exterior del gráfico).{-}

{/}

{Relleno con un gradiente}

{+125,0}Es el modo de relleno más apreciado por todo dibujante y, además, uno de los
más difíciles de encontrar en otros programas de dibujo. Requiere un poco de
técnica, pero después se pueden conseguir con él resultados fantásticos.

En este modo se rellena una sección de un color con un {gradiente} de colores
de la {gama seleccionada} en la barra de herramientas (ver la ayuda sobre
las {#1267,gamas de colores} para saber cómo definir y seleccionar estas gamas). {Se utilizarán
colores más claros o más oscuros de la gama en función de la luminosidad de
los colores que delimitan la sección rellenada}.

{Ejemplo}: En un mapa nuevo, seleccione una gama de colores uniforme (por
ejemplo, cualquiera de las definidas en la paleta por defecto de DIV). Ahora
dibuje una circunferencia (y no un círculo relleno) con uno de los colores
más oscuros de la gama de unos 50 por 50 puntos (no muy grande) y, dentro de
la misma, un pequeño círculo (relleno) con el color más claro de la gama.
Finalmente, seleccione este modo de relleno (con la gama de colores en la
barra de herramientas) y pulse entre el círculo y la circunferencia.

Aparecerá {una nueva barra} de herramientas con dos iconos, una flecha simple
y otra doble. Debe pulsar uno de estos dos iconos para que se comience a
realizar el gradiente. La {flecha simple} avanza un paso y la {doble} varios.
Cuando esté satisfecho con el resultado, pulse el {botón derecho} del ratón
para volver a la barra de relleno.

Es recomendable realizar varias pruebas rellenando formas diferentes para
observar los resultados que se pueden llegar a obtener. Debe tener en cuenta
que lo que provoca el gradiente es que, en el contorno de la zona rellenada,
haya colores claros y colores oscuros. En realidad lo que se consigue con
este modo es rellenar una sección con la media de colores que definen su
contorno, interpolando su luminosidad.

El efecto {tardará más cuanto más grande sea la zona} a rellenar, por lo que
se debe procurar dividir las zonas grandes en varias pequeñas, siempre que
sea posible.

No siempre se consiguen mejores resultados cuanto más tiempo se esté
aplicando el gradiente, sino que muchas veces, al aplicarlo en exceso, se
acaban apreciando demasiado los contornos de la sección, con lo que el
resultado empeora.

No hay muchas reglas fijas para obtener buenos resultados con los gradientes
aunque, en gran medida, depende de la {uniformidad} y {número de colores de
la gama} (es mejor utilizar gamas de 32 colores siempre que sea posible) y de
la sección a rellenar. Es una herramienta bastante "artesanal", por definirla
de alguna manera, por lo que la práctica resulta imprescindible para llegar a
dominarla.

{Nota}: La barra de edición de bloques descrita a continuación también se
puede utilizar para hacer otros tipos de rellenos de color muy efectivos.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1276,Barra de edición de bloques}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

Ésta es la barra principal del editor gráfico y la más importante de todas.
Sirve principalmente para seleccionar zonas del dibujo y permite acceder a
otras barras de herramientas para realizar distintas operaciones con estas
zonas.

{+126,0}Es la herramienta gráfica de cortar y pegar pero su funcionalidad no queda
ahí, sino que permite rotar, escalar, aclarar, suavizar, invertir, etc.

La primera acción a realizar siempre será {seleccionar la zona} con la que se
quiere trabajar. Un icono en la parte derecha de la barra con el dibujo de
{un cuadrado punteado} indica el modo en el que se va a realizar esta
selección. Pulsando en dicho icono se desplegará un diálogo con seis iconos
que indican las posibles formas de seleccionar una zona de un gráfico.{-}

{+144,0}Aprender a seleccionar partes de los mapas de estas seis formas será de gran
ayuda para conseguir soltura en el manejo del editor gráfico, por lo que se
describirá a continuación la {forma de seleccionar zonas} en cada uno de estos
modos. Más adelante se explicarán las operaciones que pueden realizarse con
estas zonas una vez seleccionadas. Puede probar todos estos modos sobre un
mapa con algunos dibujos; una vez seleccionada la zona con un modo, pulse la
tecla {ESC} para poder probar a seleccionar con otro de los modos.

{/}

{Selección por caja}

{+127,0}Esta forma de seleccionar una zona del mapa editado es la más sencilla.
Consiste en marcar una simple caja (o rectángulo) del mismo; para hacerlo se
debe pulsar en dos de los extremos de la misma con el botón izquierdo.

Una vez definida la caja inicial, se podrá ajustar ésta pulsando cerca de sus
esquinas para situarlas en una nueva posición, o bien pulsando cerca del
punto central de uno de sus cuatro laterales para ampliar o reducir la caja
por ese lado.{-}

{/}

{Selección por relleno}

{+128,0}Ésta es una selección muy versátil. Permite seleccionar una zona de un mapa
seleccionando un conjunto de colores a partir de uno o varios puntos. Se debe
pulsar sobre la zona a marcar varias veces, o ir desplazando por la misma el
puntero del ratón con el botón izquierdo del ratón pulsado, hasta seleccionar
la zona completa.

Requiere practicarse para poder comprender bien su funcionamiento. Una vez
marcada la zona del mapa, se pueden seguir añadiendo más colores o zonas.
Esta selección no es siempre adecuada pero, en muchas ocasiones, permite
seleccionar zonas complejas rápidamente. Es muy similar a la {varita mágica}
de otros programas de dibujo, que así es como la denominan.

Si, por ejemplo, se pulsa con el ratón sobre un punto amarillo, se
seleccionarán todos los puntos amarillos que estén unidos al original. Si,
después, se pulsa en un punto rojo, seleccionarán todos los puntos amarillos
o rojos unidos a los originales (al rojo y amarillo original). Y así
indefinidamente.{-}

{/}

{Selección poligonal}

{+129,0}La selección poligonal es otras de las más comunes en los programas de
dibujo. Consiste en marcar la zona dibujando su contorno. Esto se puede hacer
de dos formas: definiendo varios puntos (pulsando con botón izquierdo el
ratón) alrededor de la zona que el ordenador unirá con líneas rectas, o bien
dibujando a pulso el contorno de la misma (moviendo el puntero con el botón
izquierdo pulsado).

La selección no se completará hasta que no {se cierre el contorno} por
completo. Esto se puede hacer también de dos formas: llegando hasta el punto
inicial del contorno nuevamente, o pulsando el {botón derecho} del ratón (o
la tecla {ESC}) para que el ordenador una los extremos inicial y final del
contorno.

Una vez cerrada la selección poligonal ésta no podrá modificarse, por lo que
si se ha definido incorrectamente, se debe pulsar otra vez el {botón derecho}
(o la tecla {ESC}) {para desmarcar la zona} y poder de este modo volver a
definir la selección.{-}

{/}

{Selección por varias cajas}

{+130,0}Ésta es otra forma rápida de seleccionar partes de un mapa. Se comienza
definiendo una caja simple, como en el primer modo, pero una vez definida la
misma, en lugar de poder ajustarla, se podrán definir más cajas. La unión de
todas las cajas marcadas formará la zona seleccionada.

Se utiliza para marcar rápidamente dibujos que no pueden marcarse con un caja
simple porque se incluiría en la misma una parte de otro dibujo que no se
quiere seleccionar. Por ejemplo, un gráfico en forma de "L" se podría marcar
fácilmente con dos cajas.{-}

{/}

{Selección por caja automática}

{+131,0}Este modo de selección y el siguiente son los más rápidos de todos. Se pueden
utilizar únicamente para seleccionar un dibujo dentro de mapa con varios
separados. Es imprescindible que el fondo principal del mapa sea de {color
transparente}. Es decir, que los puntos exteriores a los dibujos sean del
primer color (el 0) de la paleta.

Si se pulsa sobre cualquier punto de un dibujo del mapa, se seleccionará
instantáneamente la {mínima caja que lo contiene} (una zona rectangular que
contenga este gráfico). Los dibujos deben estar lo suficientemente separados
unos de otros como para que se pueda definir una caja que no "pille" a los
gráficos adyacentes.

Si una vez definida la selección se vuelve a pulsar sobre el mismo dibujo,
{la caja se ampliará un punto} por sus cuatro laterales, es decir, incluirá
al dibujo con un margen añadido de un punto. Si entonces se vuelve a pulsar
otra vez, volverá a su tamaño original, o bien se ampliará aún más si ha
encontrado otra parte del gráfico cerca de la original.

En cambio, si se pulsa sobre otro dibujo diferente del mapa al inicialmente
seleccionado, se desmarcará el original y se seleccionará el nuevo gráfico.{-}

{/}

{Selección por relleno automático}

{+132,0}Esta selección es similar a la anterior, pero utilizando técnicas de relleno
en lugar de cajas. Es como si en la selección por relleno antes comentada
estuvieran preseleccionados todos los colores menos el transparente, es
decir, al pulsar sobre un punto del dibujo {se incluirán todos los puntos
unidos al original que no sean del color transparente}.

Esta es una herramienta de selección realmente potente, que puede facilitar
mucho el trabajo con el editor gráfico. Además, una vez definida la selección
inicial, se pueden seguir añadiendo selecciones a la misma, es decir, que se
pueden marcar tantos dibujos del mapa original como sea necesario.

{/}

{Controles comunes a todos los modos de selección}

* Todas estas selecciones, una vez definidas, pueden desplazarse por pantalla
si se mantiene pulsada la tecla Control a la vez que se pulsa con el {botón
izquierdo del} ratón sobre una posición del mapa editado.

* Para cancelar cualquier selección (desmarcarla) se debe, simplemente,
pulsar el {botón derecho} del ratón o la tecla {ESC}. Entonces se devolverá
la barra de edición a su estado original, pudiendo {volver a definir la
selección} desde el principio, cambiar el modo de selección, o salir de esta
barra de herramientas.

* Según se selecciona una zona se puede consultar siempre el {ancho} y {alto}
de la misma en el extremo derecho de la barra de edición.

* Puede resultar útil, según se está definiendo la selección, utilizar la
tecla {Z} para variar el nivel de ampliación y así poder observar mejor
cuáles son los puntos que se están incluyendo en la misma.

{/}

{Una vez definida la selección}

En cuanto haya una zona del mapa seleccionada, aparecerán tres nuevos iconos
en la barra. Éstos son los iconos de {mover}, {efectos} y {cortar a ventana},
respectivamente, de izquierda a derecha.

{+133,0}El icono de {cortar a ventana} es el más sencillo de los tres. Al pulsarse
{se crea una nueva ventana de mapa} en el escritorio {y se pega la zona
seleccionada} en el mismo. Dentro del editor gráfico únicamente se verá cómo
{se desmarcará la selección} pero, al salir del mismo, aparecerá la nueva
ventana de mapa en el entorno.

Este icono es realmente útil ya que permite una gran flexibilidad en las
operaciones con bloques gráficos, por ejemplo:

* {Copiar secciones de unos mapas a otros}. Extrayendo la selección a un
nuevo mapa y, después, arrastrándolo al mapa en el que se quiere copiar.

* {Editar gráficos en mapas más grandes}. Los mapas son como escritorios de
trabajo que deben ser amplios. Por ejemplo, crear un dibujo de 20 por 20
puntos en un mapa del mismo tamaño permite muy pocas comodidades. Resulta más
fácil crear este dibujo en un mapa de 200 por 200 puntos que permite tener
varias copias, texturas y pruebas del mismo para, cuando se finalice el
dibujo, extraerlo al  mapa de 20 por 20 puntos.

* {Extraer un gráfico o textura de un mapa}. Se suelen utilizar los mapas
para crear muchos dibujos, no sólo uno. Finalmente, para incluir estos
gráficos en el juego, se seleccionarán, se cortarán, a mapas individuales y
se meterán en un {fichero FPG} que pueda ser cargado en el juego.

Si se pulsa el icono de {mover} o el de {efectos}, se accederá a nuevas
barras de herramientas, para mover y copiar la zona seleccionada o para
aplicarle efectos gráficos. A continuación se describen estas dos nuevas
barras.{-}

{/}

{Mover la zona seleccionada}

{+134,0}Una vez seleccionada una zona de un mapa, pulsando sobre el icono de mover
(que muestra una mano sobre un hombrecillo), se accederá a la barra para
cortar, copiar y pegar bloques gráficos.

{Nota}: Ésta es también la barra que aparece cuando se arrastra un mapa hasta
otro en el escritorio del entorno.

En ella se moverá la selección con el puntero del ratón (una mano) por el
mapa; para {copiar} el bloque a una nueva posición se debe pulsar el {botón
izquierdo} del ratón; para ocultar el gráfico del puntero del ratón (para ver
cómo quedaría el bloque en una posición, sin la mano encima) se puede pulsar
la tecla {H} (de {hide}, ocultar en inglés).

Para retornar de esta barra se pueden utilizar los comandos usuales, como son
el {botón derecho} del ratón, o la tecla {ESC}.{-}

{+136,0}En esta barra hay bastantes iconos nuevos; a continuación de las coordenadas
están los iconos de ampliación y deshacer, como en la mayoría de barras,
apareciendo a su derecha los siguientes:

* {Opacidad / Semiopaco}. Pulsando en este icono se conmutará entre dos
formas de copiar el gráfico: opaco (por defecto) o semi-opaco. La única
limitación a la hora de copiar el gráfico semiopaco (con un efecto de
transparencia), es que no siempre se encuentran en la paleta los colores
necesarios para crear el efecto, por lo que se utilizan los más aproximados.

* {Color transparente}. Este icono se debe pulsar cuando no se quiera que el
primer color de la paleta se muestre como {transparente}. Es decir, cuando se
quiera mover la selección como un bloque rectangular compacto, sin huecos.
Sirve para evitar que se mezcle el bloque copiado con lo que haya en el fondo
del mapa.

* {Inversión horizontal}. El tercer icono invertirá el bloque horizontalmente
(lo espejará). Si se vuelve a pulsar, se devolverá el bloque a su posición
original.

* {Inversión vertical}. Este icono es el complementario del anterior. Se
invertirá el gráfico verticalmente cuando se pulse.

* {Rotación angular}. Al pulsar en este icono aparecerá una {nueva barra} que
se utiliza para rotar el bloque (girarlo). Su funcionamiento es muy simple;
primero se debe situar el bloque en una posición cualquiera del mapa y pulsar
el {botón izquierdo} del ratón. Ahora, moviendo el ratón alrededor del
gráfico, se definirá el nuevo ángulo del mismo. Para fijar el ángulo se debe
pulsar el {botón izquierdo} nuevamente, mientras que para cancelar la
rotación se debe pulsar el {botón derecho}.

* {Escalado del bloque}. Éste es el icono para cambiar el tamaño del bloque
(ampliarlo o reducirlo). Funciona prácticamente igual que el de rotación,
también aparece una {nueva barra}; primero se pulsa sobre una posición del
mapa y después, moviendo el ratón, se selecciona el nivel de ampliación para,
finalmente, fijarlo pulsando nuevamente con el {botón izquierdo} en el mapa.

* {Borrar la selección original}. El último icono borrará la zona original en
el mapa. {Se borrará con el color seleccionado en la barra de edición de
bloques}. Por lo que, si se quiere borrar con el {color transparente}, se
deberá seleccionar éste primero (antes de entrar en la barra de mover). Este
icono se utiliza para {mover un bloque}, primero se selecciona la zona,
después el icono de mover para acceder a esta barra, entonces se borra el
bloque de su posición original con este icono y, finalmente, se copia en la
nueva posición.

Todos estos iconos son compatibles entre sí, es decir, se pueden seleccionar
todos los efectos necesarios para conseguir el resultado deseado.

Se puede observar que el icono de borrar la selección original se puede
utilizar como herramienta de relleno, seleccionando el color en la barra de
herramientas y la zona a rellenar (con cualquiera de los modos de selección)
para que, al pulsar este icono, se rellene la selección con el color elegido.{-}

{/}

{Aplicar efectos a la selección}

{+135,0}Una vez seleccionada una zona de un mapa, pulsando sobre el icono de efectos
(con las letras {FX}) se accederá a la barra de herramientas para aplicar
efectos al bloque seleccionado.

En esta barra se seguirá viendo la línea de puntos que delimita la selección.
Para volver de esta barra se pueden utilizar igualmente el {botón derecho}
del ratón o la tecla {ESC}.{-}

{+137,0}También aparecen nuevos iconos en esta barra a partir del icono de deshacer
(que se debe utilizar cuando con un efecto no se obtenga el resultado
deseado). Estos iconos se describen a continuación, de izquierda a derecha:

* {Pasar a la gama seleccionada}. Se convertirán todos los colores de la zona
seleccionada a los colores de la gama seleccionada en la barra de
herramientas (de edición). Por ello, antes de entrar en la barra de efectos
se debe haber seleccionado la gama de colores. La conversión se realiza en
función de los niveles de luminosidad de los puntos seleccionados y de los
colores de la gama.

* {Invertir colores}. Crea el negativo de la zona seleccionada, cambiando los
colores claros por oscuros y los oscuros por claros.

* {Crear un borde}. En primer lugar, se tiene que seleccionar un gráfico con,
al menos, un margen de un punto, y el color del que se quiere crear el borde.
Después, al seleccionar este icono, se creará un borde de dicho color por
todo el contorno del gráfico.

* {Aclarar}. Aclara todos los puntos seleccionados, es decir, incrementa
ligeramente su luminosidad. Con la única limitación de los colores
disponibles en la paleta.

* {Oscurecer}. Es la operación contraria a la anterior; resta luminosidad a
todos los puntos de la zona seleccionada. Si se aclara o se oscurece en
exceso, se debe utilizar el icono de deshacer, y no la operación inversa, ya
que, en ese caso, se degradarían cada vez más los colores del dibujo
original.

* {Suavizar}. El icono más a la derecha permite suavizar todos los puntos de
la zona seleccionada. Se debe utilizar para efectos en zonas muy concretas,
ya que sobre dibujos completos crearía el efecto de que éstos están borrosos.
Para evitar que algunos puntos de un gráfico se vean en exceso es mejor
utilizar las herramientas para difuminar de forma localizada (herramientas
como el lápiz o el spray, manteniendo la tecla {D} pulsada).{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1277,Barra de deshacer}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

{+138,0}La barra de deshacer, a la que se accede por el icono con una doble flecha o
la tecla {F12} dentro del editor, sirve para deshacer o volver a repetir
todas las acciones hechas en el editor gráfico.

Deshacer acciones se puede realizar desde prácticamente todas las barras, con
la tecla {Backspace} (la tecla de borrado situada encima de {Enter}), y para
repetirlas nuevamente se debe mantener pulsada {Mayúsculas} mientras se pulsa
la misma tecla.

Por lo tanto, normamente no es necesario acceder a esta barra. Pero cuando se
deban deshacer muchas acciones será más cómodo, pues dispone de cuatro
botones para deshacer y repetir acciones a dos velocidades diferentes. Los
iconos de esta barra son autoexplicativos: las flechas hacia la izquierda son
para deshacer y las flechas hacia la derecha para repetir (rehacer).{-}

{+139,0}Resulta bastante divertido, una vez se ha creado un dibujo en un mapa,
utilizar esta barra para deshacer y repetir el trabajo, como si de un vídeo
se tratara.

El límite de acciones que se pueden recuperar lo marca la {memoria de
deshacer}, que se puede definir en la ventana de configuración (con la opción
{sistema \ configuración...}). El límite por defecto es 1088Kb, que será casi
siempre suficiente, pero puede convenir ampliarlo si se está trabajando con
mapas muy grandes.

{Importante:} Cuando se trabaja en varios mapas es vital saber que sólo se
podrán deshacer acciones en el último mapa en el que se ha trabajado. Por
ejemplo, si se tienen dos mapas, se entra en uno para dibujar un círculo y
después en el otro para dibujar un cuadrado; no se podrá deshacer el círculo
a no ser que se deshaga primero el cuadrado. Es decir, que sólo se pueden
deshacer las acciones en el orden contrario al que se han hecho.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1278,Barra de texto}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

{+140,0}La barra de texto sirve para {escribir textos} en los mapas con las fuentes
de los archivos {FNT}, o las creadas con el {Generador de fuentes} (explicado
en el {#1256,menú de fuentes}).

La apariencia de esta barra es, prácticamente, idéntica al resto de
herramientas. Para escribir con una fuente (un tipo de letra) debe existir en
el entorno alguna {ventana de fuentes de letras} activada (ver el menú de
fuentes).

* {Si no existe una ventana de este tipo}, se podrá escribir con {la fuente
de letras utilizada por el editor de programas} (se puede seleccionar en
{sistema \ configuración...} entre varios tamaños de fuente para el editor).
Para escribir con la fuente de editor, se debe seleccionar el color para las
letras primero y, después, pulsar sobre cualquier parte del mapa (con el
{botón izquierdo}) para introducir el texto. Una vez introducido el texto se
debe pulsar la tecla {ESC} o el {botón derecho} del ratón.

* {Si existe una ventana de fuente activada} entonces se escribirá con ella.
En este caso, {se debe selecionar el color transparente} para escribir un
texto. Si se selecciona otro color diferente, se mostrará la {fuente tintada}
con él. Es decir, que para utilizar los colores naturales de la fuente, se
debe seleccionar el primer color de la paleta.

Mientras se introduce el texto, se puede posicionar el cursor pulsando con el
ratón en otra parte del mapa.

Cuando se está introduciendo un texto se puede borrar el carácter anterior
con la tecla {Backspace}, y la tecla {Enter} saltará a la línea siguiente.

{Nota}: Esta barra también dispone del icono de {porcentaje} de tinta, que
puede utilizarse para escribir textos traslúcidos en lugar de opacos. De esta
forma se pueden conseguir efectos de rotulación atractivos, al escribir sobre
diferentes texturas.{-}

# ─────────────────────────────────────────────────────────────────────────────

{.1279,Barra de puntos de control}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

{+141,0}La última barra de herramientas accesible no es una barra de dibujo, sino que
se utiliza para definir {puntos de control} dentro de los mapas que se van a
utilizar en los juegos para tener, de esta forma, localizadas ciertas
posiciones en los mismos.

Hay diferentes aplicaciones que se les pueden dar a estos puntos dentro de
los programas de DIV.

Esta barra de puntos de control permite situar hasta 1000 puntos diferentes
dentro de un gráfico, y cada uno será identificado por su número (del 0 al
999).{-}

{+142,1}{-}
Para situar uno de estos puntos, basta con seleccionar el número de punto con
los {iconos flecha izquierda} y {flecha derecha} y, después, pulsar sobre el
gráfico.

Para {borrar} (deseleccionar) un punto de control, se debe volver a pulsar
sobre el mismo en el mapa una segunda vez.

El único punto de control que utiliza el sistema es el punto de control
{número 0} (el primero); éste es el punto que define cuál es el {centro
virtual} del gráfico y que tiene múltiples aplicaciones dentro del lenguaje.

Cuando no se defina el punto de control número 0, el sistema actuará como si
el {centro virtual} del gráfico fuera el {centro real} del mismo (un punto
situado en la mitad del ancho y la mitad del alto del gráfico).

{Nota}: Una vez definidos los puntos de control, para que éstos tengan efecto
dentro de un programa, debe guardarse nuevamente el {mapa} (archivo {MAP}) o
volverse a incluir el mismo en el fichero de gráficos (archivo {FPG})
arrastrándolo hasta el mismo (según cuál de ambos archivos se cargue en el
programa).

# ─────────────────────────────────────────────────────────────────────────────

{.1280,Edición de animaciones}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

El editor gráfico de DIV también permite crear y editar secuencias de
animación. La secuencia de imágenes se creará en una serie de mapas {todos
del mismo tamaño en puntos}, es decir, que si se quiere crear una animación
de un tamaño de 100 por 100 puntos y 8 {fotogramas}, se deben crear primero
los 8 mapas de 100 por 100 puntos en el escritorio.

La manera más fácil de crear varios mapas del mismo tamaño es crear el
primero (con la opción {mapas \ nuevo...}), y entonces arrastrar el mismo
varias veces al tapiz.

{+143,0}Después se deben {ordenar las ventanas de los mapas}; esto se hace,
simplemente, colocando todas las ventanas solapadas, unas sobre otras. Se
coloca en cualquier parte del escritorio la última, sobre ésta la
antepenúltima, etc. No es aconsejable colocar cada ventana {justo encima} de
la anterior, sino más bien ligeramente desplazada, por ejemplo, un poco más
a la derecha y un poco más abajo.

{Importante}: Si existen más mapas del mismo tamaño en el escritorio
(continuando con el ejemplo anterior, algún otro mapa de 100 por 100 puntos
que no deba formar parte de la animación), {se deben minimizar sus ventanas}
para que el programa sepa que no deben incluirse en la animación. Una vez
editada la animación, podrán volver a {maximizarse} estos mapas.

Una vez colocadas todas las ventanas en orden se podrá comenzar a editar la
animación. Para ello, simplemente se debe editar la ventana superior de todas
las que forman parte de la animación (la que está sobre todas las demás) con
una doble pulsación sobre la misma. Y, una vez dentro del editor gráfico, se
podrá pasar al fotograma siguiente con la tecla {TAB} y al anterior con
{Mayúsculas+TAB}.{-}

{/}

{Ejemplo práctico}

Continuando con el mismo ejemplo, una vez creados los ocho mapas de 100 por
100 puntos (todos ellos vacíos, en negro) se colocarán en orden según se ha
explicado (da igual el orden en el que se coloquen los mapas ya que todos
están vacíos, por lo que cualquiera puede ser el primero, el segundo, el
último, etc).

Entonces, se realiza una doble pulsación con el ratón para editar el mapa
superior (el último que se ha colocado). Ahora seleccione un color cualquiera
y la herramienta del lápiz. Dibuje en el mapa un 1 en grande (da igual cómo
le quede el número), ahora pulse {TAB} y dibuje en el segundo fotograma un
dos, pulse {TAB} nuevamente y dibuje un tres, ... y así hasta el ocho.

Ya está creada la animación; puede utilizar la tecla {TAB} (con o sin
presionar {Mayúsculas}) para visualizar la animación. Si deja pulsada esta
tecla, verá la animación seguida; utilice la tecla {Z} para variar el nivel
de ampliación en el que se ve la animación. Puede seguir editando cualquiera
de sus fotogramas.

{Nota:} Si sale del {editor gráfico} en un fotograma que no sea el primero,
por ejemplo en el cuarto, verá que las ventanas están colocadas {en otro
orden}, con el cuarto fotograma sobre los demás. No se preocupe, siguen
estando ordenados, pero ahora {cuando quiera volver a editar la animación
pulse sobre el fotograma superior de todos}, el cuarto, para no
descolocarlos.

{/}

{Algunos consejos sobre las animaciones}

Si quiere crear un gráfico animado, la mejor forma suele ser crear primero
una animación esquemática, dibujando unos cuantos palotes que representen al
gráfico. Cuando la animación en esquema quede bien, entonces edite el primer
fotograma y dibuje en detalle el gráfico definitivo sobre el esquema de
palotes. Después, utilice las mismas técnicas y herramientas para completar
el resto de fotogramas.

Cuando se retocan animaciones largas (de muchos fotogramas) es conveniente,
en ocasiones, concentrarse en una parte concreta de la animación, para ello
minimice el resto de los fotogramas.

La mejor forma de guardar en disco las animaciones es hacerlo en un {fichero
FPG}. Si no tiene ningún fichero todavía, cree uno nuevo ({ficheros \
nuevo...}). Entonces arrastre hasta la ventana del fichero el primer
fotograma e introduzca un código y una descripción para el mismo. Después,
el resto en orden (el programa le sugerirá códigos consecutivos para el resto
de fotogramas). Cuando quiera volver a trabajar sobre esta animación, marque
todos los fotogramas en la ventana del fichero y utilice la opción {ficheros
\ cargar marcados}.

Si la animación no consta de muchos fotogramas, y estos no son muy grandes,
puede utilizar un pequeño truco para ordenar los fotogramas de la animación
sin tener que colocar los mapas unos sobre otros; éste consiste {en pasar el
puntero del ratón sobre todos los mapas en orden inverso} (primero sobre el
último, después sobre el penúltimo, etc.) hasta que llegue al primero.
Entonces entre en el editor gráfico con una doble pulsación, los fotogramas
estarán igualmente ordenados. El único problema es que se desordenarán los
mismos si sale del editor gráfico y mueve el puntero del ratón sobre el
escritorio de forma desordenada.

# ─────────────────────────────────────────────────────────────────────────────

{.1281,Trucos y técnicas avanzadas de dibujo}
Ver: {#3,Indice} - {#1261,Ayuda sobre el editor gráfico} {/}

En este último punto dedicado al {editor gráfico} se describen algunos trucos
y técnicas que han empleado los artistas gráficos de Hammer Technologies para
conseguir mejores resultados en los gráficos de los juegos adaptados, por
supuesto, a las posibilidades del editor gráfico de DIV Games Studio.

Se recomienda abordar este punto únicamente cuando se conozcan ya
perfectamente todas las posibilidades de este editor.

{/}

{Uso de escalados}

Esta primera técnica consiste en realizar gráficos al doble de su tamaño
para, después, reducirlos a la mitad, con lo que se gana bastante calidad y
definición en los mismos.

Por ejemplo, para crear un dibujo de 100 por 100 puntos se hace éste a 200
por 200 puntos y, después, se reescala a su verdadero tamaño (con la opción
{mapas \ reescalar...}).

Pruebe por ejemplo a realizar un dibujo de trazos, en color blanco sobre el
fondo negro, dividido en pequeñas secciones cerradas; después, coloree estas
secciones (con la herramienta de relleno normal y colores diversos), elimine
los trazos blancos (con la herramienta de relleno por diagonales y el color
negro) y, finalmente, reduzca el mapa a la mitad de su tamaño.

Otra técnica curiosa. En el dibujo anterior, en lugar de eliminar los trazos
blancos, selecciónelos con la herramienta de edición de bloques (con la
selección por relleno, pulsando sobre estos trazos) y aplíqueles el efecto
de suavizar varias veces (con la barra de efectos)...

{/}

{Uso de máscaras para sustituir colores}

En ocasiones se quiere sustituir un color de un mapa por otro diferente. Esto
se puede conseguir como se muestra a continuación.

Por ejemplo, cree un mapa con varios garabatos de lápiz en diferentes
colores. Ahora, para sustituir uno de los colores por otro seleccione el
diálogo de máscaras (tecla {M}), seleccione el color a cambiar (puede pulsar
sobre el mapa para ello) y pulse el botón de {Invertir} (para proteger contra
escritura todos los colores menos el que quiere cambiar). Finalmente,
seleccione la herramienta de rectángulos (cajas rellenas), seleccione el
nuevo color y dibuje un rectángulo que ocupe el mapa completo (de esquina a
esquina) ... ¡ah !, y no se olvide de quitar la máscara para seguir
trabajando.

{/}

{Empleo de las ventanas}

Esto más que una técnica es un consejo. Utilice siempre las posibilidades de
ventanas del entorno para guardar copias de seguridad del trabajo. Cuando
vaya a intentar "mejorar un gráfico", puede convenir seleccionarlo y
cortarlo a una nueva ventana de mapa. De esta forma, siempre podrá recuperar
el gráfico original "si la mejora no lo mejora". Cuando ya no necesite estas
copias de seguridad, cierre las ventanas.

{/}

{Usar las teclas para ajustar bloques}

Cuando esté creando un fondo mapeado para un juego, es decir, creando un
decorado a partir de bloques básicos que se repiten varias veces, utilice los
cursores para ajustar correctamente los bloques, ya que estos siempre
ofrecerán más seguridad en los movimientos que el ratón. Recuerde que la
tecla {Bloq. Núm.} del teclado numérico debe estar desactivada para que los
cursores muevan el bloque de un punto en un punto.

{/}

{Creando gamas de colores}

Una vez definida la paleta de colores para el juego. La apropiada definición
de gamas de colores puede simplificar mucho el trabajo dentro del editor
gráfico.

Cuando necesite en un dibujo realizar una {transición de un color a otro},
acceda al editor de gamas de colores (tecla {C}) y seleccione una de las
gamas que no esté utilizando para redefinirla. Defina una gama de {16 o 32
colores y editable cada 8 colores}; entonces sitúe uno de los colores en una
de las posiciones de la gama (pulsando sobre los pequeños iconos con una
flecha gris hacia arriba) y el otro en la siguiente posición (ocho colores
más a la derecha o izquierda). El programa buscará por usted {la mejor
transición} posible en la paleta de un color al otro (los colores
intermedios entre ambos). Esto será útil para encontrar transiciones entre
distintos colores, como de un rojo a un azul, de un verde a un marrón, etc.

Realice siempre pruebas seleccionando colores de la gama y reasignándolos a
otra posición de la misma (pulsando primero sobre un color de la gama y
después sobre uno de los pequeños iconos grises), para obtener diferentes
secuencias de colores que puedan serle útiles.

{/}

{Redefinir el color transparente para evitar pixelaciones}

Se denomina pixelación a cuando se aprecian demasiado los puntos del contorno
de un gráfico. Si el juego se va a desarrollar sobre un fondo de un color
determinado, o sobre unos ciertos tonos de color, se pueden crear gráficos
cuyos contornos se disimulen mejor en el fondo con la técnica aquí expuesta.

Por ejemplo, cree un mapa nuevo de 80 por 80 puntos y dibuje algún gráfico
(pueden servir un círculo blanco y otro en un color oscuro separados) pero
deje, al menos, un margen libre de un punto alrededor del gráfico (vacío, en
color negro). Suponiendo ahora que éste es un gráfico que debe aparecer sobre
un fondo azul de un cielo en el juego, siga los siguientes pasos:

* Entre en el editor de paletas ({paletas \ editar paleta..}), seleccione el
color transparente (el color negro de arriba a la izquierda) y modifíquelo
para que sea del color del supuesto fondo del juego (el azul que prefiera,
por ejemplo, un 25 de verde y un 50 de azul, crearán un azul cielo). Ahora
pulse {Aceptar} y responda {Cancelar} a la pregunta de si desea adaptar los
mapas.

* Edite el gráfico, verá el gráfico sobre el fondo azul, con el contorno del
mismo pixelado. En el diálogo de máscaras (tecla {M}), enmascare el color
transparente (pulse sobre el primer color de la paleta, el azul). Con esto
evita modificar el exterior del gráfico.

* Ahora, para suavizar las pixelaciones, seleccione el lápiz, amplie el
dibujo (con la lupa, zoom por 8) y cuidadosamente páselo por el contorno
del gráfico con la tecla {D} (difuminar) pulsada. Se acercarán los colores
del contorno del gráfico al color del fondo. Continúe aplicando el efecto el
tiempo necesario.

* Para finalizar, quite la máscara (volviendo a pulsar sobre el color
transparente en el diálogo de máscaras), vuelva al editor de paletas,
redefina el color transparente otra vez a negro, pulse {Aceptar} y vuelva a
responder {Cancelar} a la pregunta para que no se adapten los mapas.

Se puede redefinir el color transparente siempre que se quiera ver el
contorno de los gráficos sobre un color concreto. Recuerde que siempre puede
resaltar el color transparente con la tecla {B} dentro del editor gráfico.

{/}

{Relleno con texturas}

Para rellenar un gráfico con una textura, en lugar de un color sólido se
puede utilizar la posibilidad de mover las selecciones con la tecla
{Control}, por ejemplo:

* Ponga en un mapa una textura a un lado (si no tiene ninguna puede crearla
rápidamente con la barra del spray) y, al otro lado, dibuje un círculo de
cualquier color (relleno). La textura debe ser más grande que el círculo.

* Ahora, para rellenar el círculo con la textura, utilice la barra de edición
de bloques y seleccione el círculo (con el modo de selección por relleno).

* Con la tecla {Control} pulsada, mueva la selección del círculo hasta la
textura, pulse entonces el icono de mover y desplace el bloque de nuevo hasta
el círculo.

{/}

{Pasar gráficos de un mapa a otro con TAB}

La posibilidad que ofrecen las animaciones de cambiar de mapa, dentro del
editor gráfico, pulsando la tecla {TAB}, puede utilizarse para muchas otras
acciones.

Si tiene varios mapas {del mismo tamaño}, con diversos gráficos en cada uno,
puede seleccionar un gráfico en uno de los mapas, pulsar el icono de {mover}
de la barra de edición y, entonces, utilizar la tecla {TAB} para copiar el
gráfico a otro mapa.

También se puede utilizar esto para conseguir el relleno con texturas
explicado en el punto anterior, teniendo la textura en otro mapa. Seleccione
el gráfico a rellenar en uno de los mapas, pulse {TAB} para pasar la
selección al mapa con la textura, corte en él el bloque (con el icono de
{mover}) y vuelva otra vez al mapa con el gráfico pulsando nuevamente la
misma tecla.

{En resumen}

Con todo esto, más la posibilidad de fusionar paletas, el generador de
explosiones, las  fuentes de letras y controlando el relleno con gradiente,
las operaciones de bloques, los reescalados, el editor de gamas, ..., puede
considerarse ya usted un grafista profesional, siempre que no tenga la mala
suerte de ser daltónico.

# ─────────────────────────────────────────────────────────────────────────────

{.1290,Ayuda sobre los comandos de teclado.}

Ver: {#3,Indice general}{/}

  {#1291,Comandos en el entorno gráfico}·
  {#1292,Comandos comunes en los juegos}·
  {#1293,Comandos en el trazador de programas}·
  {#1294,Comandos en el editor de programas}·
  {#1295,Comandos en el editor gráfico}·

# ─────────────────────────────────────────────────────────────────────────────

{.1291,Comandos en el entorno gráfico}
Ver: {#3,Indice} - {#1290,Ayuda sobre los comandos de teclado}{/}

{Comandos en el entorno gráfico}

{/}

{ALT+X}         - Salir del entorno gráfico al sistema operativo.·
{ESC+Control}   - Salir directamente del entorno y de los programas.·

{ALT+S}         - Ejecutar una sesión del sistema operativo MS-DOS.·

{ESC}           - Para anular o cancelar un cuadro de diálogo.·
{TAB}           - Para elegir el control seleccionado de una ventana o cuadro.·
{Enter}         - Para activar el control seleccionado.·

{F1}            - Invocar la ventana de ayuda.·

{F2}            - Guardar el programa seleccionado.·
{F4}            - Abrir un programa.·
{F10}           - Guardar y ejecutar el programa seleccionado.·
{F11}           - Compilar el programa seleccionado.·
{F12}           - Guardar y trazar el programa seleccionado.·

{Control+ALT+P} - Grabar una captura del entorno gráfico (DIV_*.PCX)·

# ─────────────────────────────────────────────────────────────────────────────

{.1292,Comandos comunes en los juegos}
Ver: {#3,Indice} - {#1290,Ayuda sobre los comandos de teclado}{/}

{Comandos comunes en los juegos}

{/}

{ALT+X}        - Salir del juego.·
{ESC+Control}  - Salir del juego.·

{Contro+ALT+P} - Grabar una captura del juego (SNAP*.PCX)·
{F12}          - Invocar al trazador de programas.·
{Pausa}        - Detener el juego momentáneamente.·

# ─────────────────────────────────────────────────────────────────────────────

{.1293,Comandos en el trazador de programas}
Ver: {#3,Indice} - {#1290,Ayuda sobre los comandos de teclado}{/}

{Comandos en el trazador de programas}

{/}

{Cursores.} - Movimiento por el listado.·
{Re.Pág.}   - Página anterior.·
{Av.Pag.}   - Siguiente página.·

{F5}        - Ver el listado de un proceso.·
{F6}        - Ejecutar el proceso actual.·
{F7}        - Ver o editar datos.·
{F8}        - Trazar sentencia.·
{F9}        - Fijar un punto de ruptura.·
{F12}       - Invocar al trazador / Avanzar imágenes.·

{F}             - Ejectuar hasta la siguiente imágen.·

{TAB}           - Seleccionar botón.·
{Enter}         - Activar botón.·
{ESC}           - Salir del trazador.·

# ─────────────────────────────────────────────────────────────────────────────

{.1294,Comandos en el editor de programas}
Ver: {#3,Indice} - {#1290,Ayuda sobre los comandos de teclado}{/}

{Comandos en el editor de programas}

{/}

{Comandos genéricos.}

{/}

{F5}        - Saltar al inicio de un proceso del programa.·
{Control+Z} - Ampliar la ventana de programa seleccionada.·

{/}

{Comandos de movimiento y edición básicos.}

{/}

{Cursores}                  - Movimiento básico del cursor.·
{Inicio}                    - Saltar al inicio de la línea.·
{Fin}                       - Saltar al final de la línea.·
{Av.Pág.}                   - Siguiente página.·
{Re.Pág.}                   - Página anterior.·
{Insertar}                  - Conmutar entre inserción y sobreescritura.·
{Suprimir}                  - Borrar el carácter del cursor.·
{Borrar}                    - Borrar el carácter anterior al cursor.·
{TAB}                       - Saltar a la siguiente tabulación.·
{Mayúsculas+TAB}            - Destabular.·
{Control+Borrar, Control+Y} - Borrar línea actual.·
{Control+Derecha}           - Siguiente palabra.·
{Control+Izquierda}         - Palabra anterior.·
{Control+Re.Pág.}           - Saltar al inicio del programa.·
{Control+Av.Pág.}           - Saltar al final delprograma.·
{Control+Inicio}            - Saltar al incio de la página.·
{Control+Fin}               - Saltar al final de la página.·

{/}

{Comandos de búsqueda y sustitución.}

{/}

{ALT+F, Control+F}     - Buscar un texto.·
{ALT+N, F3, Control+L} - Repetir búsqueda.·
{ALT+R, Control+R}     - Sustituir texto.·

{/}

{Comandos de bloques tipo QEDIT.}

{/}

{ALT+A}        - Marcar el inicio o final de un bloque permanente.·
{ALT+U}        - Desmarcar el bloque permanente.·
{ALT+C}        - Copiar el bloque a la posición actual.·
{ALT+M}        - Mover el bloque a la posición actual.·
{ALT+D, ALT+G} - Borrar el bloque.·

{/}

{Comandos de bloques tipo EDIT.}

{/}

{Mayúsculas+Movimiento}    - Marcar bloque volátil (Teclas de movimiento:
{Cursores, Control + Derecha, Control + Izquierda, Re.Pág, Av.Pág., Inicio,
Fin}).·

{Mayúsculas+Insertar} - Pegar bloque.·
{Control+Insertar}    - Copiar bloque.·
{Mayúsculas+Suprimir} - Cortar bloque.·

{Control+X}           - Cortar bloque.·
{Control+C}           - Copiar bloque.·
{Control+V}           - Pegar bloque.·

{Suprimir}            - Borrar bloque.·

# ─────────────────────────────────────────────────────────────────────────────

{.1295,Comandos en el editor gráfico}
Ver: {#3,Indice} - {#1290,Ayuda sobre los comandos de teclado}{/}

{Comandos en el editor gráfico}

{/}

{Comandos genéricos.}

{/}

{F1}                    - Invocar la ventana de ayuda.·

{ESC}                   - Salir del editor gráfico.·

{Cursores, OP/QA}       - Movimiento del cursor.·
{Barra espaciadora}     - Equivale a pulsar con botón izquierdo del ratón.·
{Mayúsculas+Movimiento} - Movimiento de 8 en 8 puntos.·
{Mayúsculas+Botón izq.} - Coger color de pantalla.·

{W, S}                  - Elegir color dentro de la gama actual.·
{Mayúsculas+W, S}       - Elegir gama actual.·
{Control+Cursores}      - Elegir color y gama.·

{Borrar}                - Deshacer.·
{Mayúsculas+Borrar}     - Repetir acción (rehacer).·

{0}                     - Seleccionar el color transparente.·
{B}                     - Resaltar el color transparente.·
{C}                     - Ventana de colores.·
{M}                     - Ventana de máscara.·
{Z}                     - Cambiar nivel de ampliación.·

{/}

{Comandos de selección de herramienta.}

{/}

{F2}             - Lápiz, para el trazo a mano alzada.·
{F3}             - Líneas rectas.·
{F4}             - Multilínea, líneas encadenadas.·
{F5}             - Curvas bézier.·
{F6}             - Multicurva, curvas encadenadas.·
{F7}             - Rectángulos y cajas.·
{F8}             - Círculos y circunferencias.·
{F9}             - Spray de pintura.·
{F10}            - Relleno de superficies.·
{F11}            - Edición de bloques.·
{F12}            - Deshacer y rehacer acciones.·
{Mayúsculas+F1}  - Escribir textos.·
{Mayúsculas+F2}  - Situar puntos de control.·
{Mayúsculas+F3}  - Barra de punteado.·

{/}

{Comandos específicos.}

{/}

{Control}  - Mover selección (barra: seleccionar bloque).·
{Control}  - Igualar ancho y alto (barras: rectángulos y círculos).·
{D}        - Difuminar (barras: lápiz, líneas, curvas y spray).·
{H}        - Esconder cursor (barra: mover bloque).·
{ +, -}    - Variar tensión (barra: multicurva).·

# ─────────────────────────────────────────────────────────────────────────────

{.1300,Preguntas comunes sobre DIV}
Ver: {#3,Indice general}{/}

{¿Como obtener ayuda sobre ... ?}

Es importante saber como está organizada la ayuda, todas las opciones accesibles
desde cualquier menú de opciones se describen en la {#1250,Ayuda sobre los menús
de opciones}. Por ejemplo se podrá obtener ayuda sobre el generador de fuentes de letras
en la ayuda sobre el menú de fuentes. La ayuda se divide en cuatro bloques
unidos por el índice general.

{#1290,Teclas} - Muestra las combinaciones de teclas accesibles para realizar
ciertas acciones en distintos puntos del programa.

{#1250,Menús} - Ayuda general sobre cada uno de los menús de opciones, y
específica sobre cada opción accesible a través de los mismos.

{#1261,Dibujo} - Ayuda y tutoriales sobre el programa de dibujo, se divide
en la ayuda genérica (conceptos básicos) y la ayuda avanzada (específica de
cada barra de herramientas).

{#1249,Lenguaje} - Toda la información sobre el lenguaje de programación y la
creación de programas. Dispone de varios nexos principales, como son el glosario
de términos y la sintaxis de los programas (su estructura general).

{¿Cómo puedo volver a la página anterior en la ayuda?}

Se puede siempre volver a la página anterior pulsando la tecla Borrar
(también llamada "BackSpace", que es la tecla para borrar que está sobre Enter).

{¿Porqué me dice "No se reconoce el tipo de fichero"?}

Es posible que esté intentando cargar un archivo con el menú incorrecto, es
decir, el menú de paletas sólo sirve para cargar paletas, el de ficheros sólo
para cargar ficheros de gráficos (grupos de gráficos), el de programas para
cargar programas o archivos de texto, etc.

También es posible que esté intentando cargar un mapa PCX o BMP True Color,
esta versión de DIV únicamente puede trabajar a 256 colores, no siendo posible
importar este tipo de archivos. Deberá convertir el gráfico que quiere cargar
en DIV a 256 colores con otra herramienta primero.

{/}

{¿Como se debe arrastrar un gráfico?}

Para arrastrar un gráfico se debe pulsar con el botón izquierdo del ratón sobre
la ventana del mapa, pero no sobre la barra de título, sino sobre el propio
gráfico contenido en la ventana. Después bastará con mover el ratón hasta la
posición en la que se desea dejar el gráfico y soltar entonces el botón izquierdo
(se pueden arrastrar mapas a ficheros, a la papelera, al tapiz de fondo, a otros
mapas o al generador de fuentes).

{¿Como extraer un gráfico contenido en otro?}

{+126,0}Se debe acceder a la barra de edición de bloques para seleccionar
la parte del gráfico que se quiere extraer. La selección se puede realizar
de varias formas, como un rectángulo, dibujando el contorno, etc.{-}

{+133,0}Una vez realizada la selección aparecerán algunos iconos nuevos
en la barra de herramientas, entre ellos el icono de {cortar a ventana}.
Al pulsar sobre este icono {se crea una nueva ventana de mapa} en el escritorio
{y se pega la zona seleccionada} en el mismo.{-}

{¿Como se cortan y copian gráficos?}

Ver también la pregunta anterior. Para cortar y mover gráficos se debe acceder
a la {#1276,barra de edición de bloques}, dentro del programa de dibujo,
seleccionando el icono que muestra unas tijeras.

Desde el escritorio se pueden realizar algunas operaciones, como copiar
un gráfico a otro, esto se puede hacer arrastrando el primer gráfico hasta
el segundo. También se puede crear una copia de un gráfico si se arrastra
el mismo hasta el tapiz de fondo (una zona del escritorio que no contenga
ninguna ventana).

{/}

{¿Porqué no escucho los sonidos en mi ordenador?}

Si, disponiendo de una tarjeta de sonido compatible con Sound Blaster
o Gravis Ultrasound, al ejecutar los juegos ejemplo no oyera los efectos
de los mismos, entonces puede probar a configurar su tarjeta de sonido
con el programa SETUP.PRG (que se encuentra en el directorio SETUP
de DIV Games Studio).

Cargue este programa con F4 y pulse F10 para ejecutarlo. Aparecerá
el programa de configuración del sistema sonido. Introduzca los
parámetros de su tarjeta y pulse sobre el botón denominado "Save&Exit".

{¿Que debo hacer si el sistema se vuelve inestable?}

DIV Games Studio es un programa muy complejo y, aunque es bastante
sólido en su ejecución, puede que el algún equipo de algún error
al realizar una acción determinada, o bien se bloquee el ordenador.

En estos casos, para volver el sistema a su estado original, debe
cargar DIV desde la línea de comandos de MSDOS indicando el
parámetro{ /SAFE} (introduciendo el comando D.EXE /SAFE desde el directorio
en el que se instaló el programa), para entrar en el "Modo a prueba
de fallos".

{/}

{¿Que debo hacer para aprender a programar?}

Los conceptos básicos no se explican en esta ayuda, sino en el manual
de usuario de DIV Games Studio, en los capítulos 5, 6, 7 y 8.

Además se puede aprender mucho de los ejemplos de las funciones del
lenguaje (ver la lista de funciones en la ayuda sobre el lenguaje)
y de los tutoriales, que son unos mini-juegos muy sencillos y
diseñados para facilitar el aprendizaje del lenguaje (estos tutoriales
se pueden encontrar en el directorio PRG\TUTOR de DIV Games Studio).

{¿Cómo se cargan los gráficos en los juegos?}

En un juego se pueden utilizar los gráficos contenidos en los mapas
(archivos MAP), cargándolos de uno en uno con la función {#174,load_map()},
o bien metiendo varios gráficos en un fichero FPG de gráficos
(ver el {#1255,menú de ficheros}) y cargándolos después con la
función {#132,load_fpg()}, esta última opción tiene la ventaja
de que se pueden cargar y descargar muchos gráficos de golpe en
el juego.

Después se suelen utilizar los gráficos para asignárselos a la variable
{#1126,LOCAL graph} de los procesos del juego.

{¿Como mostrar un nuevo gráfico en un juego?}

Para crear un nuevo gráfico o "sprite" en un juego, se debe primero
crear un nuevo proceso ({#1016,PROCESS}) con las órdenes que regirán
el comportamiento del mismo en el juego, después cada vez que se
quiera crear un proceso de dicho tipo, se deberá llamar al proceso
(ver como se hace una {#1033,llamada a un proceso}).

{¿Como eliminar un proceso?}

Para eliminar o "matar" a un proceso del juego, se puede ejecutar
una sentencia {#1028,RETURN} desde el mismo o bien, desde otro
proceso, enviarle una señal s_kill (ver la función {#158,signal()},
que es la empleada para esto).

{¿Cuales son las funciones para manejar el ratón?}

El ratón no se controla con ninguna función, sino con la estructura global
{#1100,mouse}, puede acceder a la ayuda sobre {lenguaje} / {datos globales} para
ver el resto de estructuras que controlan otros aspectos importantes de los
juegos.

{¿De donde carga todos los archivos DIV?}

Cuando en un programa se llama a una función como load_fpg( ... )
el gestor interno de DIV intenta localizar este archivo siguiendo
el siguiente esquema (supongamos que se intenta cargar el archivo
"DIR\FICHERO.EXT"):

- Primero se sitúa donde se encuentra el ejecutable (EXE) del juego,
o en el directorio principal de DIV (donde está D.EXE) en caso de
estar ejecutando el juego desde el entorno.

- Después se intenta abrir desde este directorio el archivo según
se ha especificado a la función ("DIR\FICHERO.EXT").

- En caso de no poder cargar este fichero, se intentará cargar el
fichero dentro de un directorio que tenga como nombre la extensión
del propio fichero, es decir "EXT\DIR\FICHERO.EXT".

- Si tampoco se ha encontrado este, se probará a cargar el fichero
sin indicar ninguna ruta, es decir "FICHERO.EXT".

- Y por último, si no se ha localizado el fichero en ninguno de los
anteriores directorios, se intentará buscar directamente en el
directorio cuyo nombre coincide con la extensión del fichero, obviando
la ruta de acceso que se le pasó a la función, es decir "EXT\FICHERO.EXT".

# ─────────────────────────────────────────────────────────────────────────────

{.2047,Ultimo término posible dentro de este hipertexto}