Tutorial Aprender a programar jugando con Pilas Engine

Diapositivas destinadas a dar en clase a alumnos en edad escolar, para enseñar a programar desde cero

Transcript

1. Aprender a programar jugando Con: Carlesso Nicolás carlesson@gmail.com UTN-FRC , Año 2016
2. Licencia Creative Commons Esta obra está bajo una Licencia Creative Commons Atribución- CompartirIgual 4.0 Internacional
3. Capítulo 1 Primera parte de aprender jugando (6 capítulos)
4. ¿Qué es un programa?
5. ¿Qué es un programa? • Secuencia de instrucciones escritas por personas.
6. ¿Qué es un programa? • Secuencia de instrucciones escritas por personas. • Conjunto de operaciones que realizan las maquinas
7. ¿Qué es un programa? • Secuencia de instrucciones escritas por personas. • Conjunto de operaciones que realizan las maquinas • Mediador entre los usuarios y la maquina
8. ¿Qué es un actor dentro de la pilas?
9. ¿Qué define a un actor?
10. ¿Qué define a un actor? • Tamaño
11. ¿Qué define a un actor? • Tamaño • Posición en la pantalla
12. ¿Qué define a un actor? • Tamaño • Posición en la pantalla ATRIBUTOS
13. ¿Qué puede hacer un actor? • Sonreír
14. ¿Qué puede hacer un actor? • Sonreír • Gritar
15. ¿Qué puede hacer un actor? • Sonreír • Gritar • Decir
16. ¿Qué puede hacer un actor? • Sonreír • Gritar • Decir METODOS
17. Iniciando con Pilas
18. Interprete de pilas
19. Ejemplo atributo posición
20. Ejemplo método hablar
21. Salida comando help(mono)
22. Ejercitación Incorporar distintos actores en la misma pantalla en posiciones distintas (que no se superpongan), investigar sus métodos con el comando help y cambiar los tipos de fondos. Tipos de actores posibles: • Aceituna • Banana • Bomba • Manzana • Nave • Ovni • Pacman • Pingu • Pelota • Shaolin • Tortuga • Zanahoria Tipos de fondos posibles: • Césped • Galaxia • Nubes • Noche • Pasto • Tarde
23. Capítulo 2 Primera parte de aprender jugando (6 capítulos)
24. Tipos de datos y Operadores • En el momento en que queramos realizar alguna operación matemática, unir textos o simplemente validar con un si o con un no o un cierto o falso, necesitamos distintos tipos de datos y formas de operar con ellos.
25. Tipos de datos Tipo Clase Ejemplo int Entero 32 str Cadena “Hola Mundo” float Flotante 3.141592 bool Booleano True o False list Lista [4,”Hola”,3.14] dict Diccionario {“10 del Barsa”:”Messi”,”5 del Real”:”Kroos”}
26. Operadores Aritméticos Operador Descripción Ejemplo Resultado + Suma C= 3 + 5 C =8 - Resta C= 4- 2 C =2 - Negación C=-7 C=-7 * Multiplicación C=3*6 C=18 ** Potenciación C=2**3 C=8 / División C=7.5/2 C=3.75
27. Operadores Lógicos Operador Descripción Ejemplo == ¿Son iguales a y b? r = 5 == 3 # r es False != ¿Son distintos a y b? r = 5 != 4 # es True < ¿Es a menor que b? r = 5 <3 # r es False > ¿Es a mayor que ? r = 5 > 3 # r es True
28. Sentencias • Ahora que sabemos de los distintos tipos de datos y operadores. ¿De que forma los podríamos utilizar? Sí un numero es menor a cero (numero<0), es negativo y si no lo es, es cero o positivo. Sí tu nombre es Juan (nombre == “Juan”), entonces tu nota es 7 Sí la bomba está encendida (bomba.encendid a==true), entonces explotará.
29. Sentencia condicional if Es la forma mas simple, viene del ingles, significa sí. ¿Cómo haríamos para saber si un numero es negativo?. Ejemplo: if numero < 0: print “Negativo”
30. Sentencia if …. else Vamos a ver ahora un condicional algo más complicado. ¿Qué haríamos si quisiéramos que se ejecutaran unas ciertas órdenes en el caso de que la condición no se cumpliera? Ejemplo: if numero < 0: print “Negativo” else: print “Positivo”
31. Sentencia if … elif … elif… else Todavía queda una construcción más que ver, que es la que hace uso del elif. ¿Qué pasa en los ejemplos anteriores si queremos saber si es un cero? Ejemplo: if numero < 0: print “Negativo” elif numero > 0: print “Positivo” else: print “Cero”
32. Bucles Mientras que los condicionales nos permiten ejecutar distintos fragmentos de código dependiendo de ciertas condiciones, los bucles nos permiten ejecutar un mismo fragmento de código un cierto número de veces, mientras se cumpla una determinada condición. • while (mientras) • for … in
33. while El bucle while (mientras) ejecuta un fragmento de código mientras se cumpla una condición. Ejemplo: edad = 0 while edad < 18: edad = edad + 1 print “Felicidades, tienes “ + str(edad)
34. for … in Los for se utilizan para recorrer secuencias, por lo que vamos a utilizar un tipo secuencia, como es la lista, para nuestro ejemplo. Ejemplo: secuencia = [“uno”, “dos”, “tres”] for elemento in secuencia: print elemento
35. Actividad: Probar las sentencias y los tipos de datos vistos, realizando una animación en donde aparezcan en pantalla 10 monos que aumenten el doble de su tamaño y vuelvan a su tamaño original, unas 2 veces en 2 segundos cada uno, sin superponerse uno con otro. El método del mono para aumentar su tamaño es: mono.escala = [valor escala inicial, valor escala final], tiempo Nota: No te limites al enunciado prueba cosas, usa tu imaginación, diviértete.
36. Capítulo 3 Primera parte de aprender jugando (6 capítulos)
37. Grupo de Actores • En muchas oportunidades necesitaremos manejar un grupo de actores al mismo, como por ejemplo un grupo de bombas, que podemos hacer explotar al mismo tiempo, un puñado de cajas que caigan encima de algún actor, etc..
38. Creando grupo de actores
39. Creando grupo de actores • A partir de ahora, la referencia bombas nos servirá para controlar a todas las bombas al mismo tiempo. • Esta referencia es parecida a una lista de python normal. Así que podríamos contar cuantas bombas hay en la escena, o recorrer el grupo haciendo algo: >>> print "hay", len(bombas), "bombas" hay 5 bombas >>> for una_bomba in bombas: . print una_bomba.x, una_bomba.y
40. Creando grupo de actores • Ahora bien, algo que hace un poquito diferente a los grupos de las listas de python, es que los grupos te permiten alterar a varios actores al mismo tiempo con mas facilidad. • Por ejemplo, imagina que quieres hacer que todas las bombas aparezcan en el centro de la ventana. Podrías hacer algo cómo esto: >>>bombas.x = 0
41. Creando grupo de actores • Incluso, les podríamos enseñar a las bombas a reaccionar como si fueran pelotas, es decir, que reboten e interactúen con la aceleración gravitatoria: bombas.aprender(pilas.habilidades.RebotarComoPelota) • Ahora tendrás algo mucho mas interesante, un montón de actores rebotando entre sí. **Un consejo, la gravedad del escenario se puede modificar usando una sentencia como la que sigue: pilas.atajos.definir_gravedad(200, 0) donde el primer argumento es la gravedad horizontal, en este caso 200 es hacia la derecha, y el segundo argumento es la gravedad vertical, que suele ser de -90 en general.
42. Creando grupo de actores • Hay ocasiones, donde quieres tener un grupo desde cero e ir agregando actores en él. • Esto se puede hacer fácilmente, e incluso abre las puertas a que puedas mezclar actores de distintas especies. • Para crear un grupo vacío tienes que crear un objeto de la clase Grupo: mi_grupo = pilas.grupo.Grupo() • y luego, para añadir actores al grupo puedes usar el método append e indicar la referencia del actor que quieres agregar: bomba = pilas.actores.Bomba() pelota = pilas.actores.Pelota() mi_grupo.append(bomba) mi_grupo.append(pelota)
43. Actividad: • Recrear el efecto del buscaminas en donde al tocar una bomba con el puntero del mouse y darle clic explotan todas juntas. Nota: No te limites al enunciado prueba cosas, usa tu imaginación, diviértete.
44. Capítulo 4 Primera parte de aprender jugando (6 capítulos)
45. Funciones Definición: es un fragmento de código con un nombre asociado que realiza una serie de tareas y devuelve un valor. • Las funciones se declaran de la siguiente forma: def mi_funcion(param1, param2): print param1 print param2 • Es decir, la palabra clave def seguida del nombre de la función y entre paréntesis los argumentos separados por comas. • A continuación, después de los dos puntos tendríamos las líneas de código que conforman el código a ejecutar por la función.
46. Funciones Para llamar a la función (ejecutar su código) se escribiría: mi_funcion(“hola”, 2) • Es decir, el nombre de la función a la que queremos llamar seguido de los valores que queramos pasar como parámetros entre paréntesis. • La asociación de los parámetros y los valores pasados a la función se hace normalmente de izquierda a derecha: como a param1 le hemos dado un valor “hola” y param2 vale 2, mi_funcion imprimiría hola en una línea, y a continuación 2.
47. Funciones El número de valores que se pasan como parámetro al llamar a la función tiene que coincidir con el número de parámetros que la función acepta según la declaración de la función. En caso contrario Python se quejará: >>> mi_funcion(“hola”) Traceback (most recent call last): File “<stdin>”, line 1, in <module> TypeError: mi_funcion() takes exactly 2 arguments (1 given)
48. Funciones Los valores por defecto para los parámetros se definen situando un signo igual después del nombre del parámetro y a continuación el valor por defecto: def imprimir(texto, veces = 1): print veces * texto • Si no indicamos un valor para el segundo parámetro se imprimirá una sola vez la cadena que le pasamos como primer parámetro: >>> imprimir(“hola”) Hola • Si se le indica otro valor, será este el que se utilice: >>> imprimir(“hola”, 2) holahola
49. Funciones Para definir funciones con un número variable de argumentos colocamos un último parámetro para la función cuyo nombre debe precederse de un signo *: def varios(param1, param2, *otros): for val in otros: print otros varios(1, 2) varios(1, 2, 3) varios(1, 2, 3, 4) **Esta sintaxis funciona creando una tupla (de nombre otros en el ejemplo).
50. Funciones También se puede preceder el nombre del último parámetro con **, en cuyo caso en lugar de una tupla se utilizaría un diccionario. Las claves de este diccionario serían los nombres de los parámetros indicados al llamar a la función y los valores del diccionario, los valores asociados a estos parámetros. • En el siguiente ejemplo se utiliza la función items de los diccionarios, que devuelve una lista con sus elementos, para imprimir los parámetros que contiene el diccionario. def varios(param1, param2, **otros): for i in otros.items(): print i varios(1, 2, tercero = 3)
51. Funciones Veamos un pequeño programa para demostrarlo: def f(x, y): x = x + 3 y.append(23) print x, y x = 22 y = [22] f(x, y) print x, y • El resultado de la ejecución de este programa sería 25 [22, 23] 22 [22, 23]
52. Funciones Veamos por último cómo devolver valores, para lo que se utiliza la palabra clave return: def sumar(x, y): return x + y print sumar(3, 2) • Como vemos esta función tan sencilla no hace otra cosa que sumar los valores pasados como parámetro y devolver el resultado como valor de retorno. • También podríamos pasar varios valores que retornar a return. def f(x, y): return x * 2, y * 2 a, b = f(1, 2)
53. Actividad: • Crear una función que al llamarla, el actor se comporte de distintas formas dependiendo lo que reciba por parámetros. Ejemplo hacer que el mono, grite, hable o salte, dependiendo si recibe, comida, un reto o un saludo. Nota: No utilices el ejemplo del enunciado prueba cosas se creativo, ten en cuenta que esto lo usaras siempre de una forma similar a la planteada en este punto.
54. Capítulo 5 Primera parte de aprender jugando (6 capítulos)
55. Colisiones Definición: Lo que ocurre cuando dos actores entran en contacto. • Por ejemplo, cuando un personaje como Pacman toca a un Fantasma se produce una colisión. Para programar colisiones en pilas tienes seguir unos pocos pasos. • Tienes que pensar “qué” quieres hacer cuando se produce una colisión. • Escribir una función de respuesta a la colisión. • y, por último, decirle a pilas qué actores son colisionables entre sí. **Ten en cuenta que cada actor tiene un atributo llamado radio_de_colision, que se representa como un círculo de color verde cuando pulsas la tecla F12 sobre la ventana.
56. Colisiones • Comencemos con un ejemplo, coloque dos actores en la pantalla de su juego: banana = pilas.actores.Banana() banana.x = 100 mono = pilas.actores.Mono() • Ahora, para poder mover al mono, podemos enseñarle una habilidad: mono.aprender(pilas.habilidades.Arrastrable)
57. Colisiones Ahora vamos a crear una función con lo que queremos que hagan los dos actores al entrar en contacto: def el_mono_come(mono, banana): mono.sonreir() banana.eliminar() y por último crear dos listas de actores y decirle a pilas que asocie la función de mas arriba con la colisión: bananas = [banana] pilas.escena_actual().colisiones.agregar(mono, bananas, el_mono_come) Perfecto. Ahora, si mueves al mono por la pantalla con el mouse, podrá comer bananas.
58. Colisiones • Intenta crear mas actores que representen bananas y agregarlos a la lista que usamos antes, por ejemplo: b = pilas.actores.Banana() b.x = -100 bananas.append(b) • Ahora intenta nuevamente mover al mono... sí, las colisiones seguirán funcionando, cualquier objeto que agregues a la lista de bananas será alimento del mono... • Bien, ¿y si queremos llenar la pantalla de comida?, una forma sencilla es ejecutar lo siguiente: bananas += pilas.atajos.fabricar(pilas.actores.Banana, 20)
59. Actividad: Lograr un juego, como el de los ejemplos, en donde un mono se alimente de las bananas en pantalla y sonría cada vez que se coma una, moviéndolo al mono con el teclado y las bananas estén en suspensión por la pantalla. Nota: No te limites al enunciado prueba cosas, usa tu imaginación, diviértete.
60. Capítulo 6 Primera parte de aprender jugando (6 capítulos)
61. Física • Los actores que tienen física son un poco particulares, pero aún así se los puede tratar como a otros actores.
62. Física Cuando haces juegos con física o movimientos realistas es muy importante tener en algunos conceptos importantes: • Si bien uno observa pelotas y cajas, en realidad, internamente son solo cuadrados y circunferencias. • Lo que ocurre en pantalla son dos cosas, por una lado vemos imágenes con aspecto de caja o pelota, y por el otro se nos oculta una simulación entre polígonos mucho mas primitiva y simple. • Cada uno de esos actores está asociado a una figura geométrica, la física en realidad se da en un nivel muy primitivo de figuras (círculos y cuadrados). **Intenta lo siguiente, agrega actores de todo tipo y pulsa la tecla F11 y observarás varias lineas de color rojo indicando las figuras de los cuerpos. Las lineas rojas indican polígonos que el motor de física puede controlar.
63. Física • Si por algún motivo quieres que los objetos no estén contenidos en la pantalla, y sean un poco mas libres, podrías eliminar las paredes: pilas.escena_actual().fisica.eliminar_paredes() • o incluso podrías eliminar el suelo: pilas.escena_actual().fisica.eliminar_suelo() **Pero recuerda que los objetos que no se ven en la pantalla de todas maneras estarán ahí. Una buena idea es eliminarlos ni bien los dejas de usar.
64. Cambiando la gravedad interactivamente Por defecto, la gravedad del escenario es de (0, -90), esto significa que los objetos “caen” hacia abajo, y lo hacen con una aceleración de 90 mts/s^2 (metros sobre segundos cuadrados). Hay dos formas de cambiar la gravedad del escenario. • Podrías cambiar la gravedad en cualquier momento invocando a la función definir_gravedad indicando la nueva gravedad, por ejemplo: pilas.atajos.definir_gravedad(200, 0) • O directamente especificar la gravedad cuando inicias pilas, por ejemplo: pilas.fisica.definir_gravedad(90, 90) **Ten en cuenta que el primer argumento es la aceleración horizontal y la segunda componente es la aceleración vertical.
65. Actividad: • Utilizando el ejemplo de la vaca voladora disponible en el motor de pilas engine modifica los radios de colisión de los distintos actores (vaca, bomba y estrella) juega con esto y relaciónalo con los niveles de dificultad generalmente incluidos en los juegos que tu conoces. Nota: No te limites al enunciado prueba cosas, usa tu imaginación, diviértete.
66. ¿Preguntas?
67. FIN