pacman 0.003 - Controlando nuestro pacman

código pacman

Vamos a modificar nuestro juego Pacman para que el muñequito sea controlado por teclado. Además, para que no huyan los muñecos, limitaremos su movimiento a las dimensiones de la pantalla.

Como iremos introduciendo lógica particular para nuestro pacman, crearemos una clase específica para él. La nueva clase se llama "Pacman" y heredará de la clase "MiSprite". Por lo pronto, lo único que haremos es que en la función "update" trate los eventos de teclado y cambie la dirección del muñequito.

class Pacman ( MiSprite ):
 def __init__(self, fichero_imagen, pos_inicial):
     MiSprite.__init__(self, fichero_imagen, pos_inicial, [0,0])

 def update (self):
     global eventos
     v = 1 #velocidad a la que se mueve nuestro pacman
     for event in eventos:
         if event.type == pygame.KEYDOWN:
             if event.key == pygame.K_LEFT:
                 self.velocidad[0] = -v
                 self.velocidad[1] = 0
             elif event.key == pygame.K_RIGHT:
                 self.velocidad[0] = v
                 self.velocidad[1] = 0
             elif event.key == pygame.K_UP:
                 self.velocidad[1] = -v
                 self.velocidad[0] = 0
             elif event.key == pygame.K_DOWN:
                 self.velocidad[1] = v
                 self.velocidad[0] = 0
             elif event.key == pygame.K_SPACE:
                 pass

     MiSprite.update(self)

Ya ves, muy sencillo, vemos si se produce un evento de tecla pulsada, comprobamos la tecla y si la tecla es de una de la de movimiento de cursor, cambiamos la dirección de nuestro pacman.

Además, vamos a modificar la función "update" de la clase "MiSprite" para que los muñecos no salgan fuera de nuestra pantalla.

class MiSprite ( pygame.sprite.Sprite ):
....
def update (self):
     self.rect.move_ip(self.velocidad[0],self.velocidad[1])
  
     screen = pygame.display.get_surface ()
      
     if self.rect.top < 0:           
          self.rect.top = 0
          self.velocidad[1] = 0
     elif self.rect.bottom > screen.get_height():
          self.rect.bottom = screen.get_height()
          self.velocidad[1] = 0
          
      if self.rect.left < 0:
          self.rect.left = 0
          self.velocidad[0] = 0
      elif self.rect.right > screen.get_width():
          self.rect.right = screen.get_width()
          self.velocidad[0] = 0

No creo que haga falta comentar el código, es también muy sencillo. Se comprueba si el rectángulo de la imagen desborda algún lado de la pantalla y si es así, la modificamos para que no se salga de la pantalla.

Para la próxima entrega haremos que nuestro pacman pueda comer determinados objetos del juego.

Pacman 0.002 - Los eventos

código pacman

Continuando con nuestro juego en Python, vamos a introducir el manejo de eventos. Los eventos son desde cambio de la ventana hasta teclas pulsadas, pasando por movimiento del ratón. Para hacernos una idea de los tipos de eventos, lo que vamos hacer es simplemente capturarlos y mostrarlos en pantalla. Para probarlo, ejecuta el juego y pulsa teclas, mueve el ratón, etc.

En la primera versión de nuestro pacman, parecía que nuestro juego se quedaba "colgado". Esto se debe a que no procesábamos los eventos.

Los eventos van quedando almacenados en una cola, a la espera de que los procesemos. Para recuperar todos los eventos empleamos la función "pygame.event.get()" que devuelve una lista con todos los eventos y los elimina de la cola original. Esto lo haremos en todas las iteraciones del bucle principal de nuestro programa.

  while True:
     eventos = pygame.event.get()
     ManejarEventos ()
 
     sprites.update ()
     sprites.clear (screen, background)
     pygame.display.update (sprites.draw (screen))

     reloj.tick (60) #tiempo de espera entre frames

A continuación, en nuestro ejemplo, vamos a llamar a la función "ManejarEventos()" que lo único que hace es mostrar en pantalla el tipo de evento y además chequea si se produce el evento de tipo "Quit" que da por terminado el juego. Este tipo de evento se produce por ejemplo cuando pulsamos sobre la "X" de la ventana para cerrarla.

def ManejarEventos():
  global eventos
  for event in eventos:
      print event
      if event.type == pygame.QUIT:
          sys.exit(0) #se termina el programa
      elif event.type == pygame.MOUSEBUTTONDOWN:
          print event.pos

En las próximas entradas de este blog lo que haremos es permitir que pacman sea manejado con el teclado y que pueda comerse las otras piezas del juego.

Pacman 0.001 - Aprender a programar es divertido

código pacman

Vamos a programar nuestra primera versión de pacman en Python 2.6 y usando la librería "Pygame". En esta primera versión lo que haremos es mostrar en una pantalla negra las imágenes que se muestran a continuación.

Además, haremos que nuestro pacman y el fantasma se muevan por la pantalla.

Todo el código y las imágenes lo tienes en el siguiente fichero pacman

Todos los objetos que mostremos en pantalla serán "sprites". Un sprite es un objeto que tiene dos propiedades: image y rect. "image" es la imagen a mostrar y "rect" es el rectángulo en donde se muestra la imagen en pantalla.
La función "update" de los sprites es llamada de forma continua a lo largo del juego para poder hacer cualquier cambio. Por ejemplo, en nuestro caso cambiamos la posición del sprite en pantalla empleando la función "move_ip" que desplaza el rectángulo de la imagen según la velocidad indicada en el constructor del sprite.
Por si no conoces Python, la función "__init__" es el constructor de la clase.

import pygame

class MiSprite ( pygame.sprite.Sprite ):
def __init__(self, fichero_imagen, pos_inicial, velocidad):
  pygame.sprite.Sprite.__init__(self)

  self.image = pygame.image.load(fichero_imagen).convert()
  self.rect = self.image.get_rect()

  self.rect.topleft = pos_inicial
  self.velocidad = velocidad

def update (self):
  self.rect.move_ip ( self.velocidad[0], self.velocidad[1])

Una vez definida nuestra clase Sprite vamos a inicializar el juego y la pantalla. Creamos una copia de la pantalla como "background" para optimizar el redibujado.

pygame.init()

window = pygame.display.set_mode([300,400])
pygame.display.set_caption("pacman")

screen = pygame.display.get_surface()
screen.fill ([0,0,0])

background = screen.copy()

A continuación creamos los sprites que se muestran en pantalla. Almacenamos los sprites en una lista de tipo "RenderUpdates" que optimiza el redibujado en pantalla.

sprites = pygame.sprite.RenderUpdates()

sprite = MiSprite("pacman.gif", [0,0], [1,1])
sprites.add ( sprite )

sprite = MiSprite("fantasma.gif",[100,0], [1, 1])
sprites.add ( sprite )

sprite = MiSprite ("fruta.gif", [0, 100], [0,0])
sprites.add ( sprite )

sprite = MiSprite ("bola.gif", [100, 100], [0,0] )
sprites.add ( sprite )

Por último, ejecutamos un bucle infinito en donde se actualizarán los sprites y se redibujarán en pantalla.

reloj = pygame.time.Clock()

while True:
sprites.update ()
sprites.clear (screen, background)
pygame.display.update (sprites.draw (screen))
reloj.tick (60)     #tiempo de espera entre frames

En próximas entradas iremos mejorando nuestro pacman.

!Quiero aprender a programar divirtiéndome!

La forma tradicional de aprender a programar es muy muy aburrida, con los típicos ejemplos de búsquedas de texto, ordenaciones, etc. !Quiero aprender a programar divirtiéndome!

¿Cómo? Pues bien sencillo, programando un juego. ¡Ojo! Un juego visual, nada de pantallas de consola con letritas. ¡Uff! Seguro que piensas que eso es muy complejo, sobre todo para enseñárselo a tus alumnos que no tienen ni idea de programación. Pues es mucho más fácil de lo que puedas pensar, todo consiste en elegir las herramientas adecuadas. ¿Y qué herramientas son esas? Python y Pygame. Python es un lenguaje de script cuyo uso se está extendiendo en todos los ámbitos y Pygame es una librería para programar juegos en Python.

La metodología que te propongo es ir creando con los alumnos la estructura básica de un comecocos para luego ir añadiendo nuevas funcionalidades al juego mientras los alumnos descubren toda la potencialidad de Python.
Se puede ver un video demostrativo del juego que vamos a crear. Los saltos que se aprecian son debido a la baja calidad de la grabación para que no ocupase demasiado.

En las próximas entradas de este blog, iré creando este comecoco. Por lo pronto, ya puedes ir instalándote Python y Pygame.

Wink - Graba lo que pasa en pantalla

Wink es un programa gratuito que permite grabar un video en flash de lo que ocurren en pantalla. Esto es útil para crear tutoriales visuales en donde explicamos a los alumnos cómo usar algún tipo de programa. También nos sirve cuando le pedimos a los alumnos que hagan una actividad en el ordenador, como por ejemplo configurar una conexión de red, con esta herramienta los alumnos pueden grabar lo que han hecho y entregarlo, y nosotros podremos revisarlo.
Podemos grabar lo que se muestra en pantalla añadiendo comentarios, configurando el número de fotogramas por segundo, añadiendo botones de pausa,etc.
Un programa muy muy fácil de usar y muy potente. !Pruébalo!

Wink está disponible tanto para Windows como para Linux.

ITALC - Una herramienta muy interesante para el aula

ITALC es un programa que además de permitirnos monitorizar lo que hacen los alumnos en sus ordenadores, nos permite que los alumnos vean en sus propias pantallas lo que estamos haciendo en el ordenador del profesor. De esta manera facilita las explicaciones y podemos evitar el uso del proyector que en muchas aulas no lo tenemos o si lo tenemos, no presenta una buena visualización por la luz o dimensiones de la misma.
Además, presenta otras funcionalidades interesantes como:

1. Permite el bloqueo automático de los ordenadores. Por ejemplo, por si estamos explicando algo y queremos que los alumnos nos presten atención y dejen de trabajar con los ordenadores.


2. Nos permite dejar a un alumno que desde su ordenador muestren al resto de alumnos lo que está haciendo como si fuera el profesor.


3. También permite tomar el control remoto de un ordenador.

Y recuerda, ITALC es open source y funciona tanto en Linux como en Windows.

Estándares de competencia en TIC para docentes

Siempre me había preguntado que nivel de competencia deberíamos tener los docentes en el uso de las TIC, Tecnologías de la Información y la Comunicación. Pues bien, me he llevado una gran sorpresa al descubrir que existe una serie de estándares que los recoge, estableciendo niveles y competencias concretas.

Para el docente, tenemos el estándar elaborado por la UNESCO. En este estándar se establecen tres niveles de competencia:

1. Nociones básicas de TIC. En este nivel, los docentes tienes los conocimientos y habilidades necesarios para un uso efectivo de las TIC.
2. Profundización del conocimiento. En este segundo nivel, las personas son capaces de usar las TIC para resolver problemas reales.
3. Generación del conocimiento. En este último nivel, las personas son capaces de generar nuevos conocimientos, de establecer nuevas prácticas educativas, etc.

En cada uno de estos niveles las competencias se encuentra divididas en:  plan de estudios y evaluación, pedagogía, TIC, organización y administración y formación profesional de docentes. En la siguiente imagen se puede ver un esquema de este estándar:

Por ejemplo, en el documento en donde se recoge este estándar. se indica que a nivel de "nociones básicas de TIC", en el marco de pedagogía:

• I.C.1. Describir cómo la didáctica y las TIC se pueden utilizar para contribuir a que los estudiantes alcancen conocimientos en las asignaturas escolares.
• I.C.2. Incorporar en los proyectos de clase actividades adecuadas que integren las TIC, a fin de contribuir a que los estudiantes adquieran conocimientos en asignaturas escolares.
• I.C.3. Utilizar software de presentación multimedia y recursos informáticos para complementar la enseñanza.

Te animo a leer detenidamente este estándar.