PROGRAMACIN CON KPL

Programar es darle instrucciones a un computador y los computadores son muy buenos para seguirlas,
hacen exactamente lo que se les diga, pero no tienen imaginacin. Programar un computador nos obliga a
pensar de una manera muy lgica, ordenada y precisa, es necesario aprender a hacerlo para poder
programar. Todos los lenguajes de programacin tienen reglas a seguir para que el computador pueda
entender las instrucciones, los lenguajes humanos tambin tienen reglas para el mismo propsito;
nosotros las usamos para comunicarnos sin pensar mucho en ellas.
Cuando damos instrucciones a una persona, primero le damos un nombre a la tarea general que va a
realizar y luego le damos las instrucciones que debe ejecutar para llevar a cabo la tarea. En un programa
KPL hacemos lo mismo, nombramos el programa con Program NombrePrograma y lo terminamos con
End Program. Entre estas dos lneas agrupamos todas las instrucciones en algo que llamamos la tarea o
mtodo principal. Todo programa KPL tiene un mtodo llamado Main( ), que contiene las instrucciones
de la tarea principal del programa y termina con End Method. Esta es la estructura bsica de un
programa en KPL:

La diferencia entre dar instrucciones a una persona y dar instrucciones a un computador est en la
complejidad de cada instruccin, en el orden de las instrucciones y en el lenguaje utilizado. El
computador no puede suponer ni imaginar nada, las instrucciones que le damos son ms elementales,
precisas, en un estricto orden y sometidas a reglas de un lenguaje ms restrictivo que los lenguajes
utilizados por los humanos para comunicarse. No estamos acostumbrados a dar instrucciones en forma tan
lgica, precisa, ordenada y con un lenguaje tan restrictivo; debemos aprender a hacerlo para poder
programar.
El nombre del programa debe indicar lo que hace, aunque puede ser cualquier nombre, debe estar
compuesto por una sola palabra con letras o nmeros y debe empezar con una letra. Cada lnea del
programa tiene un nmero, la lnea 1 y 8 marcan el principio y el fin del programa y las lneas 2 y 7
indican el inicio y fin de la tarea principal del programa.. El mtodo Main es la forma de indicar donde
empieza y termina la tarea principal del programa y el computador ejecutar instruccin por instruccin
en el estricto orden en que aparecen en el mtodo Main( ). Para correr la aplicacin KPL haga doble clic
sobre el siguiente icono que se encuentra en el escritorio, y aparece la pantalla principal de KPL.

Si la pantalla que le aparece no es igual, oprima el primer icono de la barra de herramientas

para
crear un nuevo documento. Se muestra un programa nuevo llamado Untitled1.kpl en el panel del editor de
cdigo. Las lneas que empiezan con // no son instrucciones sino comentarios que dan informacin al
lector sobre el programa y le ayudan a entender qu hace. La barra de herramientas es muy parecida a la
barra de herramientas de los editores de texto y de muchas otras aplicaciones actuales. Coloque el mouse
sobre cualquiera de los conos de la barra de herramientas y ver un pequeo mensaje explicativo de la
funcin del icono.
Seleccione y elimine las lneas de comentario y las lneas en blanco y escriba el siguiente programa:

Recuerde que las instrucciones tienen que ser muy precisas, si se equivoca en algn carcter el
computador no entender la instruccin. No es necesaria la sangra en las lneas pero da claridad al lector
del programa no al computador. Por claridad del lector, tambin puede aadir lneas en blanco y eso no
afectar el programa, lo que si necesita el computador es que cada instruccin se encuentre en una lnea
separada.
Para correr su programa haga clic sobre el icono
debera ver la siguiente ventana:

o presione F5, si escribi bien las instrucciones

Si tienen algn error en las instrucciones aparece la ventana de mensajes de error indicando la lnea en la
cual ocurri el error y el tipo de error. En este caso se escribi PrentLine en la lnea 5, en lugar de
PrintLine. Se debe corregir el error y volver a ejecutar el programa; recuerde que el computador no es
capaz de suponer, imaginar ni asumir nada. Es comn tener errores en nuestros programas, no debemos
sentirnos mal por eso, slo es cuestin de revisar con paciencia cada instruccin errada y corregirla. :

Para guardar su programa oprima el icono

digite Saludo y oprima Guardar:

y aparece la ventana solicitando el nombre del archivo,

Despus de guardar su programa, el nombre de su archivo aparece en dos lugares diferentes como se
muestra en el grfico; en el editor de cdigo y en el explorador de archivos que est a la derecha de la
pantalla principal. Ahora puede cerrar su programa haciendo clic sobre la x que se encuentra en la parte
superior del editor de cdigo, no sobre la x de la ventana principal.

Con el archivo en el disco, puede reabrirlo haciendo doble clic sobre su nombre en el explorador de
archivos y aparece en el editor. Para ver las instrucciones en el mtodo Main haga clic sobre el signo +
que se encuentra a la izquierda de dicho mtodo. Para contraer de nuevo el mtodo Main haga clic en el
signo que se encuentra a su izquierda. Esta caracterstica de contraer y expandir un mtodo es muy
importante con programas que tienen muchas instrucciones.

MANEJO DEL LPIZ

El sistema de coordenadas que maneja el computador en su pantalla grfica, es diferente al sistema de
coordenadas que manejamos en los cursos de lgebra. El origen (X = 0, Y = 0) de la pantalla no est en el
centro sino en la esquina superior izquierda.

El primer valor de cada pareja de nmeros en el grfico es la coordenada X la cual crece de izquierda a
derecha y el segundo valor corresponde a la coordenada Y la cual crece de arriba hacia abajo.
KPL es un lenguaje de propsito general que sirve para hacer programas que involucran manejo de texto,
grficos, clculos matemticos, etc. Vamos a crear nuestro primer programa para el manejo de grficos.
UTILIZANDO EL SISTEMA DE COORDENADAS GRFICAS PARA GENERAR IMGENES
En KPL el manejo del lpiz y del papel es muy similar a la realidad, solamente que todo el control no se
realiza con las manos sino mediante instrucciones. Pero por donde empezar? En KPL todos los
programas empiezan y terminan de la misma forma, por eso iniciamos escribiendo el siguiente trozo de
cdigo, solo que esta vez el nombre de nuestro programa ser DibujoALapiz.

Ahora agregamos dos instrucciones que aunque no sirven para que el programa dibuje en la pantalla
permiten manipular la forma como se dibuja.

La instruccin Color(Brown) le dice a KPL que dibuje utilizando el color Caf (Brown en ingls); y la
instruccin PenWidth(4) indica que al dibujar con la pluma (Pen), KPL dibuje una lnea de 4 pxeles de
ancho. Puede escribir las instrucciones Color y PenWidth utilizando la combinacin de teclas crtl-j y
escogiendo la instruccin de la lista que aparece en la ventana. O puede escribir la primera letra y luego
ctrl-j para que en la ventana solo aparezca la lista con las instrucciones que empiezan con esa letra.

Para poder dibujar en la pantalla se utiliza la instruccin MoveTo(posicinX, posicinY); esta le indica a
KPL que dibuje una lnea desde la posicin en donde se encuentra actualmente el lpiz hasta la posicin
en pantalla indicada por los parmetros (posicinX, posicinY). Inicialmente el lpiz est en la posicin
(0,0), esquina superior izquierda.

Ejercicios:

1. Pinte un cuadrado con vrtice superior izquierdo en el punto (200, 200) y de lado 100.
2. Pinte el mismo cuadrado anterior pero relleno, use la instruccin Rectangle(100, 100, True).
3.
4.

Tambin puede pintar Ellipse(200, 200, True), o Circle(300, 300, True).0000000

Pintar un tringulo con vrtices en (200, 300) (300, 300) (250, 200).
Dibujar la siguientes figuras:

Supongamos que la casa que queremos dibujar tiene su vrtice inferior izquierdo en X = 200, Y
= 300, las paredes tienen 100 pxeles de altura, y el techo se eleva hasta 50 pxeles sobre las
paredes. Qu haramos para dibujar la siguiente casa con un solo trazo sin levantar el lpiz del
papel y sin sobrescribir trazos?

Nota: Si por casualidad su casita se ve como la de la figura no se asuste, KPL

ya
pens como solucionar ese problema.

Para resolver el problema agregamos la instruccin Pen(False) antes de mover el lpiz a la

posicin X = 200, Y = 300. De esta forma cuando el lpiz se mueve de la posicin (0, 0) a la
(200, 300) ya no aparece una lnea conectando ambos puntos. KPL comenzar a dibujar
nuevamente a medida que movamos el lpiz despus de utilizar la instruccin Pen(True).
5.

Dibuje un cubo.

MANEJO DE GRFICOS
MOSTRAR EL OVNI
En el explorador de archivos de la pantalla principal de KPL aparece una carpeta con el nombre Pictures
en la que se encuentra el archivo OVNI.gif. Seleccionelo y haga clic derecho con el mouse, luego haga
clic sobre la palabra view para ver las seis imgenes de este gif. Revise algunos archivos ms como
Space.png, Ship1Top.gif y Ship3.png. A partir de estas imgenes construiremos los sprites de los
programas del taller. Un Sprite es una imagen o animacin en dos dimensiones integrada en una escena de
un videojuego. KPL tiene comandos para cargar y manipular sprites a partir de archivos con imgenes.

Cree un nuevo programa oprimiendo el icono

y elimine las lneas de comentarios y las lneas en
blanco, llmelo Ovni y digite las instrucciones del mtodo Main para mostrar el Sprite Ovni.

El programa Ovni tiene las siguientes instrucciones de manejo de imgenes. La lnea 3 le dice al
computador que cargue la imagen que se encuentra en el archivo OVNI.gif y la llame OVNI dentro del
programa, la lnea 4 mueve la imagen llamada OVNI al punto de la pantalla de coordenadas X = 50, Y =
50, y la lnea 5 muestra en la pantalla la imagen llamada OVNI.
KPL tiene reglas precisas para estas instrucciones, la primera instruccin LoadSprite requiere dos valores
para que funcione. El primer valor debe ser el nombre con el cual nos referimos a la imagen en el
programa, y el segundo valor debe ser el nombre del archivo que contiene la imagen. Estos valores deben
estar entre comillas dobles separados por coma, debemos respetar estas reglas para que el computador
entienda las instrucciones.
Despus de cargar la imagen la colocamos en una posicin en la pantalla con la instruccin
MoveSpriteToPoint(OVNI, 50, 50) que requiere tres valores. El primer valor es el nombre del sprite
que al cargar la imagen lo llamamos OVNI, el segundo la localizacin en el eje X para el sprite, que
queremos que sea 50, y el tercero la localizacin en el eje Y, la cual queremos que sea 50. Observe que los
valores numricos no van entre comillas dobles, mientras que las palabras deben ir entre comillas dobles.
Guarde el programa Ovni en un archivo llamado Ovni.
Podemos colocar varios ovnis en diferentes sitios de la pantalla usando el mismo archivo en el que se
encuentra la imagen (OVNI.gif), pero debemos usar distintos nombres para los sprites. Coloque 4 ovnis
en las esquinas de un cuadrado de lado 100 y esquina superior izquierda en X = 100, Y = 100.

MOVER EL OVNI
Ahora que sabemos como mostrar el Ovni nos gustara moverlo de un sitio a otro de la pantalla; por
ejemplo desde la posicin X = 50, Y = 50, hasta la posicin X = 450, Y = 50. Para que el ovni empiece a
moverse hacia la derecha por la pantalla debemos mantener fija la posicin Y e incrementar en una cierta
cantidad la posicin X, y repetir este proceso muchas veces. KPL tiene la instruccin
MoveSpriteByAmount(NombreSprite, incX, incY)
para mover el sprite desde la posicin (X, Y) donde se encuentra, hasta la posicin (X + incX, Y + incY).
Observe que la instruccin
MoveSpriteToPoint(NombreSprite, X, Y)
mueve el esprite a la posicin X, Y independientemente de donde se encuentre; mientras que
MoveSpriteByAmount(NombreSprite, incX, incY)
incrementa las coordenadas actuales del sprite; la posicin X la incrementa en incX, y la posicin Y en
incY.
Para mover el Ovni a la derecha, empezamos en la posicin (50, 50), lo desplazamos a la posicin (51,
50), luego a la (52, 50), etc. y repetimos esto 400 veces para llevarlo a la posicin (450, 50). Tendramos
que escribir un programa con 400 instrucciones para mover el sprite pxel a pxel a la derecha:

MoveSpriteToPoint(OVNI, 50, 50)

MoveSpriteToPoint(OVNI, 51, 50)
MoveSpriteToPoint(OVNI, 52, 50)
..
MoveSpriteToPoint(OVNI, 450, 50)
O tambin

MoveSpriteToPoint(OVNI, 50, 50)

MoveSpriteByAmount(OVNI, 1, 0)
MoveSpriteByAmount(OVNI, 1, 0)
MoveSpriteByAmount(OVNI, 1, 0)

MoveSpriteByAmount(OVNI, 1, 0)
Afortunadamente existe un mecanismo que nos permite repetir un conjunto de instrucciones el nmero de
veces que queramos, como muestra el siguiente programa:

Seleccione todas las lneas de este programa, haga clic derecho con el mouse y seleccione copiar, pegue
este programa en el editor de KPL, encima del programa anterior reemplazndolo completamente. La
tarea principal o mtodo Main( ) primero ejecuta la subtarea cargar el ovni en la posicin (50, 50) y lo
muestra. Estas subtareas se pueden construir como otros mtodos invocados desde el Main( ), de esta
manera el programa es ms claro y modular. La primera instruccin en ejecutarse es la invocacin
cargarOvni( ), lo cual transfiere el control a la lnea 3, se ejecutan las lneas 4 y 5 y el control se transfiere
a la lnea 9.
Las instrucciones que se encuentran entre la lnea 9 y la lnea 12 se repiten el nmero de veces que
aparece despus de la palabra Loop. La lnea 9 le dice al computador que debe repetir las lneas 10 y 11,
400 veces. Al llegar a la lnea 10 la primera vez, mueve el ovni 1 pxel hacia la derecha y 0 pxel hacia
abajo desde la posicin (50, 50), el ovni queda en la posicin (51, 50); luego detiene el programa 1000
milisegundos, que equivale a un segundo. Regresa a la lnea 10 y mueve el ovni 1 pxel a la derecha y 0
pxel hacia abajo desde la posicin (51, 50) y el ovni queda en la posicin (52, 50); luego detiene el
programa 1 segundo, etc. Repite esto cuatrocientas veces.
Los computadores son muy rpidos y tienen la capacidad de mover el ovni 400 veces en menos de una
dcima de segundo. Si no colocamos la instruccin Delay(1000), al correr el programa solo vemos el ovni
en la posicin final, por la rapidez con la que el computador mueve el ovni. Para ver un movimiento
suave del ovni, debemos decirle al computador que mueva el ovni un pxel hacia la derecha y se detenga,
lo mueva otro pxel hacia la derecha y se detenga, etc. Si detenemos 1 segundo (Delay(1000)) la
ejecucin del programa cada vez que desplazamos el ovni un pxel, veremos una imagen del ovni cada
segundo y eso no produce sensacin de continuidad o animacin. Recuerde que se necesitan de 14 a 25
imgenes por segundo para obtener el efecto de animacin (ver el apndice B).
Si cambia la instruccin Delay(1000) por Delay(40) el computador repite 400 veces las instrucciones
mover el ovni un pxel hacia la derecha y detenerse 40 milisegundos, es decir que muestra 25 (1000/40)
imgenes por segundo logrando el efecto de animacin. De esta manera, la secuencia de desplazamientos
y detenciones simulan un movimiento continuo a nuestros ojos.

Ejercicios:
1. Mueva el ovni desde la posicin (0, 0) hasta la posicin (400, 400) en lnea recta y cambie el valor del
Delay a 0.05 milisegundos.
2. Mueva dos ovnis al mismo tiempo sobre un cuadrado de lado 300 y esquina superior izquierda en X =
50, Y = 50. Un ovni se mueve en el sentido de las manecillas del reloj, y el otro en sentido contrario.
ROTAR EL OVNI

Este programa agrega la instruccin

RotateSpriteBy(OVNI, 1)
para incrementar la rotacin del ovni un grado con respecto a su rotacin actual. Esta instruccin es
diferente a la instruccin
RotateSprite(OVNI, 1)
la cual rota el sprite un grado respecto al eje X. Este programa tiene tres instrucciones que se repiten 400
veces, las lneas 10, 11 y 12; ahora no slo movemos el ovni un pxel en X sino que incrementamos su
rotacin en un grado en cada una de las repeticiones.

ALGUNAS COSAS CONCEPTUALES

IDENTIFICADORES
Un identificador es una secuencia descriptiva de letras maysculas o minsculas, nmeros y el carcter de
subrayado. Los identificadores se utilizan para darle nombre al programa, a las variables, a los sprite, a las
estructuras, a los mtodos y a las funciones. Debe empezar con una letra o el smbolo de subrayado y no
puede ser una palabra clave del lenguaje.
Identificadores vlidos:
Hugo
Yo
_PosicionX
PosicinYBola_2
esto_es_correcto
Identificadores invlidos:
2Caminos
Bola-Posicion.X

empieza con un nmero

contiene caracteres invlidos

Las palabras claves y los identificadores no son sensibles a las maysculas, las siguientes instrucciones
son equivalentes:

Define
Define

nombre
NOMBRE

AS
as

STRING
string

=
=

Pedro
Maria

LITERALES
Son valores constantes en un programa: 100, 2.5, Buenos das. El primero especifica un entero, el
segundo un valor decimal y el tercero una cadena de caracteres. Se puede usar un literal en cualquier parte
en la que un valor de este tipo est permitido.
COMENTARIOS
Un comentario puede ser una lnea o un bloque de notas, que es parte del cdigo de un programa pero que
es ignorado a la hora de correrlo. Estas notas son utilizadas ms comnmente para escribir datos
importantes acerca del funcionamiento del programa, permitiendo que el cdigo sea ms entendible para
las personas que no han tenido nada que ver con la elaboracin del mismo; o para que te acuerdes como
es que tu programa funciona si por casualidad sufres de amnesia.
LINEAS DE COMENTARIOS
Su sintaxis es muy simple, pues solo toca colocar dos barras inclinadas (//) y todo lo que siga de ah en
adelante en esa lnea KPL lo toma como un comentario.

BLOQUES DE COMENTARIOS
Comienzan por /* y terminan con */, y todo lo que se escriba adentro es tratado como un comentario. Este
tipo de comentarios resultan tiles cuando se desean escribir notas muchos ms largas y elaboradas que
ocupen ms de una lnea.
PALABRAS RESERVADAS
Las siguientes palabras son parte del lenguaje mismo y no se pueden usar como identificadores:

AND
AS
EACH
END
EXIT
FALSE
FOR
FUNCTION
GOTO
WHILE
METHOD
MOD

NOT
OR
PROGRAM
STEP
STRUCTURE
TRUE
TIPOS DE DATOS
KPL tiene unas categoras que clasifican a los literales o valores en diferentes clases llamadas tipos de
datos. Estos literales se clasifican en nmeros, cadenas de caracteres y lgicos. Adems, los nmeros se
clasifican en enteros y nmeros con parte decimal. Cada una de estas categoras define un rango de
valores y un conjunto de operadores que pueden actuar sobre ellos. KPL tiene los siguientes tipos de datos
simples:
INT: Nmero entero entre -2.147.483.648 y 2.147.483.647, inclusive. Ejemplos: 1, 5, -323, 12345678.
DECIMAL: nmeros con parte decimal.
STRING: Cadena de caracteres entre comillas dobles. Ejemplos: Hugo, Paco, Luis.
BOOL: Slo existen dos valores booleanos, TRUE o FALSE.
VARIABLE
En casi todos los programas necesitamos tener un lugar donde guardar un valor que puede ser un n mero
entero, o un nmero decimal, o una cadena de caracteres, o un valor booleano; es como tener una casilla
en la que guardamos un dato. El valor guardado en la casilla lo podemos cambiar a medida que el
programa avanza, por eso a la casilla la llamamos variable. Una variable nos sirve para guardar una
unidad bsica de informacin representada por un nmero entero, decimal, cadena o booleano. Toda
variable debe tener un nombre (identificador), un tipo y un valor y se define en el programa de la
siguiente manera:.
Define <Identificador> AS <Tipo de dato> [ = <Expresion> ]
La declaracin de una variable empieza con la palabra clave Define, seguida por un identificador vlido,
la palabra clave AS, el tipo de dato de la variable, y opcionalmente un valor inicial. El valor inicial puede
ser un valor literal como Maria o 10, o una variable u otra expresin cuyo resultado es del tipo de dato.
Las variables globales se definen en la parte superior del programa (despus de las estructuras) para que
puedan ser utilizadas por todos los mtodos, y las variables locales se definen en el cuerpo de un mtodo
para estar disponibles solo para ese mtodo. No se puede declarar una variable dentro de un ciclo o un
ifThenElse. Toda variable se debe declarar antes de ser utilizada.
OPERADORES
Los operadores nos permiten manipular las variables y los valores para obtener nuevos valores que
guardamos en variables o mostramos por la pantalla. KPL tiene operadores aritmticos, operadores
relacionales y operadores lgicos. Los operadores aritmticos actan sobre variables y valores de tipo
entero.

+
*
/

suma
Resta o menos unario
Multiplicacin
Divisin real o entera

Mod
=

Retorna el resto de la divisin

Asignacin

Los operadores relacionales sirven para comparar variables o valores numricos y cadenas, su resultado
siempre es un valor Bool.

=
<>
>
<
>=
<=

Igual a
Diferente de
Mayor que
Menor que
Mayor o igual que
Menor o igual que

Los operadores lgicos nos permiten construir expresiones lgicas compuestas y solo operan sobre
operndos de tipo Bool. Todos los operadores lgicos binarios combinan dos valores Booleanos para dar
como resultado un valor Booleano.

AND
OR
NOT unario

y
o
negacin

PRECEDENCIA DE OPERADORES

ARREGLOS
Un arreglo es una coleccin de variables del mismo tipo, definido por la palabra reservada Define,
seguido por un identificador valido nombre del arreglo, la palabra reservada As, luego se especifica el
tipo de dato que el arreglo va a contener se pueden usar tanto tipos de datos sencillos como Estructuras,
y por ltimo entre llaves ([ ]) especifican el tamao del arreglo.

Veamos mejor el funcionamiento de un arreglo mediante un ejemplo grfico:

Como se puede ver en la figura anterior un arreglo es como si fuesen un conjunto de cajas, colocadas una
detrs de la otra, dentro de las cuales se pueden meter datos. Pero existen ciertas restricciones con
respecto a los datos que cada caja puede contener en su interior:
1.

Los datos dentro de todas las cajas consecutivas tienen que ser del mismo tipo, es decir, si se decide
que el arreglo es de manzanas solamente se podrn meter manzanas en las cajas.
2. Si el arreglo es de manzanas solo podr meter una sola manzana en cada caja

Para poder meter y extraer datos en el arreglo se especifica el nombre del arreglo y entre llaves ( [] ) se
indica mediante un ndice la posicin dentro del cual quiero meter el dato deseado.
nombreDelArreglo [ 1 ] = 50 // Coloca 50 en la primera posicin
nombreDelArreglo [ 3 ] = 20 // Coloca 20 en la ltima posicin
variableA = nombreDelArreglo [ 3 ] // Coloca en la variable A el valor de la
// ltima posicin del arreglo
Los ndices para apuntar a las posiciones del arreglo tambin pueden ser variables de tipo entero, como se
muestra en el siguiente ejemplo:
Define Indice As Int
For Indice = 1 To 3
Print( "Datos: " + nombreDelArreglo[ Indice ] )
Next
Nota: KPL siempre inicializa cada posicin del arreglo con el valor por defecto del tipo de dato que
contiene, cada vez que se crea un nuevo arreglo. Luego el programador puede alterar esos valores como
se explic anteriormente.
Un Arreglo es como un casillero con varias casillas en las que podemos guardar valores del mismo tipo al
mismo tiempo. El arreglo se identifica mediante un nombre y cada posicin del casillero se identifica con
un ndice que va desde cero hasta el tamao del arreglo menos 1. Declaramos un arreglo de la siguiente
manera:
Define <Identificador> AS <Tipo> [ <Expresin> ]
Ejemplo:
Define Valores AS INT[3]
Valores[0] = 10
Valores[1] = 20
Valores[2] = 30
Print(Valores en la posicin 0 es: + Valores[0] )
INSTRUCCIN DE SELECCIN

KPL soporta estructuras de decision que permiten ejecutar instrucciones basado en una condicin usando
la estructura If / Then / Else / End If:
IF <Expresin booleana> THEN
Instrucciones

END IF
O
IF <Expresin booleana> THEN
Instrucciones

ELSE
Instrucciones

END IF
INSTRUCIONES DE REPETICIN
KPL soporta dos tipos de instrucciones de repeticin:

For
El FOR se ejecuta un nmero especfico de veces desde <valor inicial> hasta <valor final>, y tiene la
siguiente estructura:
FOR <Variable> = <valor inicial> TO <valor final> [ <Step> <Valor> ]
<Instrucciones>
NEXT

While
El WHILE evala la <Expresin booleana> y se ejecutan las instrucciones si sta es TRUE.
WHILE <Expresin booleana>
<Instrucciones>
END WHILE

EL OVNI TAMBALEA
Program Ovni
Method cargarOvni()
LoadSprite("OVNI", "OVNI.gif")

MoveSpriteToPoint("OVNI", 50, 50)

ShowSprite("OVNI")
End Method
Method Main()
Define ngulo As Int = 5
cargarOvni()
Loop 400
MoveSpriteBy("OVNI", 1, 0)
RotateSpriteBy("OVNI", ngulo)
ngulo = ngulo * -1
Delay(40)
End Loop
End Method
End Program
La instruccin Define ngulo As Int = 5, permite definir una variable llamada ngulo en la que podemos
guardar un valor entero, por eso el As Int, y en ella guardamos el valor 5. Si queremos cambiar el 5 por
otro valor entero como el 11, simplemente damos la instruccin ngulo = 11. O si queremos cambiar el 5
por -5, multiplicamos el 5 por -1 y el resultado lo guardamos en la casilla ngulo, como en la lnea 13. En
esta variable no podemos guardar un valor decimal, ni una cadena; solo podemos guardar valores enteros.
Como el programa anterior, este programa mueve y rota el Ovni 400 veces, pero en el primer ciclo del
loop lo rota 5 grados y le asigna a ngulo el valor -5, en el segundo ciclo lo rota -5 grados y le asigna a
ngulo el valor 5, en el tercer ciclo lo rota 5 grados y asigna a ngulo el valor -5, etc,. Esto hace que el
Ovni se tambalee. Cambie el valor inicial del ngulo y observe lo que sucede al correr el programa.

Ejercicios:
1.
2.
3.

Mueva el ovni y el lapiz en un crculo con centro en X = 100, Y = 100.

Mueva el ovni y el lapiz en dos crculos tangentes.
Mueva el ovni y el lapiz de tal manera que dibujen el smbolo de los juegos olimpicos.

ACTIVAR EL GIF ANIMADO: EL OVNI GIRA SOBRE SI MISMO

Tambin podemos definir una variable que permita guardar varios valores de un determinado tipo al
mismo tiempo, es como un casillero en el que cada casilla guarda un valor en un instante dado.
Program Ovni
Method cargarOvni()
LoadSprite("OVNI", "OVNI.gif")

MoveSpriteToPoint("OVNI", 50, 50)

ShowSprite("OVNI")
End Method
Method Main()
cargarOvni()
Define TiempoImagen As Int[6] = {40, 40, 40, 40, 40, 40}
SetSpriteAnimationTimeline("OVNI", True, TiempoImagen)
Loop 400
MoveSpriteBy("OVNI", 1, 0)
Delay(10)
End Loop
End Method
End Program
En este programa la instruccin Define TiempoImagen As Int[6] = {40, 40, 40, 40, 40, 40} define la
variable llamada TiempoImagen que almacena seis valores enteros, uno en cada una de sus casillas. Para
asignar un valor diferente a 40 en alguna de las posiciones del casillero, por ejemplo asignar 100 en la
primera posicin, damos la instruccin TiempoImagen[1] = 100.
Recuerde que el archivo OVNI.gif tiene seis imgenes, cada una con el ovni en una posicin diferente. Si
pasamos estas seis imgenes en secuencia a la velocidad apropiada, tendremos animacin del ovni
girando. El mtodo SetSpriteAnimationTimeline("OVNI", True, LineaTiempo)hace girar al ovni, pasando
la secuencia de las seis imgenes y mostrando cada imgen el tiempo en milisegundos dado en la variable
LineaTiempo. El primer valor de esta variable define la cantidad de tiempo en milisegundos que se
muestra la primera imagen, el segundo valor define la cantidad de tiempo en milisegundos que muestra la
segunda imagen, etc. En este caso definimos 40 milisegundos para cada una de las imgenes, lo que
quiere decir que muestra las 6 imgenes en 240 milisegundos. La palabra True le dice al computador que
repita todo el tiempo esta animacin mientras dura la ejecucin del programa. Si colocamos False en
lugar de True, el computador ejecuta la animacin de giro solo una vez. Este programa nos muestra dos
animaciones, una en el movimiento rectilneo y otra en el giro del ovni alrededor de un eje vertical que
pasa por su centro.

MOVER EL OVNI CON LAS TECLAS DE FLECHA

Program Ovni
Define posX As Int = 50
Define posY As Int = 50
Define incX As Int = 1
Define incY As Int = 1

Method cargarOvni()
LoadSprite("OVNI", "OVNI.gif")
MoveSpriteToPoint("OVNI", posX, posY)
Define TiempoImagen As Int[6] = {40, 40, 40, 40, 40, 40}
SetSpriteAnimationTimeline("OVNI", True, TiempoImagen)
ShowSprite("OVNI")
End Method
Method tecla()
If IsKeyDown("UP") And posY > 0Then
posY = posY - incY
End If
If IsKeyDown("Down") And posy < ScreenHeight() - GetSpriteHeight("OVNI") Then
posY = posY + incY
End If
If IsKeyDown("Right") And posX < ScreenWidth() - GetSpriteWidth("OVNI") Then
posX = posX + incX
End If
If IsKeyDown("Left") And posX > 0 Then
posX = posX - incX
End If
MoveSpriteToPoint("OVNI", posX, posY)
End Method
Method Main()
cargarOvni()
Loop 10000
tecla()
Delay(10)
End Loop

End Method
End Program
Las variables definidas al comienzo del programa pueden ser utilizadas por cualquiera de los mtodos,
por eso se llaman variables globales; por el contrario, las variables definidas dentro de un mtodo son
llamadas variables locales, pues solo se pueden utilizar dentro del mtodo. Este programa define cuatro
variables globales que pueden ser utilizadas por cualquiera de los mtodos del programa.
El programa permite mover el ovni con las teclas de fecha sin salirse de la pantalla utilizando la
instruccin condicional If. El mtodo tecla( ) valida si la tecla oprimida es flecha hacia arriba y si la
posicin en Y es mayor que cero, si estas dos condiciones se cumplen disminuye la posicin en Y en el
valor que tenga la variable incY. Luego valida si la tecla que se oprimi es flecha hacia abajo y si la
posicin en Y es menor que el alto de la pantalla menos el alto del ovni, si estas dos condiciones se
cumplen incrementa la posicin en Y en el valor que tenga la variable incY. Luego valida si la tecla
oprimida es flecha derecha y la posicin en X es menor que el ancho de la pantalla menos el ancho del
ovni, si estas dos condiciones se cumplen incrementa la posicin en X en el valor que tenga la variable
incX. Luego valida si tecla oprimida es flecha izquierda y la posicin en X es mayor que cero, si las dos
condiciones se cumplen disminuye la posicin X en el valor que tenga la variable incX. Por ltimo,
mueve el ovni a la posicin actualizada.
El mtodo Main( ) invoca el mtodo cargarOvni( ) y luego entra en un ciclo repetitivo con dos
instrucciones: invocar el mtodo tecla( ) que valida la tecla digitada y detener el programa 10
milisegundos. El computador tarda alrededor de 3 minutos en ejecutar estas dos instrucciones 10000
veces, esto permite mover el ovni durante este lapso de tiempo. Puede cambiar los valores de incX, incY,
el nmero de repeticiones y la cantidad de milisegundos que el computador se detiene en cada repeticin.
Cambie un parmetro a la vez, ejecute el programa y observe el cambio.

ESTRUCTURAS (STRUCTURES)
Una estructura en KPL permite agrupar varias variables para poder tratarlas como una nica entidad
lgica. A estas variables las llamaremos Variables Internas de la Estructura; las cuales no requieren del
uso de la palabra reservada Define, y no pueden ser inicializadas como se puede hacer con las variables
normales. Este es un ejemplo de cmo definir una estructura:

Despus de definir una estructura, para emplearla en un programa es necesario definir una variable que la
contenga, en la cual se establece como tipo de dato el nombre de la estructura creada:
Define Ovni As Imagen
Para acceder a las variables de la estructura se escribe el nombre de la variable que la contiene, seguido
de un punto y el nombre de la variable interna:

Ovni.x = 50
Ovni.y = 50
Ovni.incX = Ovni.incY

Ejercicios:

Crear una estructura llamada Cometa, que permita guardar su color, punto de elevacin, peso, ancho
y alto.

Darle valores a las variables internas de la Cometa.

FUNCIONES Y MTODOS
Si se han preguntado como hago para escribir un programa sin tener que estar constantemente repitiendo
la misma secuencia de instrucciones una y otra vez, los mtodos y las funciones son una solucin a esta
inquietud. Estas permiten crear porciones de cdigo que realizan funciones especializadas, las cuales
pueden ser llamadas desde cualquier parte del programa.
MTODOS
Un mtodo es definido por la palabra reservada Method, seguido por un identificador valido el cual se
usar para darle un nombre que indique de manera general lo que realiza el mtodo, una lista de
parmetros entre parntesis, una porcin de cdigo, y finaliza con End Method.

Como se aprecia en la figura, los mtodos pueden ir ubicados en cualquier parte del programa mientras no
se salgan de las etiquetas Program Programa y End Program casos 1 y 2 y mientras no sean definidos
dentro de otro mtodo caso 3. Los siguientes son unos ejemplos que muestran donde no definir los
mtodos dentro de un programa:

Los mtodos pueden tener o no tener parmetros, todo depende de que informacin necesite el mtodo
para poder realizar su tarea.
Un mtodo sin parmetros se vera as:
Method MetodoTres()
// Porcin de Cdigo
End Method
Pero cuando un mtodo requiere parmetros se tiene que seguir la siguiente sintaxis: el nombre que se le
da al parmetro para poder utilizarlo dentro del mtodo, seguido de la palabra reservada As y del tipo de
dato o estructura del parmetro. Para declarer varios parmetros debemos separarlos con comas.

Ejercicios:

Escribir un mtodo que cada vez que se llame escriba una lnea verde en la pantalla desde una
posicin (X1, Y1) hasta una posicin (X2, Y2) las cuales se pasan como parmetros.

Escribir un mtodo que posicione un sprite, el que usted quiera, en todo el centro de la pantalla.
Nota: Este mtodo no recibe parmetros.

FUNCIONES
Una funcin es similar a un mtodo, con la excepcin que puede retornar un solo valor a quien lo llama.
Una funcin se define con la palabra reservada Function, seguida por un identificador valido, una lista de
parmetros entre parntesis, un tipo de retorno, una porcin de cdigo, y finaliza con End Function. Algo
para tener muy en cuenta es que toda funcin debe contener una instruccin de retorno que devuelva un
valor a quien la llame. La lista de parmetros y la definicin de las funciones en el programa siguen las
mismas reglas que en los mtodos.

El tipo de retorno se especifica despus del parntesis donde se incluyen los parmetros con la palabra
reservada As seguido por el tipo de dato o estructura que se requiere retornar. La instruccin de retorno
siempre se declara con la palabra reservada Return seguido por lo que se desea retornar. Hay que tener en
cuenta que el tipo de dato de retorno y lo que se esta retornando despus de Return sean del mismo tipo
para no generar errores.

Ejercicios:

Escribir una funcin que calcule el rea de un triangulo, que reciba como parmetros su base y su
altura.

Escribir una funcin que retorne el nmero de das que tiene el nmero del mes que ha sido pasado
como parmetro.

LLAMADO A MTODOS Y FUNCIONES

El llamado a los mtodos y funciones requiere escribir el nombre del mtodo o de la funcin tal como fue
definida, y luego colocar parntesis -()- alrededor de los valores que van a ser pasados como parmetros,
estos deben de ser colocados en el mismo orden como se hizo en la definicin del mtodo o funcin.
Ejemplos:

Funcion (2, 3) llama al mtodo nombrado Funcin, con el valor de 2 para el parmetro a y
con el valor de 3 para el parmetro b.

MetodoTres () como este mtodo no tiene ningn parmetro, se utiliza un parntesis que abre
seguido de un parntesis que cierra para indicar que no se le van a pasar parmetros al mtodo.

En el caso de las funciones para poder obtener el valor que retorna se debe colocar una variable que
reciba dicho valor, la cual debe de ser del mismo tipo que el valor que se esta retornando.
Este es un ejemplo de cmo llamar al mtodo Funcin y de guardar el valor que retorna en la variable
suma.

KPL cuenta con un conjunto de mtodos y funciones predefinidos, las cuales pueden ser utilizados por el
programador al desarrollar sus programas, a diferencia de los desarrollados por l que solo sirven dentro

del programa donde fueron definidos. Estos mtodos y funciones se llaman tal cual como se explic
previamente. La lista de estos se encuentra en este link: KPL System Methods And Functions
RETORNO EN LAS FUNCIONES
Hay que tener muy claro el concepto de retorno en las funciones, ya que cuando KPL llega a una de estas
instrucciones inmediatamente termina la funcin y regresa al lugar del programa de donde se llam a la
funcin. Adems una funcin puede tener ms de una instruccin de retorno, pero solo puede existir una
por cada uno de los posibles caminos en el curso de accin de la funcin, sino el cdigo no resulta siendo
alcanzable, o se llega al final de la ejecucin de una funcin sin retornar nada. Veamos todo esto ms
detallamente con este ejemplo:

Ejercicios:

Modifique el Programa del Ovni desarrollado anteriormente para que se autodestruya despus de
oprimir la tecla Enter, y ah termine la aplicacin.

Escribir un programa que dibuje tres crculos en la pantalla y luego la borre despus de oprimir la
tecla B.

CONCEPTOS AVANZADOS DE PROGRAMACION

El primer concepto que vamos a tratar en esta seccin es el que responde a la pregunta: Cmo hacer para
colocarle comillas al texto que despliego en la pantalla, si estas son utilizadas para delimitar el texto a
desplegar? La respuesta es muy sencilla, se sigue la siguiente sintaxis: "\"Aqu va el texto a desplegar
entre comillas\"". Aunque no parezca ser un concepto tan avanzado como se pretenda puede resultar
muy til a la hora de mejorar la apariencia del texto desplegado.
RECURSIVIDAD EN LOS MTODOS Y FUNCIONES

Hay ciertos problemas que cuando se intentan traducir de la concepcin que tenemos en la cabeza a
cdigo resultan mucho ms fcil verlos como una anidacin de la misma funcin, es decir, dentro de una
funcin se puede volver a llamar a si misma dentro de su propio cdigo. Lo ms importante a tener en
mente al hacer uso de la recursividad es definir el punto de parada para que el programa sepa cuando
dejar de llamarse a si mismo y no seguir hacindolo indefinidamente.
Un ejemplo es un mtodo que encuentre el nmero factorial de un nmero positivo, el cual esta definido
por:<![endif]>

Es decir, el factorial de 2 sera: 2x1 = 2; el factorial de 5 sera 5x4x3x2x1; y as sucesivamente para todos
los nmero positivos. Una forma fcil de implementar el nmero factorial en cdigo es crear una funcin
que retorne 1 si el nmero es 0, y para los n>=1 multiplique el nmero que recibe por parmetro con otra
llamada al mismo mtodo pero el parmetro sera el nmero decrementado en uno. Y esto se repetira
hasta que el nmero que recibe la funcin como parmetro sea 1, el cual sera la condicin de parada para
finalizar la cadena de llamados recursivos.
Este es el cdigo de la funcin terminada:
Function Factorial(Numero As Int) As Int
If Numero = 0 Then
Return 1
End If
Define Temporal As Int = Numero
If Numero = 1 Then
Return 1
Else
Temporal= Temporal - 1
Return Numero * Factorial(temporal)
End If
End Function
CREANDO CUADROS MS FLUIDOS
Una de las tcnicas empleadas por los desarrolladores de juegos para darle mayor calidad a las imgenes
generadas es decirle al motor grfico que genere los cuadros de animacin antes de refrescar la pantalla.
Esto hace que las animaciones se vean mucho ms suaves. En KPL este efecto se logra de la siguiente
manera:
// Se coloca la instruccin:
BeginFrame()

// Aqu se coloca todo el cdigo que produce las animaciones.

// Y por ltimo se le dice a KPL que enve todos los cambios a la
// pantalla con
RefreshScreen()
DESPLEGAR ESTADOS DEL JUEGO DURANTE LA EJECUCIN DEL MISMO
Aunque parezca difcil, desplegar los estados del juego al usuario mientras este juega no es ms que
aplicar todos los conceptos para manejo de sprites y del lpiz para dibujar en la pantalla un elemento ms.
Estos elementos pueden ser puntajes, tiempo, vida, etc,. Por tal motivo, dejamos esta seccin para que el
lector la investigue.
MS TEMAS DE ESTA SECCIN:

2 Jugadores
Ratn
Pausar un juego
Mover el fondo
Ajuste de velocidad
Uso de sonidos
Uso de vectores

APLICANDO ESTRUCTURAS PARA JUEGOS CON 2 JUGADORES

Ahora vamos a desarrollar un ejemplo que muestra como puede un juego manejar a dos jugadores a
travs del mismo teclado.
Program DosJugadores
// Las estructuras son usadas para almacenar toda la informacin
// concerniente al Sprite que un jugador va a utilizar
Structure SpriteJugador
Nombre As String
Imagen As String
X As Decimal

Y As Decimal
End Structure
Method Main()
// De esta forma se tendr un Sprite distinto para cada uno
// de los dos jugadores, pero controladas individualmente con el teclado
Var Ovni As SpriteJugador
Var EstacionEspacial As SpriteJugador
// SetDeviceCoordinates() hace que KPL utilice un sistema de
// coordenadas donde la esquina superior izquierda es el punto (0,0)
SetDeviceCoordinates()
// El Jugador Uno va a controlar el Ovni
Ovni.X = 400
Ovni.Y = 240
Ovni.Nombre = "Jugador Uno"
Ovni.Imagen = "UFO.GIF"
// El Jugador Dos va a controlar la Estacin Espacial
EstacionEspacial.X = 150
EstacionEspacial.Y = 200
EstacionEspacial.Nombre = "Jugador Dos"
EstacionEspacial.Imagen = "SpaceStation.GIF"
LoadSprite(Ovni.Nombre, Ovni.Imagen )
MoveSpriteToPoint(Ovni.Nombre, Ovni.X, Ovni.Y )
// Las 2 imgenes usada solo contiene 6 cuadros de animacin, lo que crea el efecto de giro sobre su
// eje. Para crear la animacin se va a utilizar un arreglo de 6 valores Enteros, que le digan al Sprite
// que tanto tiempo desplegar un cuadro de animacin antes de pasar al siguiente.
Var LineaDeTiempo As Int[6]
LineaDeTiempo [1] = 50
LineaDeTiempo [2] = 50

LineaDeTiempo [3] = 50
LineaDeTiempo [4] = 50
LineaDeTiempo [5] = 50
LineaDeTiempo [6] = 50
// Se le introduce la lnea de tiempo al Ovni
SetSpriteAnimationTimeline(Ovni.Nombre, True, LineaDeTiempo)
// Se despliega el Ovni
ShowSprite( Ovni.Nombre )
LoadSprite(EstacionEspacial.Nombre, EstacionEspacial.Imagen )
MoveSpriteToPoint(EstacionEspacial.Nombre, EstacionEspacial.X, EstacionEspacial.Y)
// Se le introduce la lnea de tiempo a la Estacin Espacial
SetSpriteAnimationTimeline(EstacionEspacial.Nombre,True, LineaDeTiempo)
// Se despliega la Estacin Espacial
ShowSprite(EstacionEspacial.Nombre )
// El uso de estas 2 variables se explica ms adelante
Var UltimaRevision As Decimal = 0.0
Var HoraActual As Decimal
// Este ciclo se repetir indefinidamente hasta que el usuario oprima el botn de detener la
// aplicacin
// localizado en la esquina superior izquierda de la ventana
While True
// Se revisa la hora actual del sistema
HoraActual = TickCount()
// Si no han pasado 50 milisegundos desde la ltima vez que se revis no se hace nada.
// Esto se realiza con el objetivo de reducir la velocidad de operacin del juego a una que los
// humanos puedan manejar, debido a que las computadoras son tan rpidas que ejecutaran
// todos
// los pasos ms rpido que lo que un humano podra responder.
If HoraActual - UltimaRevision > 50 Then

// El Jugador Uno controla el Ovni utilizando las flechas en el teclado

If IsKeyDown("Right") Then
Ovni.X = Ovni.X + 10
End If
If IsKeyDown("Left") Then
Ovni.X = Ovni.X - 10
End If
If IsKeyDown("Up") Then
Ovni.Y = Ovni.Y - 10
End If
If IsKeyDown("Down") Then
Ovni.Y = Ovni.Y + 10
End If
// Se mueve el Ovni
MoveSpriteToPoint( Ovni.Nombre, Ovni.X, Ovni.Y )
// El Jugador Dos controla a la Estacin Espacial utilizando las teclas W A S Z
// Si se presiona la tecla 'D' la Estacin se mover a la derecha
If IsKeyDown("D") Then
EstacionEspacial.X = EstacionEspacial.X + 10
End If
// Si se presiona la tecla 'A' la Estacin se mover a la izquierda
If IsKeyDown("A") Then
EstacionEspacial.X = EstacionEspacial.X - 10
End If
// Si se presiona la tecla 'W' la Estacin se mover hacia arriba
If IsKeyDown("W") Then
EstacionEspacial.Y = EstacionEspacial.Y - 10
End If

// Si se presiona la tecla 'S' la Estacin se mover hacia abajo

If IsKeyDown("S") Then
EstacionEspacial.Y = EstacionEspacial.Y + 10
End If
// Se mueve la Estacin Espacial
MoveSpriteToPoint(EstacionEspacial.Nombre, EstacionEspacial.X, EstacionEspacial.Y )
// Despus de mover ambos Sprites se coloca como el tiempo de la ltima revisin a la hora
// actual. De esta forma esperaremos otros 50 milisegundos desde este momento hasta que ambos
// Sprites se puedan mover nuevamente.
UltimaRevision = HoraActual
End If
End While
End Method
End Program

USO DEL RATON EN LOS JUEGOS

KPL tambin permite hacer uso del ratn (Mouse) en los juegos. Debe incluir un mtodo con el parmetro
Evento que define las acciones con el ratn ante las cuales responder. En este caso solo nos interesa
cuando el usuario haga clic, construimos el cdigo para que reponda solamente ante el evento
ButtonDown . Los parmetros X y Y definen la posicin donde se a hecho clic con el ratn. Y el
parmetro Boton indica si se oprimio el botn izquierdo (es igual a 1) o el derecho (es igual a 2).
Method EntradaRaton(Evento As String, X As Int, Y As Int, Boton As Int )
If Evento = "ButtonDown" Then
// Aqu se incluye todo el cdigo que le indica a KPL que
// hacer cada vez que se hace clic con el ratn
If Boton = 1 Then
// Aqu se incluye todo el cdigo que le indica a KPL que
// hacer cada vez que se hace clic izquierdo con el ratn
End If

If Boton = 2 Then
// Aqu se incluye todo el cdigo que le indica a KPL que
// hacer cada vez que se hace clic derecho con el ratn
End If
End If
End Method
A este mtodo no se le hace un llamado explicito dentro del programa, es KPL quien lo llama cada vez
que se usa el ratn. Para hacer uso del ratn no basta con declarar el mtodo EntradaRaton, hay que
especificar su uso con la instruccin:
SetMouseEvent("EntradaRaton")
La cual se puede colocar al principio del mtodo Main() o en el lugar que queramos, para que de ah en
adelante KPL sepa como responder a las entradas del ratn. Para indicarle a KPL que ya no queremos
seguir haciendo uso del ratn se puede hacer lo siguiente:
Method BloquearRaton(Evento As String, X As Int, Y As Int, Boton As Int )
// Se puede definir un mtodo vaco que no realice ninguna accin
// cuando se hace uso del ratn.
End Method
Para indicarle a KPL que use este mtodo volvemos a utilizar la instruccin SetMouseEvent pero esta
vez el parmetro ser el mtodo BloquearRaton.
Se propone como ejercicio investigar que ms Eventos existen para controlar al ratn.

COMO PAUSAR UN JUEGO

Para explicar como pausar un juego vamos a utilizar el programa desarrollado en los ejercicios con sprites
donde el Ovni dispara un misil. Este es el cdigo del programa:
Program OvniPausa
Structure Imagen
x As Int
y As Int
incX As Int
incY As Int

End Structure
Define ovni As Imagen
Define misil As Imagen
Define hayMisil As Bool = False
Define TiempoImagen As Int[6] = {40, 40, 40, 40, 40, 40}
Method cargarOvni()
LoadSprite("OVNI", "UFO.gif")
ovni.x = 50
ovni.y = 50
ovni.incX = 5
ovni.incY = 5
MoveSpriteToPoint("OVNI", ovni.x, ovni.y)
SetSpriteAnimationTimeline("OVNI", True, TiempoImagen)
ShowSprite("OVNI")
End Method
Method cargarMisil()
LoadSprite("MISIL", "missile1.gif")
ScaleSprite("MISIL", 0.8)
SetSpriteAnimationTimeline("MISIL", True, TiempoImagen)
RotateSprite("MISIL", 90)
misil.incY = 5
End Method
Method moverMisil()
If misil.y < ScreenHeight() + GetSpriteHeight("Misil") Then
MoveSpriteByAmount("MISIL", 0, misil.incY)
misil.y = misil.y + misil.incY
Else
hayMisil = False

HideSprite("MISIL")
End If
End Method
Method tecla()
If IsKeyDown("UP") And ovni.y > 0 Then
ovni.y = ovni.y - ovni.incY
End If
If IsKeyDown("Down") And ovni.y < ScreenHeight() - GetSpriteHeight("OVNI") Then
ovni.y = ovni.y + ovni.incY
End If
If IsKeyDown("Right") And ovni.x < ScreenWidth() - GetSpriteWidth("OVNI") Then
ovni.x = ovni.x + ovni.incX
End If
If IsKeyDown("Left") And ovni.x > 0 Then
ovni.x = ovni.x - ovni.incX
End If
If IsKeyDown("A") And hayMisil = False Then
hayMisil = True
misil.x = ovni.x
misil.y = ovni.y
MoveSpriteToPoint("MISIL", misil.x, misil.y + GetSpriteHeight("OVNI"))
ShowSprite("MISIL")
End If
MoveSpriteToPoint("OVNI", ovni.x, ovni.y)
End Method
// Para crear el efecto de pausa en el juego incluimos este mtodo
Method Pausar()
If IsKeyDown("Space") Then

// Se espera a que se suelte la barra espaciadora

While IsKeyDown("Space")
RefreshScreen()
End While
// Se imprime el mensaje de PAUSA
SetFont("Arial", 64, True, False, False)
Color(137)
Pen(False)
MoveTo(100, 100)
Rectangle(500, 200, True)
MoveTo(120, 120)
Color(20)
Rectangle(460, 160, True)
Color(139)
MoveTo(117, 150)
Print("PAUSADO")
RefreshScreen()
// Se espera a que se vuelva a presionar y soltar la
// barra espaciadora. De esta manera el programa se
// queda bloqueado en un ciclo de ejecucin infinito
// hasta que se retire la pausa
While IsKeyDown("Space") = False
RefreshScreen()
End While
While IsKeyDown("Space")
RefreshScreen()
End While
// Se borra el mensaje de PAUSA

BorrarPantalla()
End If
End Method
// Este mtodo vuelve a pintar toda la pantalla de blanco
// nuevamente ocultando el letrero de PAUSA
Method BorrarPantalla()
MoveTo(0, 0)
Color(White)
Rectangle(700, 390, True)
End Method
Method Main()
cargarOvni()
cargarMisil()
Loop 10000
tecla()
moverMisil()
Delay(10)
// Aqu se hace uso del mtodo que detiene el juego
// cuando se usa la pausa
Pausar()
End Loop
End Method
End Program

MOVER EL FONDO
Ahora desarrollaremos un ejemplo que nos permite crear el efecto de movimiento del fondo. Esta tcnica
es muy til para hacerle creer al usuario que los objetos se estn moviendo en el universo creado para el
juego, mientras que en realidad lo nico que se mueve es el fondo (en ingls background) de la pantalla.

Program RotarFondo
// Se define el tamao de la ventana
Define AnchoPantalla As Int = 640
Define AltoPantalla As Int = 480
// Se crean las variables para almacenar la informacin relevante
// sobre el sprite
Define NombreSprite As String
Define AltoSprite As Int
Define AnchoSprite As Int
Method DibujarCiudad()
NombreSprite="CIUDAD"
LoadSprite(NombreSprite, "CityScape.png")
// Se obtienen las dimensiones del sprite
AnchoSprite = GetSpriteWidth( NombreSprite )
AltoSprite = GetSpriteHeight( NombreSprite )
// Se le dice a KPL que coloque el sprite de la ciudad en la
// parte inferior de la pantalla, y que repita
// horizontalmente la misma imagen hasta llenarla por
// completo. Esto se hace para que el fondo llene toda la
// pantalla aun si la imagen utilizada en el sprite es ms
// pequea.
TileSprite( NombreSprite, 0, AltoPantalla - AltoSprite, AnchoPantalla + 2, AltoSprite, 0,
0)
End Method
Method Main()
// Se le dice a KPL que utilice nuestro tamao personalizado
// para la pantalla
SetScreenSize(AnchoPantalla,AltoPantalla)

// Se dibuja la ciudad
DibujarCiudad()
While True
BeginFrame()
// Se copia una porcin de la parte izquierda de la
// pantalla justo hacia el extremo derecho de la misma.
// Hay que tener en cuenta que la nica parte de la
// pantalla que este mtodo copia son los sprites a los
// cuales se les ha aplicado la instruccin TileSprite
CopyRect( 0, AltoPantalla - AltoSprite, 1, AltoSprite, AnchoPantalla + 1,
AltoPantalla - AltoSprite )
// Se rota todo el ancho de la pantalla, desde la punta
// de los edificios hasta la parte inferior de la
// misma, un pxel a la izquierda. El rea que se rota
// incluye la porcin que se copi en el paso anterior.
// De esta forma es como se logra el efecto de
// continuidad en el fondo.
ScrollBackground( 0, AltoPantalla - AltoSprite, AnchoPantalla + 2, AltoSprite,
-1, 0 )
RefreshScreen()
Delay(20)
End While
End Method
End Program

AJUSTE DINMICO DE LA VELOCIDAD DE LAS ANIMACIONES DE UN

JUEGO
El ltimo concepto que vamos a tratar a lo largo de este curso es el que involucra un ajuste dinmico de la
velocidad de las animaciones para que el juego corra al mismo ritmo sin importar que tan rpida o lenta es

la computadora donde este se ejecute. Pero, por qu surge la necesidad de realizar este ajuste? Todo es
debido a que no todos los computadores tienen el mismo hardware, razn por la cual el mismo segmento
de cdigo correr a una velocidad diferente dependiendo del equipo que la ejecute. Esto degrada la
experiencia del juego, al esta no siempre ser constante; produciendo que ciertos juegos corran muy lento
en computadores viejos mientras que otros corren tan rpido en computadores ms modernos que los hace
injugables.
Para explicar como realizar este ajuste de los cuadros vamos a analizar el juego Planes, que viene con los
juegos integrados de KPL.
El juego define la siguiente variable para guardar la informacin del tiempo que se demora un cuadro en
ser desplegado en la pantalla, durante cada ciclo del main:
Define secondsPerFrame As Decimal = 0.0
La funcin AdjustForFrameRate es usada por todas las reas del programa Planes que generan
animaciones, para convertir la velocidad de animacin, que se define como el nmero deseado de pxeles
por segundo a mover, al nmero de pxeles a mover durante un cuadro de animacin.
Para determinar cuantos pxeles se debe mover una figura en la pantalla, se tiene que averiguar cuanto
tiempo le tom a la computadora para dibujar el ltimo cuadro.
Esto le permite a los objetos del juego moverse a una velocidad muy similar tanto en computadores lentos
como en computadores rpidos. De todas formas, en los computadores ms lentos, que se demoran ms
en dibujar cada cuadro independiente, la cantidad de movimiento por cuadro ser mayor por lo que las
animaciones no sern tan fluidas. Esta es la razn por la cual en computadoras demasiado lentas las
animaciones parecern como si estuviesen perdiendo cuadros, pues las figuras se movern en incrementos
ms grandes para compensar la baja cantidad de cuadros por segundo a la que corre el juego. Solamente
las maquinas muy rpidas podrn alcanzar la velocidad de cuadros deseada!
Function AdjustForFrameRate( AmountPerSecond As Decimal ) As Decimal
Return AmountPerSecond * secondsPerFrame
End Function
Esta es la manera como el juego utiliza la funcin AdjustForFrameRate para ajustar la velocidad del
desplazamiento horizontal de los aviones enemigos en el mtodo AnimateEnemies:
Enemies[i].X = Enemies[i].X - AdjustForFrameRate( Enemies[i].Speed )
En el mtodo HandleKeys se aplica el mismo principio para ajustar la velocidad del movimiento del
avin del jugador:
If IsKeyDown( "Up" ) Then
If Plane.Y > 10 Then
Plane.Y = Plane.Y - AdjustForFrameRate( Plane.Speed )
End If
End If
De esta forma se logra reducir la cantidad de movimiento de cada uno de los aviones si el computador
realiza los clculos muy rpido.

La variable secondsPerFrame solo es modificada en el mtodo main. En este mtodo se definen las
siguientes variables para ayudar a calcular el tiempo que se demora en dibujarse el ltimo cuadro de
animacin desplegado en la pantalla.
Define startTime As Decimal
Define endTime As Decimal
Define BackgroundScrollTimer As Decimal
En este mtodo dentro de un ciclo repetitivo se realiza lo siguiente:
// En la variable startTime se guardan los milisegundos que lleva
// KPL ejecutandose desde que empez a correr.
startTime = TickCount()
BeginFrame()
// En este juego solo se desea rotar el fondo estrictamente lo necesario.
// Para hacer esto, el siguiente cdigo rota el fondo cada 40
// milisegundos, es decir, unas 25 veces por segundo.
If startTime - BackgroundScrollTimer > 40 Then
// Aqu se coloca el cdigo para rotar el fondo
// Se reinicia el contador que mide el tiempo para la prxima
// rotacin del fondo
BackgroundScrollTimer = startTime
End If
// Se generan todas las animaciones para este cuadro
AnimateEnemies()
HandleKeys()
// Se actualize la pantalla
RefreshScreen()
// Se almacena el tiempo actual
endTime = TickCount()
// Se realiza el ajuste, el cual se realiza disminuyendo 1 s
// (microsegundo) por cada milisegundo que se demor el sistema en

// dibujar el cuadro
secondsPerFrame = (endTime - startTime) * 0.001
// Se despliega el tiempo de ajuste en la pantalla
Status("Frame Time: " + FormatString( "0.0000", secondsPerFrame ) )

USO DE SONIDOS
Para usar sonidos se emplea el mtodo PlaySound, el cual permite reproducir sonidos en KPL. Lo nico
que se requiere es pasarle por parmetro el nombre y la ruta donde se encuentra ubicado el archivo de
sonido que se desea reproducir. Si se especifica solo el nombre, sin una ruta, KPL asume que el sonido se
encuentra en la carpeta \Media\Sounds dentro del directorio de KPL.
En el juego Racer2 para evitar que el mismo sonido se reprodujera ms de una vez simultneamente se
emplea un sistema de control que evita que el flujo normal de operacin del juego acceda al mtodo
PlaySound a menos que haya transcurrido el tiempo que dura la reproduccin del sonido. Esto se puede
ver en el siguiente fragmento de cdigo:
Method SonidoMotor()
// Solo entra al mtodo a menos que desde la ltima vez que
// se reprodujo el sonido hayan pasado como mnimo 2800
// milisegundos.
If HoraActualSonido - UltimaRevisionSonido > 2800 Then
PlaySound("cartcar.wav")
UltimaRevisionSonido = HoraActualSonido
End If
End Method

USO DE VECTORES PARA EL MOVIMIENTO

Ahora vamos a cambiar un poco el esquema tradicional con que movemos los objetos dentro del ambiente
de KPL, se van a empezar a utilizar los vectores. Para eso se requiere que el objeto que vamos a mover
tenga definido los siguientes atributos:
o

Una direccin o ngulo () al cual apunta. En el juego Racer2 este se llama Heading.

Dos variables para almacenar la posicin de la cabeza del vector.

En la siguiente figura se muestra el esquema que se sigue para poder manejar el movimiento:

Para rotar el objeto sobre si mismo se hace lo siguiente:

Method RotateCar( Heading As Decimal )
// Se le indica el ngulo al cual quiero llegar y se le aplica
// el ajuste dinmico respectivo de la velocidad de la animacin
Jugador1.Heading = Jugador1.Heading +
AdjustForFrameRate( Heading )
// Se rota el objeto
RotateSprite( Jugador1.Imagen, Jugador1.Heading )
End Method
Pero para mover el objeto una cierta cantidad hacia adelante en la direccin que indica el ngulo (), se
requiere descomponer el vector que especifica este incremento en sus respectivas componentes X y Y:
Method MoveCar()
Define amountOfMovement As Decimal =
AdjustForFrameRate( Jugador1.speed )
// Se saca la componente en X del vector de incremento de la posicin
Define amountX As Decimal = Cos( Jugador1.Heading * piOver180 )
* amountOfMovement
// Se recalcula la nueva posicin en el eje X del objeto

Define nextX As Decimal = Jugador1.posX - amountX

// Se revisa si esta nueva posicin es valida
If NextX > 0 And NextX < ScreenWidth()
GetSpriteWidth(Jugador1.Imagen) Then
Jugador1.posX = nextX
End If
// Se saca la componente en Y del vector de incremento de la posicin
Define amountY As Decimal = Sin( Jugador1.Heading * piOver180 )
* amountOfMovement
// Se recalcula la nueva posicin en el eje Y del objeto
Define nextY As Decimal = Jugador1.posY amountY
// Se revisa si esta nueva posicin es valida
If nextY > 35 And nextY < ScreenHeight()
GetSpriteHeight(Jugador1.Imagen) Then
Jugador1.posY = nextY
End If
// Se mueve el objeto hacia su nueva posicin

MoveSpriteToPoint( Jugador1.Imagen, Jugador1.posX, Jugador1.posY

End Method
Algo para tener en cuenta es que las funciones que calculan el coseno y el seno en KPL trabajan con
Radianes, por tal motivo, se requiere hacer la conversion de grados que es la unidad con que estamos
trabajando en este juego, porque es ms facil de implementar a radianes. La funcin de la conversin es

la siguiente:

EJERCICIO FINAL
Ahora, despus de haber visto todos estos mtodos de animacin y de programacin de juegos, te
encuentras en la capacidad de desarrollar tu propio juego completamente funcional. Por eso, se propone
como ejercicio final la realizacin de tu propio juego, el cual debe reunir todo lo aprendido a lo largo del
curso, y puede ser desarrollado en grupos o individualmente.