Castellano
Material Necesario
Componente | Cantidad | Descripción |
---|---|---|
BBC micro:bit | 1 ud | Placa BBC micro:bit |
En este Proyecto, vamos a realizar un Competitivo Juego que lo hemos llamado El Comepuntos. Las normas del juego son:
- Primeramente elegimos el Nivel del Juego. Este nivel puede ser el 1, 2 o 3. Lo elegimos pulsando el Boton «A» de nuestra micro:bit
- Nivel 1. El más fácil. Tiempo Total del Juego 75 ciclos. Cuando comemos un punto, el tiempo se incrementa en 50 ciclos
- Nivel 2. El intermedio. Tiempo Total del Juego 50 ciclos. Cuando comemos un punto, el tiempo se incrementa en 25 ciclos
- Nivel 3. El más difícil. Tiempo Total del Juego 25 ciclos. Cuando comemos un punto, el tiempo se incrementa en 15 ciclos
- El Juego se acaba cuando los ciclos de tiempo restantes llegan a 0 (cada parpadeo del comepuntos es un ciclo)
- Una vez hemos elegido el nivel deseado pulsamos el Botón «B» y empieza el Juego
- El Juego consiste en mover la tarjeta micro:bit para conseguir que nuestro comepuntos (el punto de la pantalla de leds que se enciende y apaga, ese es nuestro protagonista) se coma o capture la mayor cantidad posible de puntos (los puntos fijos que van apareciendo en la pantalla de leds) mientras nos quede tiempo, es decir, el número de ciclos totales del juego sea mayor que 0
- Recuerda que ganas ciclos de tiempo a medida que comes los puntos
- Si los ciclos de tiempo llegan a 0 se acaba el juego. La pantalla mostrará «Fin» y el número de puntos conseguidos (los puntos comidos).
- Empieza por el Nivel 1 y conforme adquieras experiencia elige un nivel más difícil
- Y sobre todo COMPITE contra tus amigos y GANA, pero antes entrena…
Para este Proyecto no necesitamos ningún tipo de montaje. Solamente nuestra tarjeta micro:bit.
A continuación una imagen del Juego (aunque no se ve el parpadeo, el punto inferior es el que parpadea, es nuestro comepuntos)…
En esta ocasión no vamos a poner el pseudocódigo, sino directamente el programa en Python.
Hemos comentado en profundidad el código del programa en Python, para que sirva al mismo tiempo como documentación y facilite su comprensión.
from microbit import *
import random
# -------------------------
# Funciones del comepuntos
# -------------------------
# Función que muestra el comepuntos en la pantalla de leds
# El comepuntos se mostrará como un punto intermitente
def mostrar_comepuntos():
# Encender led (x,y) y esperar 50 milisegundos
display.set_pixel(x, y, 9)
sleep(50)
# Apagar led (x,y) y esperar 50 milisegundos
display.set_pixel(x, y, 0)
sleep(50)
# Función que gestiona el movimiento horizontal del comepuntos
def acelerometro_x():
global x
acel_x = accelerometer.get_x()
# Si inclinamos hacia la horizontal izquierda y x>0
if (acel_x < -150) and (x > 0):
x = x - 1
# Si inclinamos hacia la horizontal derecha y x<4
if (acel_x > 150) and (x < 4):
x = x + 1
# Función que gestiona el movimiento vertical del comepuntos
def acelerometro_y():
global y
acel_y = accelerometer.get_y()
# Si inclinamos hacia la vertical arriba y y>0
if (acel_y < -150) and (y > 0):
y = y - 1
# Si inclinamos hacia la vertical abajo y x<4
if (acel_y > 150) and (y < 4):
y = y + 1
# --------------------
# Funciones del punto
# --------------------
# Función que muestra el punto en la pantalla de leds
# El punto se mostrará como un punto fijo e inmóvil
def mostrar_punto():
# Encender led (a,b)
display.set_pixel(a, b, 9)
# Función que apaga el punto cuando se lo come el comepuntos
def comer_punto():
# Apagar led (a,b)
display.set_pixel(a, b, 0)
# Función que crea el punto en las coordenadas (a,b)
# de forma aleatorio y verifica que no haya sido creado
# en las coordenadas(x,y) donde está el comepuntos
def crear_punto():
global a
global b
# Entrar la primera vez en el While
repetir = True
while repetir:
a = random.randint(0, 4)
b = random.randint(0, 4)
repetir = False
# Verificar que el punto no aparece en el
# mismo lugar que el comepuntos
if (a == x) and (b == y):
repetir = True
# Función que verifica si el comepuntos se
# come el punto. Es decir, las coordenadas del
# comepuntos (x,y) son las mismas que las del punto (a,b)
def comprobar_comepuntos_come_punto():
come_punto = False
if (x == a) and (y == b):
come_punto = True
return come_punto
# ----------------------------
# Inicializamos las Variables
# ----------------------------
# Inicializamos valores
# Asignamos los puntos iniciales (x,y) del comepuntos
# Más o menos en el centro de la pantalla de leds, (2,2)
global x
global y
x = 2
y = 2
# Asignamos los puntos iniciales (a,b) del punto
# La posición (a,b) del punto es aleatoria
global a
global b
crear_punto()
# Contar los puntos que se he comido el comepuntos
puntos_comidos = 0
# Nivel de dificultad por defecto = 1 (Facil)
nivel_dificultad = 1
# Lo primero que debemos elegir antes de jugar al comepuntos
# es el nivel de dificultad, mediante el boton A elegimos el
# nivel y cuando pulsamos el boton B empezamos a jugar en ese nivel
while not button_b.was_pressed():
display.scroll("N")
display.scroll(nivel_dificultad)
# Elegir nivel de dificultad
if button_a.was_pressed():
nivel_dificultad = nivel_dificultad + 1
if (nivel_dificultad > 3):
nivel_dificultad = 1
# Definir los parametros según el nivel elegido
# Nivel 1
# Tiempo total del juego 75 ciclos
# Incremento de tiempo cuando comemos un punto 50 ciclos
# Nivel 2
# Tiempo total del juego 50 ciclos
# Incremento de tiempo cuando comemos un punto 25 ciclos
# Nivel 3
# Tiempo total del juego 25 ciclos
# Incremento de tiempo cuando comemos un punto 15 ciclos
# Nivel 1
if (nivel_dificultad == 1):
tiempo_restante = 75
incrememto_de_tiempo = 50
# Nivel 2
if (nivel_dificultad == 2):
tiempo_restante = 50
incrememto_de_tiempo = 25
# Nivel 3
if (nivel_dificultad == 3):
tiempo_restante = 25
incrememto_de_tiempo = 15
perdido = False
# ----------------
# Bucle Principal
# ----------------
while not perdido:
# Mostramos el comepuntos en la posicion (x,y)
mostrar_comepuntos()
# Movimiento horizontal
acelerometro_x()
# Movimiento vertical
acelerometro_y()
# Mostrar punto
mostrar_punto()
# Restamos al tiempo restante 1 ciclo
tiempo_restante = tiempo_restante - 1
# Comprobamos si el comepuntos(x,y) se come el punto(a,b)
if (comprobar_comepuntos_come_punto()):
# Nos comemos el punto, sumamos 1 a los puntos comidos y
# creamos un nuevo punto
comer_punto()
puntos_comidos = puntos_comidos + 1
crear_punto()
# Asignamos mas tiempo restante al comer el punto
tiempo_restante = tiempo_restante + incrememto_de_tiempo
# Verificamos si queda tiempo restante
# Si no queda tiempo restante damos el juego por perdido y salimos
# del bucle principal
if (tiempo_restante == 0):
perdido = True
# -------------------
# Terminado el Juego
# -------------------
# Mostramos en la pantalla de micro:bit
# "Fin" y el número de puntos comidos
display.scroll("Fin.Puntos")
display.scroll(puntos_comidos)
En este caso, hemos preferido no subir el fichero python del programa, por considerar que la mejor forma de aprender es teclearlo y así ir comprendiéndolo y aprendiendo…
A continuación algunas imágenes del Juego.
Como siempre, espero hayas aprendido y disfrutado con este Proyecto.
Si tienes dudas o quieres hacer cualquier aportación que consideres de interés, puedes realizar todos tus comentarios a continuación.
Ingeniero Superior en Informática de Gestión, UPV 1988-1993
Máster en Dirección Comercial y Marketing, Fundesem 2005
Máster en Peritaje Informático e Informática Forense, EuroInnova 2018
Máster en Marketing y Estrategia de Comunicación Digital, Fundesem 2019