CURSO DE PROGRAMACION DE VIDEO JUEGOS: TEXTO #5.
---------------------------------------------------
Hola, como han estado, estuve pensando que cuando terminemos el
curso podriamos continuarlo en C++, usando lo que ya sabemos del
Turbo Pascal como base, ¨les parece?, de todas maneras no es nada
definitivo, tal vez me aburra del curso y ya no lo siga haciendo
(no se asusten, todavia me quedan muchas ganas).
Como se los habia dicho, en este capitulo vamos a terminar con
la primera parte del curso y estaremos en condiciones de fabricar
los primeros juegos en modo texto.
Veamos primero el uso de la funcion READKEY:
1.- Funcion READKEY.
Esta funcion nos permite leer que tecla es presionada en nuestro
teclado. Veamos un ejemplo de su uso:
Ejemplo: tecla := ReadKey;
en este ejemplo la variable tecla es de tipo CHAR (caracter), y
le estamos asignando el valor que devuelve la funcion ReadKey
que es el caracter de la tecla que estamos presionando.
Ya se lo que estan pensando, ya sabemos hacer que se mueva una
letra por la pantalla, ahora podemos hacer que se pueda mover
con el teclado. Veamos primero un programa muy simple que nos
va a ser de mucha utilidad despues:
Esta funcion necesita la unidad CRT para poder funcionar, o sea,
debemos agregar en la primera linea del programa:
Uses crt;
------------------------------------------------------------------------------
{ Saber el caracter de las teclas }
Uses crt;
var tec: char;
begin
clrscr;
writeln( 'Presione una tecla...' );
tec:=READKEY;
writeln( 'Usted presiono la: ', tec );
readln;
end.
------------------------------------------------------------------------------
Lo unico que hace este programa es entregarnos el valor (de tipo
char) de la tecla que presionamos. Creo que no requiere mayor
explicacion.
-- o --
2.- La funcion ORD.
Veamos ahora el uso de otra funcion, que yo considero complemento
de READKEY. Esta nos entrega el valor del codigo ASCII de un caracter
(al menos para eso lo uso yo).
¨Que demonios es un codigo ASCII?
(Con esta respuesta se me van a venir un chorron de criticas de la
gente que sabe, pero bueno, ya explique las reglas del curso en el
capitulo 1, yo solo ense¤o lo que yo se).
veras, en un PC existen 256 caracteres, es decir, podemos escribir
256 simbolos distintos, entre ellos las letras, los numeros, sim-
bolos (@#$%"), etc.. cada uno de esos caracteres tiene un numero que
lo identifica, ese numero es llamado codigo ASCII del caracter.
De este modo, la funcion ORD nos entrega un valor entre 0 y 255 que
corresponde al codigo de un caracter que nosotros le entregamos
en los parametros.
Ejemplo: Ord( 'a' ); { nos entrega el codigo ASCII del caracter a }
Ord( '#' ); { nos entrega el codigo ASCII del caracter # }
Consideremos ahora la siguiente linea:
tec := Ord( ReadKey );
como sabemos, la funcion ReadKey nos devuelve un valor de tipo char
que corresponde a la tecla que presionamos en el teclado, lo que
estamos haciendo en esta linea es agarrar este valor y enviarlo
como parametro a la funcion Ord, que nos va a devolver el codigo
ASCII de la tecla que presionamos, luego el valor de este codigo
lo almacenamos en la variable tec (que ahora es de tipo integer).
No es muy complicado.
Completemos ahora el programa anterior:
------------------------------------------------------------------------------
{ Saber el caracter de las teclas y su codigo ASCII }
Uses crt;
var tec: char;
cod: integer;
begin
clrscr;
writeln( 'Presione una tecla...' );
tec := READKEY;
cod := Ord(tec);
writeln( 'Usted presiono la: ', tec );
writeln( 'Su codigo ASCII es: ', cod );
readln;
end.
------------------------------------------------------------------------------
Ven como funciona, es importante que guarden este programa en un
archivo, ya que lo vamos a ocupar para saber el codigo de las te-
clas.
-- o --
Bueno, con lo aprendido en capitulos anteriores y estas nuevas fun-
ciones, hagamos un peque¤o programita que nos permita mover una
barra de lado a lado por la pantalla.
------------------------------------------------------------------------------
{ Programa de la barra. }
Uses crt;
var x: integer;
tec: byte; { BYTE es un tipo de variable entera entre 0 y 255 }
begin
clrscr;
x:=40;
while tec<>27 do { 27 es el codigo ASCII del caracter de la tecla ESC }
begin
if keypressed then
begin
tec := Ord( ReadKey );
if tec=111 then dec( x ) { codigo ASCII de la o es 111 }
else
if tec=112 then inc( x ); { codigo ASCII de la p es 112 }
end;
if x>78 then x:=78
else
if x<2 then x:=2;
gotoxy( x, 20 );
write( ' | ' );
end;
end.
------------------------------------------------------------------------------
Para mover la barra de lado a lado ocupamos las teclas O y P.
Lamentablemente la funcion READKEY no nos permite verificar las
teclas especiales como las flechas, el control, el alt o el shift
pero este problema lo solucionaremos mas adelante.
Un buen ejercicio seria juntar este programa con el de la pelota,
hacerle algunas modificaciones y hacer un juego.
Otra funcion que les podria ser de utilidad es la CHR que hace lo
contrario de la ORD, o sea, nosotros le entregamos como parametros
el codigo ASCII de un caracter y esta nos devuelve el caracter
correspondiente.
-- o --
Para finalizar este corto y ultimo capitulo de la primera parte
de nuestro curso veamos un repaso de lo que hemos aprendido:
* Un programa es un texto que le indica al computador lo que debe
hacer paso a paso.
* Lo que hace un lenguaje de programacion es agarrar un programa,
compilarlo transformandolo a un codigo OBJETO, tomar el codigo
objeto y enlazarlo transformandolo al codigo EJECUTABLE.
* Un programa se divide basicamente en 4 partes:
- La declaracion de las UNIDADES a ocupar. ( Seccion USES ).
- La declaracion de las CONSTANTES. ( Seccion CONST ).
- La declaracion de VARIABLES. ( Seccion VAR ).
- El programa principal. ( Entre BEGIN y END. ).
* Las constantes y las variables son palabras a las que se le
asocia un valor (como cajones que guardan valores). Estos valores
pueden ser de tipo:
- INTEGER: Valor de tipo entero.
- BYTE: Valor de tipo entero positivo entre 0 y 255.
- REAL: Valor de tipo real.
- CHAR: Guarda un caracter. Ej.: 'a', '7', '@'...
- STRING: Guarda un texto. Ej.: 'Hola', 'Juan Pablo', '198@'...
- BOOLEAN: Puede tomar 2 valor verdadero (TRUE) o falso (FALSE).
Las constantes no pueden ser cambiadas en el programa, las variables
si, les podemos asignar valores, sumarlas, restarlas, etc..
* Para crear nuestros programas ocupamos una serie de palabras
llamadas palabras reservadas. Entre ellas estan:
- BEGIN...END: Para "encerrar" un grupo de instrucciones que
tienen algo en comun.
- USES: Para declarar las unidades que seran necesarias.
- CONST: Para declarar las constantes.
- VAR: Para declarar las variables.
- IF..THEN..ELSE: Para verificar si se cumple(n) cierta(s)
condicion(es). De ser asi, se ejecuta una o
mas instrucciones.
- FOR..TO..DO: Para ejecutar una serie de instrucciones un numero
se veces. Tambien se puede usar DOWNTO.
- WHILE..DO: Para ejecutar una serie de instrucciones mientras
se cumpla una condicion.
- AND y OR: Para verificar varias instrucciones las unimos con
AND si queremos que se cumplan las dos juntas o con
OR si queremos que sea suficiente con que se cumpla
una sola de ellas.
* Ademas ocupabamos otras palabras llamadas procedimientos y funciones.
Entre ellas estaban:
Procedimientos:
- CLRSCR: Borra la pantalla.
- WRITE y WRITELN: Escriben en la pantalla.
- READ y READLN: Leen desde el teclado.
- GOTOXY: Coloca el cursor en una posicion indicada en la pantalla.
- RANDOMIZE: Permite el uso de la funcion RANDOM.
- TEXTCOLOR: Permite cambiar el color de las letras en modo texto.
- TEXTBACKGROUND: Permite cambiar el color de fondo en modo texto.
- INC: Incrementa el valor de una variable numerica.
- DEC: Decrementa el valor de una variable numerica.
- DELAY: Espera una cantidad indicada de milisegundos.
- SOUND: Produce un sonido por el speaker.
- NOSOUND: Detiene un sonido producido con SOUND.
Funciones:
- RANDOM: Arroja un numero entero al azar dentro de un rango fijo.
- KEYPRESSED: Devuelve un valor de tipo booleano que indica si se
esta presionando una tecla.
- READKEY: Devuelve el caracter correspondiente a la tecla que se
esta presionando.
- ORD: Devuelve el valor numerico correspondiente a un caracter.
- CHR: Devuelve el caracter correspondiente a un valor numerico.
La diferencia entre los procedimientos y las funciones es que
las funciones devuelven un valor como resultado de lo que hacen.
* Para agregar comentarios en nuestros programas ocupamos los simbolos
{ }, de modo que todo lo que esta entre estos dos signos no es
tomado en cuenta por el computador.
-- o --
Bueno, eso fue todo por este capitulo, tambien damos por terminada
la primera parte de nuestro curso. Aunque no lo crean, ya estan
en condiciones de programar un juego, ya pueden hacer que se muevan
cosas con las teclas o que se muevan por si solas, tambien pueden
hacer que el computador haga movimientos al azar por medio de la
funcion RANDOM, todo lo que les queda es practicar mucho, hacer
y hacer programas hasta que les resulten.
Ahora voy a demorarme un poco en publicar la segunda parte del curso
de modo de dejarles tiempo para que hagan un par de juegos con
lo que ya han aprendido.
Traten de mandarme mails con todas las preguntas que tengan y yo
se las aclaro, es importante que aprendan bien todo lo que hemos
visto. Mandenme tambien sus juegos si quieren, me interesa ver que
tanto aprenden con este curso.
Espero sus mails, y los dejo con un juego que los puede ayudar
a entender como trabajar, CHAO...
JPLL
pc-jlopez@entelchile.net
www.geocities.com/SiliconValley/Bridge/1910
-- o --
------------------------------------------------------------------------------
uses crt;
const ESC=27; { Codigos ASCII de las teclas }
P=112; { Se juega con estas teclas }
L=108;
W=119;
A=97;
var y1, y2: integer; { Para mover la barra 1 y 2 }
xb, yb, aux, auy: integer; { Para mover la bola }
key: integer; { Para revisar las teclas }
begin
clrscr;
{ Aqui se inicializa las variables }
y1 := 12; { Posicion de la barra 1 }
y2 := 12; { Posicion de la barra 2 }
xb := 40; yb := 12; { Posicion de la bola }
aux := 1; auy := 1;
{ AquĦ comienza el ciclo }
while key<>ESC do
begin
clrscr;
{ Aqui se revisan las teclas }
if keypressed then
begin
key := ord(readkey);
{ Teclas del jugador 1 }
if key=P then dec(y1)
else if key=L then inc(y1);
if y1<1 then y1:=1
else if y1>23 then y1:=23;
{ Teclas del jugador 2 }
if key=W then dec(y2)
else if key=A then inc(y2);
if y2<1 then y2:=1
else if y2>23 then y2:=23;
end;
{ Fin revision de teclas }
{ Se cambia la posicion de la bola }
inc( xb, aux );
inc( yb, auy );
{ Fin cambio de posicion }
textcolor( 15 );
{ Aqui se revisa que la bola toque los bordes }
if xb<4 then { Si llega al borde izquierdo }
begin
if (yb>=y2) and (yb<=y2+1) then aux:=-aux { Si toca la barra }
else { Si no la toca }
begin
gotoxy( 30, 1 );
writeln( 'Gana el jugador 1' );
readln;
xb := 40; yb := 12;
end;
end
else { Si no se sale por el borde izquierdo }
if xb>76 then { Si se sale por el borde derecho }
begin
if (yb>=y1) and (yb<=y1+1) then aux:=-aux { Si toca la barra }
else { Si no la toca }
begin
gotoxy( 30, 1 );
writeln( 'Gana el jugador 2' );
readln;
xb := 40; yb := 12;
end;
end;
{ Revision del borde de arriba y de abajo }
if (yb<2) or (yb>23) then auy:=-auy;
{ Fin revision de bordes }
textcolor( 11 );
{ Se dibuja la barra 1 }
gotoxy( 77, y1 ); write( '|' );
gotoxy( 77, y1+1 ); write( '|' );
{ Se dibuja la barra 2 }
gotoxy( 3, y2 ); write( '|' );
gotoxy( 3, y2+1 ); write( '|' );
textcolor( 10 );
{ Se dibuja la bola }
gotoxy( xb, yb ); write( 'o' );
{ Velocidad del juego = 100 }
delay( 100 );
end;
{ Fin del ciclo while }
clrscr;
end.
------------------------------------------------------------------------------
(
geocities.com/siliconvalley/bridge) (
geocities.com/siliconvalley)