Contenidos
CONTENIDOS TEÓRICOS
Bloque 1:
Teoría de la programación
Control neumático e hidráulico: el
compresor, válvulas y el cilindro.
Circuitos.
Bloque 2:
Lenguajes de programación. Realizar programas
en lenguaje GAME MAKER
CONTENIDOS PRÁCTICOS
Realizar y presentar programas interactivos mediante
lenguaje GAME MAKER
CONTENIDOS MÍNIMOS
Saber utilizar el lenguaje de programación
GAME MAKER para realizar programas sencillos.Conocer los símbolos de los principales
componentes de un circuito neumático o
hidráulico.
CRITERIOS DE CALIFICACIÓN
Control escrito sobre los contenidos teóricos
del primer bloque. Tendrá un valor de un 40%
máximo sobre la nota global. Teoría de la
programación 2 puntos. Control Neumático 2
puntos.El resto de los objetivos se valorarán
mediante la presentación de varios programas
informáticos realizado con el lenguaje GAME MAKER.
Estos programas tendrán un valor máximo de un
60% (6 puntos) de la nota total de la
evaluación.
A la suma de estas notas se podrá subir o bajar
un 10% (+- 1 puntos) por la actitud, el comportamiento en el
aula, el enteres, la motivación y la actitud en el aula
clase y de informática, pudiendo llegar a un 20%
(+-2ptos.) en casos excepcionales.
Nota máxima de la evaluación: 10
puntos
Teoría de la
programación
Introducción
El ordenador solo entiende el llamado
código máquina (1 y 0, hay o no hay corriente). Los
lenguajes de programación de alto nivel permiten
dar órdenes al ordenador con un lenguaje parecido al
nuestro (Visual Basic, Pascal, GML, LOGO, C++, etc). El problema
de los lenguajes de alto nivel es que necesitan un compilador o
interprete para traducirlo al código máquina. Hay
otros programas como el GML o el Java que son programas
interpretados, es decir, se analizan y ejecutan las
instrucciones por el propio programa. Los lenguajes más
cercanos al idioma del ordenador, llamados de bajo nivel,
son muy complicados (casi como el código máquina) y
poco usados.
Los lenguajes, como todo, hay que
aprendérselos, pero tienen una ventaja, y es que hay
varios puntos en común.
1. Comentarios
Poner comentarios de lo que vamos haciendo
es muy útil, sobre todo cuando llega la hora de revisar el
programa, si no, más de una vez nos encontraremos diciendo
¿qué hacía esto aquí? No cuesta nada
documentar el programa y nos ahorrará dolores de cabeza.
La norma que seguiremos será poner // delante de los
comentarios, para identificarlos:
// Esto será un comentario y no
hará nada en el programa
2. Las variables
Una variable es como una caja donde metemos
cosas (datos). Estos datos los podemos ir cambiando, ahora meto
un 3 ahora lo quito y meto un 5. Una variable tiene un
nombre, que puede ser una letra, una palabra, varias palabras
unidas por el guión bajo o varias palabras sin separar
pero la primera letra de cada palabra en mayúsculas ejem.:
VidasPerdidas. Las variables también tienen un
valor que sería lo que habría dentro de ella
(en la caja) en ese momento y que puede ir variando
según se vaya desarrollando el programa, por eso se llama
variable.
Una variable dependiendo de su valor puede
ser numérica, si solo puede tener un valor
numérico, de texto, si solo puede contener texto (letra,
palabra o frase (string)). En las variables de texto, su valor
(el texto), debe ir entre comillas, para
diferenciar que el texto es texto y no es el nombre de otra
variable. Hay otras variables que se llaman booleanas que solo
pueden tener dos valores true o false (algunas veces true se
puede sustituir por el 1 y false por el 0). Ejemplos:
Edad=3 //variable
numérica
variableDeTexto= "Edad"
variableNumerica=Edad+2 //su valor es el
valor de la variable Edad (numérica) +2; en este caso
sería=5
variableBooleana=true; podría ser
1
Lo normal es declarar las variables al
principio de un programa. Declarar no es más que decir
"mira, yo quiero tres variables, y quiero que una se llame
Nombre, otra Edad y otra Apellido". A partir de este momento,
podrás meter, por ejemplo, "Juan" en Nombre, un 5 en Edad
y "Rodríguez" en Apellido. Ojo no es la misma variable
Nombre que nombre.
Las variables se suelen declarar al
principio del programa. ¡OJO! En GML no hace
falta).
NUMÉRICA: Pepe //declaramos la
variable Pepe. En GML no hace falta.
Pepe = 14 //Damos un valor a la variable ya
declarada Pepe;
Pepe = 42 // Cambiamos el valor d la
variable a 42;
Fijate que ponemos ; antes de pasar
a la siguiente instrucción. Esto siempre se debe hacer
así.
Podemos sumar, restar, multiplicar y
dividir variables.
NUMÉRICA: Pepe, Mari ,Juan
//Declaramos las variables que usaremos;
Pepe=2;
Mari=3;
Juan =Pepe+Mari; // Juan tiene el valor
numérico de 5
Hay variables ya definidas
por el propio lenguaje de programación que usemos, y cuyo
nombre no se lo podremos dar a ninguna de las que nosotros
definamos. Las podemos usar pero tal y como el lenguaje las
definió. Por ejemplo en GML mouse_x es la variable
que tiene el valor de la posición x del ratón en
cada momento, hspeed es la velocidad horizontal,
etc.
Si queremos que la variable se use en todo
el programa deberemos nombrarla como una variable global,
en caso contrario variable local, la variable al salir del
lugar donde le hemos asignado un valor, perderá ese valor
y ya no existirá (al salir de un algoritmo, trozo de
programa, del objeto, de una estructura IF, etc). En GML
se pone la palabra global. Y detrás el nombre de la
variable, de esta forma servirá para el programa entero.
Ejemplo global.pepe, que será distinta de la
variable pepe.
3. Programas y Algoritmos
Los lenguajes de programación,
cuentan todos en su haber con un juego de "instrucciones". Una
instrucción no es más que una orden que nosotros le
damos a la máquina.
Y es que, al fin y al cabo, un
PROGRAMA no es más que una secuencia de
instrucciones (escritas en algún lenguaje de
programación) pensado para RESOLVER algún tipo
de PROBLEMA. Si no sabemos resolver este problema, no
podremos escribir el programa.
A ti se te puede ocurrir una manera de
resolverlo, a tu compañero, otra. Este METODO con
el que resolvéis el problema, es lo que se llama
ALGORITMO, y es lo que vamos a ver a
continuación.
Un algoritmo es una secuencia de
PASOS a seguir para resolver un problema.
Por ejemplo, cuando quiero ver una
película de vídeo, podría hacer:
Elijo una película de las de mi
colección.
Compruebo SI TV y vídeo están
conectados a la red (y procedo).
SI la TV está apagada, la enciendo,
SI NO, pues no. Y lo mismo con el vídeo.
Introduzco la película en el
vídeo. Dejo el estuche sobre el vídeo.
SI la TV no está en el canal
adecuado, la cambio, SI NO, pues no.
Cojo los mandos a distancia (el del TV y el
del vídeo).
Me pongo cómodo.
Pulso PLAY en el mando del
vídeo.
Fijaos bien en unos detalles que son
fundamentales y que aparecen en este algoritmo:
– La descripción de cada paso no me
lleva a ambigüedades: los pasos son absolutamente
explícitos y no inducen a error.
– El número de pasos es finito.
Tienen un principio y un fin. Según lo visto una mejor
definición de algoritmo sería:
"Un algoritmo es una sucesión
finita de pasos (no instrucciones como en los
programas) no ambiguos que se pueden llevar a cabo en
un tiempo finito."
Hay distintas formas de escribir un
algoritmo, bien usando un lenguaje específico de
descripción de algoritmos, bien mediante representaciones
gráficas: diagramas de flujo. Nosotros vamos a usar
un lenguaje llamado pseudocódigo, y a la vez
pondremos también las instrucciones que se deberían
poner en el lenguaje de programación GML.
Según avancemos haremos solo programas en GML (que es lo
que finalmente nos interesa).
Independiente del lenguaje de
programación que vaya a usarse; un algoritmo que
esté escrito en pseudocódigo o con un diagrama de
flujo es fácilmente traducible a muchos lenguajes de
programación.
Ejercicio: Crea el diagrama de flujo
para ver la película del algoritmo anterior
(inteligencia artificial).
4. Estructuras de control
Las estructuras de control tienen una
finalidad bastante definida: su objetivo es ir señalando
el orden en que tienen que sucederse los pasos de un algoritmo o
de un programa.
Las estructuras de control son de tres
tipos:
4.1. Secuenciales
4.2. Selectivas
4.3. Repetitivas
4.1.Estructuras
secuenciales
Una estructura de control secuencial, en
realidad, no es más que escribir un paso del algoritmo
detrás de otro, el que primero que se haya escrito
será el que primero se ejecute. Veamos un ejemplo:
queremos leer el radio de un círculo, calcular su
área y mostrar por pantalla al usuario el
resultado.
Declaración de variables
REAL: radio, area // No se suele poner
acentos, y menos en órdenes de programas.
fin declaración de
variables
inicio
mostrar por pantalla "dame el radio
del circulo"
leer del teclado la variable radio
//asignación del valor de la variable
radio
area =3.14159*radio //asignación del
valor de la variable área
mostrar por pantalla "el área del
circulo es:" //En los texto SI SE PONEN ACENTOS
mostrar por pantalla el contenido de la
variable area
fin
4.2.Estructuras
selectivas
Estas estructuras se utilizan para TOMAR
DECISIONES (por eso también se llaman estructuras de
decisión o alternativas). Lo que se hace es EVALUAR una
condición, y, a continuación, en función del
resultado, se lleva a cabo una opción u otra.
4.2.1 Alternativas simples (condicional
IF)
Son los conocidos "si… entonces". Se usan
de la siguiente manera: yo quiero evaluar una condición, y
si se cumple (es decir, si es cierta), entonces realizaré
una serie de pasos.
En pseudocódigo
sería:
Declaracion de variables
REAL: numero, raiz
fin declaracion de variables
inicio
mostrar por pantalla "introduce un
numero"
leer del teclado la variable
numero
SI numero>=0
ENTONCES:
raiz=raiz_cuadrada(numero)
mostrar por pantalla "la raíz
cuadrada es:"
mostrar por pantalla raiz
fin del SI
fin
En GML sería ( recuerda no hace
falta declarar las variables al principio):
numero = get_integer ("Introduce un
número",0) ;
if (numero>=0)
{raiz=sqrt(numero)};
draw_text(50,50,"La raíz cuadrada es
" + string (raiz));
game_end();
Nota: en GML tendríamos que
poner las órdenes para un objeto y dentro de uno o
varios eventos (eventos create y draw)
4.2.2 Alternativas dobles
(IF…….ELSE….)
¿Qué pasa si no cumple la
condición puesta?. Si no decimos nada el programa
seguirá a la siguiente orden de forma secuencial.
Pero también podemos especificar que pasaría si no
cumple la condición. Es el famoso trío "si …
entonces … sino esto otro". En GML sería:
if (condicion) {se hace esto} else {si
no cumple la condición se hace esto otro}
En el ejemplo anterior sería mucho
mejor hacerlo con este tipo:
En pseudocódigo:
Declaracion de variables
¿Cómo sería el programa en
GML?
REAL: numero, raiz
fin declaracion de variables
inicio
mostrar por pantalla 'introduce un
numero'
leer del teclado la variable
numero
SI numero >= 0 ENTONCES:
raiz = raiz_cuadrada(numero)
mostrar por pantalla 'la raiz cuadrada
es:'
mostrar por pantalla raiz
SI NO es numero >=0 ENTONCES: {es decir,
si numero es negativo}
mostrar por pantalla 'lo siento, no puedo
calcular la raiz cuadrada de un numero negativo'
fin del SI
fin
4.2.3 Alternativas múltiples o
con varias condiciones
Es muy probable que tengamos la necesidad
de incluir en nuestros programas alternativas con muchas opciones
posibles. En GML sería:
variableOpciones= un valor a elegir, por
ejemplo desde el teclado o desde una ventana que
marque
el usuario
if (variableOpciones=0) {lo que
corresponda};
if (variableOpciones=1) {lo que
corresponda}; ……….
También existe la posibilidad de que
deban de cumplirse dos condiciones a la vez:
if (condición1 &&
condición2) {Se cumple esto} o
if (condición1 &&
condición2) {Se cumple esto} else {se cumple esto
otro}
Ejercicios en el cuaderno
Para hacer estos ejercicios en
pseudocódigo no declararemos las variables al
principio tal y como se hace en GML, aunque teóricamente
tendrían que declararse
Sobre estructuras secuenciales
1. Escribid un algoritmo que calcule el
área de un triángulo o de un
rectángulo.
2. Escribid un algoritmo que calcule el
precio de un artículo tras aplicarle un 16% de
IVA.
Sobre estructuras selectivas
3. Diseñad un esquema de menú
de opciones, por ejemplo, un menú para seleccionar un
libro a leer de
entre 3 disponibles.
4. Escribid un algoritmo que lea tres
números e imprima por pantalla el mayor de
ellos.
4.3. Estructuras de control
REPETITIVAS
Estas estructuras son instrucciones que se
repiten formando un bucle. El bucle se repite mientras se
cumpla una condición que ha de ser especificada
claramente. Cuando deje de cumplirse la condición, se
sale fuera del bucle y no se repiten más las
instrucciones.
Un BUCLE (loop, en inglés) es un
trozo de algoritmo o de un programa cuyas instrucciones son
repetidas un cierto número de veces, mientras se cumple
una cierta condición que ha de ser claramente
especificada
Básicamente, existen tres tipos de
estructuras repetitivas:
4.3.1 Los bucles "mientras…" o
"while"
4.3.2 Los bucles "repetir(hacer)…
mientras que" o "do… until" y
4.3.3 Los bucles "desde" o "bucles
for".
4.3.4 Otras.
Vamos a verlas todas dentro de un ejemplo.
El ejemplo es el siguiente:
Vamos a suponer que estamos pensando en un
programa que deba REPETIR algunas veces una acción. Por
ejemplo, el ordenador se ha portado mal, y como castigo, le vamos
a hacer imprimir por pantalla 3000 veces la frase "Prometo ser
bueno". ¿Cómo lo hacemos? ¿Escribimos 3000
veces la instrucción pertinente? ¡Se supone que el
castigo es para la máquina, no para uno mismo!.
4.3.1 Estructura
MIENTRAS(condición) o "WHILE"
En este tipo de estructura, el cuerpo del
bucle (ya sabéis, las acciones que deben ejecutarse
repetidas veces) se repite MIENTRAS se cumple una determinada
condición, que especificamos entre
paréntesis
Pseudocódigo
inicio
contador=1
Mientras (contador<=3.000)
hacer
mostrar por pantalla 'Prometo ser
bueno'
contador=contador+1
fin mientras
fin
En GML sería (dentro del
evento dibujar)
contador=1
while (contador<=3000)
{
draw_text (50,50,"Prometo ser
bueno");
contador+=1;
} //Escribiría todas las frases en
el mismo lugar
(50,50) una encima de otra.
A la variable que "lleva" la cuenta de las
veces que el bucle se ha ejecutado, se le he llamado
contador.
Fijarse que ANTES de entrar en el bucle
le asigno el valor 1 a la variable contador. Si no, al entrar
en el bucle y la variable (contador) no tener valor, me
saldría error (en GML ni siquiera existiría la
variable).
En cuanto vemos la palabra "mientras" o
"while", ya sabemos que hemos entrado en el bucle. Estamos en la
decisión. ¿Es contador<=3000? Yo creo que
sí, al menos si es cierto que 1<=3000.
Vale, es cierto, así que deben
ejecutarse todas las instrucciones del cuerpo del bucle. En
nuestro caso, se mostrará por pantalla la frase 'Prometo
ser bueno', y, ATENCION, sumo 1 a la variable
contador. Como contador valía 1, si ahora le sumo 1,
ahora contador vale 2. Llegamos al fin del mientras. Eso
significa que se han terminado las instrucciones del cuerpo del
bucle: debemos volver a evaluar la condición que
tenía el "mientras" o "while" entre paréntesis para
ver qué hacemos ahora.
Tenemos que ver si contador<=3000.
Ahora, contador valía 2, y se cumple que 2<=3000, con
lo que vuelve a mostrarse por pantalla la expresión
'Prometo ser bueno' y de nuevo se suma 1 a contador, con lo que
ahora, contador pasa a valer 3. De nuevo llegamos al fin del
mientras. [… un buen rato después…]. Ahora contador
vale 3000. Tenemos que ver si contador<=3000. Como es cierto
que 3000<=3000, se muestra por pantalla el mensaje 'Prometo
ser bueno', y sumamos 1 a contador. Ahora, contador vale 3001.
Llegamos (una vez más) al fin del mientras, por lo que
tenemos que volver a evaluar la condición entre
paréntesis que acompaña al "mientras". Hay que ver
si contador<=3000. Pero no es cierto que 3001<=3000, es
más bien al revés, o sea, la
condición entre paréntesis ES FALSA.
¿Eso qué quiere decir? Pues quiere decir que se
acabó, que ya no se ejecuta el cuerpo del bucle, sino que
hemos llegado al final, el bucle a terminado y salimos fuera
de el.
¿Qué pasaría si la
variable contador, al definirla, su valor fuera ya
mayor de 3000?.
Pues que el bucle no se ejecuta ninguna vez
. Esto puede tener aplicación en algunos casos.
4.3.2 Estructura REPETIR (hacer)…
MIENTRAS QUE (condición) o "DO…..UNTIL"
Aquí, lo que se desea es que un
bucle se ejecute al menos una vez antes de comprobar la
condición de repetición. Es decir si
partiéramos que la variable condición fuera mayor
de 3000, en este caso, el bucle se ejecutaría una vez.
En el caso de hacerlo con while no se ejecutaría ninguna
vez. ¡Esta es la única
diferencia¡.
La estructura PARA NUESTRO EJEMPLO es
esta:
inicio
Contador=1
Repetir
mostrar por pantalla 'Prometo ser bueno
O:-)'
Contador=Contador+1
mientras que(Contador<=3000)
fin
En GML sería:
Contador=1
do
{
draw_text (50,50,"Prometo ser
bueno");
Contador+=1;
}
until (Contador<=3000);
4.3.3 Estructura DESDE o "bucles
FOR".
Esta estructura hubiera sido la
más adecuada para resolver nuestra situación
real. Tiene la peculiaridad, que la variable contador esta
dentro del bucle y no hace falta asignarle el valor (ni
definirla) fuera del bucle, y además, al llegar el
programa al bucle siempre se realizarán las
instrucciones que hay dentro del bucle, una cantidad de veces que
nosotros fijemos.
inicio
desde contador=1 hasta
contador<=3.000 contador=contador+1 hacer
mostrar por pantalla 'Prometo ser
bueno'
fin desde
fin
Lo primero que hace es darle a la variable
contador el valor 1. Después comprueba si el valor de la
variable es menor o igual a 3000 (comprueba la condición),
y si la cumple aumenta 1 el valor de la variable contador y
realiza las instrucciones que hay dentro del bucle. Así
hasta que la condición deja de cumplirse. En GML
sería:
for (contador=0; contador<=3000;
contador+=1) {
draw_text(50,50*contador,"Prometo ser
bueno");
} //Lo que se repite del bucle va entre
{}
Nota: Las coordenadas "y", en este
caso, varían con la variable contador (50*contador) y
así las frases no se juntan una encima de otra, salen en
diferentes coordenadas, en nuestro caso diferentes
filas.
Normalmente con bucles For se usa la
variable i para contar, y no la variable contador:
for (i=0; i<=3000; i+=1)
{draw_text(50,50*i,"Prometo ser bueno")}
Ejercicio: Programa en GML que
escriba los números del 1 al 10, con while, con
do….until y con FOR .
4.3.4 Otras
Variables "Acumuladores"
Son como las variables contador, con
la diferencia que su incremento/decremento es variable
(varía según el valor de i). Se hacen mediante
ciclos for de la siguiente forma:
acumulador=1
{ for (i=0; i<=10; i+=1) {
acumulador=acumulador+i //Aumenta el valor en i cada
vez que llega aquí;
draw_text(50,50*i,acumulador); } }
// El resultado sería 1 2 4 7 11 16 22
……
Programando con Game
Maker Lenguaje
Game maker es un programa que nos permite
realizar programas en su lenguaje de programación. La
programación que se realiza es una
programación que se llama orientada a
objetos (OOP) y que es la más usada en estos momentos
por todos los lenguajes de programación. Este tipo de
programación considera el programa como un conjunto de
objetos que interaccionan entre si. A los objetos de
los programas les suceden cosas que llamaremos
eventos (colisionar, cuando se crea el objeto, cuando se
aprieta un tecla, etc) y cuando le suceden estos eventos los
objetos realizan determinadas acciones. Por ejemplo cuando
dos objetos colisionan (evento) suena un sonido de choque
(acción), aprieto la tecla fin (evento) y se acaba el
programa (acción). Un objeto puede tener distintas
instancias de ese objeto dentro de un programa. Por ejemplo,
del objeto pelota podemos tener una copia (instancia) en
un sitio y otra en otro sitio diferente del programa (dos
instancias de un mismo objeto, del objeto pelota).
En GM veremos que también que se
puede programar (mas bien ayudar) sin saber el lenguaje de
programación GML, mediante la técnica D&D
(arrastrar y soltar iconos). Nosotros mezclaremos los dos
tipos.
Un programa consiste en un conjunto
de instrucciones. En GM los "iconos" en realidad representan
instrucciones en GML, por ejemplo :
Las piezas de código (incluso los script)
se añaden dentro de un evento de un objeto, y son
consideradas como una acción que se realizará en
ese evento, pudiendo así mezclar GML con el GM de
D&D que es realmente la gran utilidad de Game
Maker.
¿Que es un sprite? es una
simple imagen, puede ser un personaje un objeto, cualquier cosa,
entonces en el sprite no se PROGRAMA nada, simplemente es la
imagen de un posterior objeto del juego. En la carpeta sprite se
añaden todas las imágenes (sprites) que vayamos a
utilizar en nuestro programa.
¿Qué es un objeto?
Todos los elementos que intervienen en el programa (si son
gráficos serán imágenes que tendrán
un sprite como referencia). Un objeto puede tener varias
instancias en el programa (varias veces el mismo objeto) Sobre
los objetos se programan los eventos que van a ocurrir
sobre ellos y sus correspondientes acciones. Hay
objetos que no necesitan sprite.
Sounds: carpeta donde se ponen los
sonidos que se vayan a utilizar durante el programa.
Baqkgrounds: carpeta donde se ponen
los fondos que vayamos a utilizar en el programa.
Rooms: GM llama a las diferentes
pantallas que van a ir pasando durante el desarrollo del programa
ROOMS (habitaciones=niveles=pantallas). Como mínimo un
programa debe tener una room, si no, no se podrá
ejecutar.
Scripts: Para crear trozos de
programas en GML (game maker lenguaje)//Mejor con piezas de
código.
Fonts: son las fuentes para utilizar
en nuestro programa.
Paths: caminos que podemos hacer que
los recorran los objetos. Cerrados o abiertos y de ida o ida y
vuelta.
Time lines: Programar el movimiento
de un objeto en steps. Por ejemplo 0-10 step mueve drcha. 10-50
izquierda, del 50-100 cambia dirección. El objeto se
moverá así cuando se active el Time Line. 30
steps aproximadamente 1 segundo
Global Game Settings Aquí se
pueden configurar todas las opciones del juego
Game Information: seria como una
ventana que se puede abrir durante el juego, donde por ejemplo
puedes poner los controles de la ayuda, creador del programa,
etc. La instrucción para que salga la ventana de
información sería: show_info()
Nosotros los sprites, los objetos, las
habitaciones y los eventos (y más cosas como veremos) los
crearemos con el programa sin necesidad de tener que escribirlo
en GML. Esto nos facilitará mucho el trabajo, aunque si
quisiéramos podríamos hacer programas solo en GML.
Nosotros prácticamente lo que haremos será
escribir en GML las acciones que se realizarán en los
eventos que les ocurra a los objetos, es decir
añadiendo piezas de código.
¡OJO! draw es un evento del tipo
step es decir, lo que se ponga dentro de este evento se
realiza cada step o paso del programa (por defecto 30 step por
segundo). Se realizaría 30 veces cada segundo. Hay un
evento llamado step o paso y que se usa normalmente
cuando queremos que algo se tenga en cuenta o el programa lo este
mirando, o realizando continuamente durante la ejecución
del programa. (Por ejemplo una IF). Lo entenderemos mejor con un
ejemplo de la función random:
La función
random
random(x) Devuelve un numero al azar
entre el rango 0 y x. El numero siempre es menor que x. Si no
queremos que pueda ser 0, pondremos random(x)+1.
Práctica 2: escribiremos en el evento
create:
numeroAleatorio=random(5) //al crearse el
objeto se elije un número aleatorio entre 0 y 4,99 (dos
decimales)
En el evento Draw ponemos
draw_text (50,50, numeroAleatorio) //Nos
dibuja en pantalla el número elegido.
El evento create es para decirle al
programa las acciones que pasarán cuando se cree el
objeto.
En el ejemplo hemos puesto que cuando se
cree el objeto se elija un número aleatorio entre 0 y 5,
pero solo lo realizará una vez, cuando se cree el
objeto. Seguidamente el programa dibujará el valor de
la variable escogida por el programa de forma aleatorio en el
evento create, pero que al ser siempre el mismo valor, siempre
estará dibujando el mismo número.
Si todas las órdenes las
hubiéramos puesto dentro de draw el programa no
acabaría nunca, estaría eligiendo números
aleatorios continuamente (En la Práctica 1 lo
probaremos).
La intrucciones de dibujar o draw,
por ejemplo draw_text, solo se pueden poner dentro del evento
draw.
numeroAleatorio=round(random(5)) //round es
redondear. Esto se pone si queremos que nos redondee el
número y no salga con decimales (si el decimal es mayor de
5 redondea hacia arriba).
Vayamos al aula de informática a
practicar. Crea una room y un objeto sin sprite. Añade el
objeto en la room. Añade los eventos Create y el Draw para
el objeto sin sprite y añade una pieza de código en
cada evento y realiza la práctica 1.
Práctica 1:
1ª parte) Función
random: crea el ejemplo de la función random para
números enteros y otro para dos decimales. Prueba a poner
todas las instrucciones en el evento draw y verás como se
repite el programa indefinidamente. Crea un programa en el que
salga una ventana y puedas introducir el número
máximo aleatorio entre los que tenga que elegir el
programa.
2ª parte) Programación
secuencial: a) Haz un programa que calcule el
área de un triángulo (o cualquier otra
fórmula) y
b) otro para que calcule el precio
final de un producto si le añadimos el IVA.
3ª parte) Programación
selectiva y repetitiva (estructuras de control): a)
Crea un programa para cada uno de los ejemplos que utilizamos
para estudiar las estructuras de control selectivas (raíz
cuadrada) y repetitivas (frase que se repite pero solo 3 veces,
programa que escriba los números del 1 al 10 y el ejemplo
de acumuladores) . b) Crea un programa que lea tres
números e imprima por pantalla el mayor de ellos.
c) Crea un programa que te de 3 opciones de
elección de 3 números. Si escribes 1 hará
una cosa, si escribes 2 otra y si escribes 3 otra diferente
(ejemplo el de elegir libros hecho en el cuaderno). d)
Práctica creando programas con estructuras de control que
se te ocurran y pruébalas (por ejemplo un programa
en el que podamos elegir la fórmula a calcular entre
varias).
Las variables suelen ponerse en el evento
create. ¡CUIDADO! o el programa podría
repetirse continuamente sin parar.
Si la elección aleatoria que
queremos es entre varias palabras en lugar de random se utiliza
choose
Ejemplo choose ("hola","adios")
//elegirá de forma aleatoria hola o adios.
Práctica 2: a)
Añade un sprite. Añade un objeto con ese sprite.
Añade una room con dos instancias de los objetos
(fíjate en el id de las instancias como es diferente). En
el evento create del objeto añade la orden anterior. Ahora
borra la orden anterior y pon solo vspeed=random(8)
¿Qué sucederá?. Prueba con hspeed. c)
Crea un programa para que elija un nombre aleatorio
La función repetir y crear una
instancia de un objeto con GML
repeat (Nºdeveces) instr.;
donde instr. son las instrucciones que tiene que repetir
(Nºdeveces):
Por ejemplo para crear una instancia de un
objeto con GML se hace:
instance_create(x,y,nombreDelObjeto)
repeat (5)
instance_create(random(400),random(400),ball); //crea cinco
instancias del objeto ball en posiciones aleatorias de X y de
Y.
Práctica 3: Añade dos
instancias mediante GML, y en posiciones aleatorias, del objeto
del ejercicio anterior (al final quedarán 5 instancias del
objeto)
¡OJO! Repeat (5) draw_text
(random (500),50,"hola") Si esta instrucción la pongo en
el evento draw se estaría repitiendo continuamente por
estar en un evento del tipo step (pruébalo). Si la
instrucción la pongo en el evento create no se
vería por que los textos solo se ven si están
dentro del evento draw. Entonces ¿Cómo
harías si queremos ver la palabra hola en sitios
aleatorios y repetida 5 veces?. (pista: ciclo FOR)
Mover una instancia
La función hspeed es para dar
velocidad horizontal, y la vspeed vertical. Si quiero
mover solo una instancia de un objeto tendré que hacerlo
como hicimos anteriormente o también crear la instancia
mediante GML y asignarle un nombre de una variable. Finalmente
mover la variable que se le asigna a la instancia.
Ejemplo:
n=instance_create(200,100,objeto1);// a partir de ahora
n es la instancia del objeto1
Ahora ponemos la instancia, punto y seguido y la
función de movimiento:
n.vspeed=8 o n.hspeed=3 y se movería
verticalmente. Si ponemos las dos velocidades para una instancia
se moverá en diagonal.
Esto se puede hacer también con los objetos. Si
ponemos: nombreDelObjeto.funciónPredefinida
afectará a todas las instancias de ese objeto.
Si queremos mover las instancias de un objeto hacia
un punto determinado y con una velocidad determinada
tendríamos que poner la secuencia siguiente:
move_towards_point(x,y,velocidad)
//Mueve la/s instancia con velocidad indicada hacia el punto x,y,
partiendo del lugar donde se encuentre inicialmente.
velocidad será la velocidad a la que se
moverá. ¡¡OJO¡¡Esta orden se
debe poner dentro del evento create del objeto y
moverá todas las instancias que posteriormente
creemos.
Práctica 4: Mueve cada
instancia de la práctica 3 de una forma diferente: una en
horizontal, otra en vertical, otra en diagonal y la otra a un
punto cualquiera. La 5ª instancia muévela usando
instance id[4]
Borrar una instancia
Tendríamos que poner
instance_destroy() dentro del evento que provocaría
la destrucción. Ojo si no especificamos se
destruirán todas las instancias del objeto.
Práctica 5: Borra solo una
instancia de las de la práctica 5. Ahora destruye
todas.
Escribir texto con el
GML
draw_text(x,y,string) Dibuja
string (texto o el valor de una variable) en
posición (x,y).Si el string es un texto debe de ir
entre comillas "", si es una variable no se ponen comillas.
Si quiero unir variables con texto en una frase
sería:
draw_text(10,20,"texto"+string(variable))
El carácter # indica una línea
nueva ( Utiliza # para dibujar el símbolo
#).
draw_text_ext(x,y,string,sep,w)
Similar a la anterior, pero puedes especificar un par de
argumentos mas. sep indica la separación entre renglones.
Si en valor de sep ponemos -1 el programa
elegirá la separación en función del
tamaño de la letra (por ejem. 20 para fuente de
tamaño 12). w indica el ancho del texto en pixeles.
Esto se usa cuando queremos especificar el ancho que debe ocupar
un texto como máximo. El programa al llegar a este ancho
(w) dividirá el texto en dos frases.
En GM hay muchos colores ya definidos
c_blue,c_red;c_blue,c_white….Pero también podemos
crear nosotros los colores. Con la siguiente orden
se crea un color:
make_color_rgb(red,green,blue) El
color obtenido según lo indiquen sus argumentos. red
(rojo), green (verde), y blue (azul). El valor debe estar entre 0
y 255. Lo normal es crear un color con un nombre por ejemplo
escribir:
color1=make_color_rgb(123,234,0).
Si quisiera dar color a un texto, dibujo,
etc, haríamos:
color1=make_color_rgb(240,24,24);
//Definimos un nuevo color
draw_set_color(color1) ; //todo lo
que hagas a partir de esta instrucción lo hará
con este color (escribir, dibujar. etc)
Para cambiar la fuente tenemos primero que
meter la nueva fuente en nuestro programa (en la carpeta Fonts
eligiendo su tamaño y tipo) para que esta fuente
exista. La seleccionamos y la ponemos un nombre. Seguidamente
damos la orden de escribir con la nueva fuente, que es
draw_set_font(Nombredelafuente) Si en vez de poner el
nombre de la fuente ponemos -1 se seleccionara la fuente inicial,
que es arial 12.
Estas instrucciones solo las reconoce el programa
dentro del evento draw.
Práctica 6: Crea un evento
draw con un objeto (sin sprite), y dentro de este evento, pon una
pieza de código en la que pongas las instrucciones para
escribir una frase en dos renglones diferentes mediante la
instrucción siguiente: draw_text_ext(), prueba con varios
w diferentes. Ahora añade una nueva fuente de
tamaño + grande y pon la frase anterior con esa misma
fuente y de color verde. Haz que el programa elija el color de
forma aleatoria.¡¡OJO¡¡Comprobaras
como lo que hay en el evento Draw se repite cada step, por eso el
color con random cambiara el color del texto en cada step si lo
ponemos dentro del evento draw. Usa sleep
(milisegundos) para que sea mas lento el cambio, por ejemplo
sleep(1000) espera 1 segundo hasta que realiza la siguiente
instrucción. Por último haz que el color elegido
por el ordenador permanezca siempre el mismo.
Dibujar con GML
background_color =color El color
puede ser uno definido o una variable que defina el color.
Además esta orden se puede poner en el evento
create.draw_point(x,y) Dibuja un punto en (x,y).
draw_line(x1,y1,x2,y2) Dibuja una
linea desde (x1,y1) hasta (x2,y2).
draw_rectangle(x1,y1,x2,y2,outline)
Dibuja un rectángulo. outline indica si debe dibujar
solo el borde(1) o si lo debe dibujar
relleno(0).outline es igual para todas las demás
figuras.
draw_roundrect(x1,y1,x2,y2,outline)
Dibuja un rectángulo redondeado.
draw_triangle(x1,y1,x2,y2,x3,y3,outline) Dibuja un
triángulo.
draw_circle(x,y,r,outline) Dibuja un
círculo en posición (x,y) con radio r
draw_ellipse(x1,y1,x2,y2,outline) Dibuja una
elipse.
draw_arrow(x1,y1,x2,y2,size) Dibuja
una flecha desde (x1,y1) hasta (x2,y2). size indica el grosor de
la flecha en pixeles.
Para poner el color de relleno se debe de
poner antes de dibujar la figura el color mediante
draw_set_color(color), como ya vimos.
Prácticas:
– 7) Dibuja un rectángulo relleno con un
color creado por ti. Crea otras formas con colores.
– 8) Pon un color de fondo en la room y crea con
líneas una tabla de 2 columnas y 3 filas.
Funciones
matemáticas
3*4 multiplica 3 por 4 5/7
divide 5 entre 7
sqrt(x) raíz cuadrada de x.
abs(x): Valor absoluto de x
power(x,n) Opera x a la potencia n.
sin(x) Opera el seno de x (x en radianes).cos(x)
Opera el coseno de x (x en radianes) tan(x) Regresa el
tangente de x (x en radianes). degtorad(x) Calcula grados
a radianes. radtodeg(x) Calcula radianes a
grados.
Página siguiente  |