def crea_tablero(titulo, alto, ancho):
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
global fondo_tablero
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electrónica
canvas["bg"] = "black"
canvas.pack()
global pizarra
pizarra = RawTurtle(fondo_tablero)
dibuja_leds()
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: detiene(), "Escape")
por_siempre()
fondo_tablero.listen()
print("terminó")
root.mainloop()
def setup_keypress(
win: turtle.TurtleScreen,
current_direction: Callable[[], Direction],
update_direction: Callable[[Direction], None],
):
win.listen()
win.onkeypress(
lambda: update_direction(right_pressed(current_direction())), "Right")
win.onkeyrelease(
lambda: update_direction(right_released(current_direction())), "Right")
win.onkeypress(lambda: update_direction(left_pressed(current_direction())),
"Left")
win.onkeyrelease(
lambda: update_direction(left_released(current_direction())), "Left")
def crea_tablero(titulo, alto, ancho):
""" Crea una pizarra electrónica.
Entradas:
titulo : título de la ventana que contendrá la
pizarra electrónica.
alto : alto de la ventana en pixeles.
ancho : ancho de la ventna en pixeles.
Salidas:
Ninguna.
Restricciones:
titulo es una tira, alto y ancho son enteros positivos.
"""
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
global fondo_tablero
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electrónica
canvas["bg"] = "black"
canvas.pack()
global pizarra
pizarra = RawTurtle(fondo_tablero)
dibuja_leds()
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: detiene(), "Escape")
por_siempre()
fondo_tablero.listen()
print("terminó")
root.mainloop()
class Snake():
""" Implementa un Snake que puede moverse en una
cuadrícula imaginaria dede m filas por n columnas.
Las filas y columnas se numeran a partir de 1.
El snake tendrá una largo, que incluye su cabeza.
El largo tiene que ser mayor que 1.
La cabeza se pinta de un color y los segmentos de
su cuerpo en otro.
El snake se puede mover en forma horizontal o
vertical.
Para mover el snake se utilizan las flechas
direccionales y la tecla "x" (que también mueve
el snake hacia abajo).
"""
## Atributos de clase que definen el tamaño por
## defecto de la cuadrícula.
FILAS = 40
COLUMNAS = 30
## Atributos de clase que define el tamaño (en pixeles)
## de cada elemento de la cuadrícula.
DIM = 10
## Atributo de clase que defifne el tamaño por
## defecto del snake.
LARGO_SNAKE = 4
## Atributos de clase que define a partir de que
## coordenadas en el eje horizontal(x) y vertical(y)
## se empieza a dibujar la cuadrícula.
DY = 20
DX = 20
@staticmethod
def deme_posicion(i,j):
""" Retorna la posicion superior izquierda en eje x, eje y
de un elemento i,j en la cuadrícula imaginaria.
Entradas:
i : Fila en la cuadrícula imaginaria.
j : Columna en la cuadrícula imaginaria.
Salidas:
(x,y) : Posición de la esquina superior izquierda
en donde se encuentra la entrada (i,j)
Supuesto:
(i,j) es una posición válida en la cuadrícula
imaginaria.
"""
x = Snake.DX + (j - 1) * (Snake.DIM + 1)
y = Snake.DY + (i - 1) * (Snake.DIM + 1)
return (x, y)
def __init__(self, filas = FILAS, columnas = COLUMNAS,
largo = LARGO_SNAKE, cabeza = "blue", cuerpo="red"):
"""Crea la culebra y su cuadrícula.
Entradas:
filas : # de filas en la cuadrícula imaginaria.
columnas : # de columna en la cuadrícula imaginaria.
largo : Tamaño del snake incluyendo la cabeza.
Salidas:
Snake en una cuadrícula según las dimensiones indicadas.
Supuesto:
La ventana, según las dimensiones establecidas,
cabe en la ventana.
El snake cabe en la cuadrícula.
"""
## Funciones locales al constructor ##
def segmento(color, i, j):
""" Dibuja un segmento del snake en posicion i, j con el color
indicado.
Entradas:
color : Color del segmento a dibujar.
(i,j) : Ubicación en que se desea dibujar el
segmento en la cuadrícula imaginaria.
Salidas:
Dibujo del segemento con el color indicado en
la posición (i,j) de la cuadrícula imaginaria.
Supuesto:
El color es uno válido en Tkinter.
(i,j) es una posición válida en la
cuadrícula imaginaria.
"""
## Determina la posición en los ejes
## reales de la posición (i,j) de la
## cuadrícula imaginaria.
x, y = Snake.deme_posicion(i, j)
## Prepara el lápiz para dibujar
## un rectánculo relleno.
self.lapiz.fillcolor(color)
self.lapiz.pu()
self.lapiz.setpos(x, y)
self.lapiz.seth(0)
self.lapiz.pd()
self.lapiz.begin_fill()
## Dibuja el rectángulo con 4
## movimientos !!!
for i in range(4):
self.lapiz.fd(Snake.DIM+1)
self.lapiz.left(90)
## Cierra el relleno.
self.lapiz.end_fill()
def mueva_snake(direccion):
""" Mueve el snake en la dirección indicada.
Entradas:
direccion : Dirección en que se mueve el snake.
Salidas:
Actualización del snkae en pantalla.
Si el snake pega contra un borde o contra ella
misma no avanza.
Supuesto:
dirección es alguno de los valores
"Up", "Down", "Left" o "Right".
"""
## Obtiene la posición actual de la cabeza del snake.
ci, cj = self.snake[-1][0], self.snake[-1][1]
## Calcula la nueva posición de la cabeza según
## la dirección indicada por el usuario.
if direccion == "Up":
i, j = (ci if ci == 1 else ci - 1, cj)
elif direccion == "Down":
i, j = (ci if ci == self.filas else ci + 1, cj)
elif direccion == "Left":
i, j = (ci, cj if cj == 1 else cj - 1)
elif direccion == "Right":
i, j = (ci, cj if cj == self.columnas else cj + 1)
if not((i,j) in self.snake): ## se asegura que el snake
## no choque contra sí mismo !!
self.scr.tracer(False)
## Borra la cola. La cola está en la
## posición 0 de la lista self.snake.
segmento("white", self.snake[0][0], self.snake[0][1])
del self.snake[0]
## Pinta la antigua cabeza de color azul para que sea
## parte del cuerpo. La cabeza es el último elemento
## de la lista self.snake.
segmento(cuerpo, self.snake[-1][0], self.snake[-1][1])
## Agrega la nueva cabeza. La cabeza nueva cabeza
## se agrega al final de la lista.
self.snake.append((i, j))
segmento(cabeza, i, j)
self.scr.tracer(True)
def dibuja_horizontales():
""" Dibuja las filas+1 lineas horizontales.
Entradas:
Ninguna.
Salidas:
Dibujo de las líneas horizontales de la
cuadrícula imaginaria en que se moverá el
snake.
"""
dy = Snake.DY ## Posición en eje y de la primera
## línea horizontal.
## Calcula la posición en eje x en que finalizan
## todas la líneas horizontales.
posFin_x = Snake.DX + self.columnas * (Snake.DIM + 1)
for i in range(self.filas+1):
self.lapiz.up()
self.lapiz.setpos(Snake.DX, dy)
self.lapiz.down()
self.lapiz.setpos(posFin_x, dy)
dy += Snake.DIM + 1
def dibuja_verticales():
""" Dibuja las columnas+1 lineas verticales
Entradas:
Ninguna.
Salidas:
Dibujo de las líneas verticales de la
cuadrícula imaginaria en que se moverá el
snake.
"""
dx = Snake.DX ## Posición en eje x de la primera
## línea vertical.
## Calcula la posición en eje y en que finalizan
## todas la líneas verticales.
posFin_y = Snake.DY + self.filas * (Snake.DIM + 1)
for j in range(self.columnas+1):
self.lapiz.up()
self.lapiz.setpos(dx,Snake.DY)
self.lapiz.down()
self.lapiz.setpos(dx, posFin_y)
dx += Snake.DIM + 1
def dibuja_escenario():
""" Dibuja la cuadrícula y el snake: el cuerpo en azul y la
cabeza en rojo.
Entradas:
Ninguna.
Salidas:
Dibujo de la cuadrícula imaginaria en que se moverá el
snake.
"""
self.scr.tracer(False)
## Dibuja la cuadricula
dibuja_horizontales()
dibuja_verticales()
## Dibuja el cuerpo del snake
for x in self.snake[:-1]:
segmento(cuerpo,x[0],x[1])
## Dibuja la cabeza
segmento(cabeza, self.snake[-1][0], self.snake[-1][1])
self.scr.tracer(True)
############################################################
## Inicio de las instrucciones del constructor __init__. ##
############################################################
## Verifica restricciones, sino se cumplen dispara un
## SnakeError.
if not (isinstance(filas,int) and isinstance(columnas,int) and \
isinstance(largo,int)):
raise SnakeError("Type Error")
else:
## Guarda las dimensiones de la cuadrícula
## imaginaria y del snake en atributos de instancia.
self.filas = filas
self.columnas = columnas
self.largo = largo
## Crea la ventana y estable un título para la misma.
self.root = TK.Tk()
self.root.title("Snake v1.0 / 2014")
## Obtiene la posición (x,y) en la ventana de la
## última fila y columna de la cuadrícula imaginaria,
## lo anterior con el objetivo de establecer el
## tamaño de la ventana.
x, y = Snake.deme_posicion(filas, columnas)
## Calcula el ancho y el alto de la ventana
anchoVentana = x + Snake.DX + Snake.DIM + 1
altoVentana = y + Snake.DY + Snake.DIM + 1
## Crea un área de dibujo (canvas) con un ancho y
## alto que está en función de la cuadrícula
## en que se moverá el snake.
self.canvas = TK.Canvas(self.root, width=anchoVentana,
height=altoVentana)
self.canvas.pack()
## Crea un área de dibujo para tortugas.
self.scr = TurtleScreen(self.canvas)
## Establece un sistema de coordenadas en donde
## el punto (0,0) se ubica en la esquina superior
## izquierda.
## El eje x va de 0 a positivos de izquierda a derecha.
## El eje y va de 0 a positivos de arriba hacia abajo.
self.scr.setworldcoordinates(0,altoVentana,anchoVentana,0)
self.scr.reset()
## Crea la tortuga para dibujar
self.lapiz = RawTurtle(self.scr)
self.lapiz.ht()
## Crea el snake.
## El snake corresponde a una lista de pares
## ordenados (x, y) en donde cada uno de estos
## elementos corresponde a un segmento del snake.
## La cabeza del snake se ubica en la última
## posición de la lista.
## El snake creado queda en posición horizontal
## y su cabeza mira hacia la derecha. La cola
## se ubica en la posición 1,1. Observe que se
## utilizaron listas por comprensión para
## construir el snake. En este punto el snake
## no es visible.
self.snake = [(1,eje_y) for eje_y in range(1, self.largo + 1)]
## Dibuja la cuadrícula y el snake.
dibuja_escenario()
## Establece el binding entre las teclas para el movimiento
## del snake y las funciones que atenderán dicho movimiento.
## En todos los casos se utiliza la misma función solo que
## el parámetro con que se invoca es diferente.
self.scr.onkeypress(lambda : mueva_snake("Up"), "Up") # Arriba
self.scr.onkeypress(lambda : mueva_snake("Right"), "Right") # Derecha
self.scr.onkeypress(lambda : mueva_snake("Down"), "Down") # Abajo
self.scr.onkeypress(lambda : mueva_snake("Left"), "Left") # Izquierda
self.scr.onkeypress(lambda : mueva_snake("Down"), "x") # Otra vez abajo
## Se queda escuchando los eventos.
## El programa termina cuando el usuario cierre la ventana.
self.scr.listen()
def crea_tablero(titulo, alto, ancho):
""" Crea una pizarra electronica
Entradas:
titulo : titulo de la ventana que contendra la pizarra electronica
alto : alto de la ventana en pixeles
ancho : ancho de la ventna en pixeles
Salidas: Ninguna
Restricciones: titulo es una tira, alto y ancho son enteros positivos
"""
## Restricciones
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
## Crea la ventana y un canvas para dibujar
root = TK.Tk()
root.title(titulo)
canvas = TK.Canvas(root, width=ancho, height=alto)
canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
fondo_tablero = TurtleScreen(canvas)
## Establece el fondo de la pizarra electronica
canvas["bg"] = "black"
canvas.pack()
pizarra = RawTurtle(fondo_tablero)
dibuja_leds(pizarra)
## Establece las funciones para capturar las teclas
fondo_tablero.onkeypress(lambda: envie_0(pizarra), "0")
fondo_tablero.onkeypress(lambda: envie_1(pizarra), "1")
fondo_tablero.onkeypress(lambda: envie_2(pizarra), "2")
fondo_tablero.onkeypress(lambda: envie_3(pizarra), "3")
fondo_tablero.onkeypress(lambda: envie_4(pizarra), "4")
fondo_tablero.onkeypress(lambda: envie_5(pizarra), "5")
fondo_tablero.onkeypress(lambda: envie_6(pizarra), "6")
fondo_tablero.onkeypress(lambda: envie_7(pizarra), "7")
fondo_tablero.onkeypress(lambda: envie_8(pizarra), "8")
fondo_tablero.onkeypress(lambda: envie_9(pizarra), "9")
fondo_tablero.onkeypress(lambda: dibuja_leds(pizarra), "Escape")
fondo_tablero.listen()
root.mainloop()
class Gamefield:
"""Die Klasse Bescreibt wie ein Feld aussieht (Muss kein Gamefeld sein)"""
def __init__(self, tkFrame, backgroundColor):
self.rootWindow = TurtleScreen(tkFrame)
self.rootWindow.bgcolor(backgroundColor)
self.rootWindow.tracer(0)
def getRootWindow(self):
return self.rootWindow
# In der gameListenToPresskey Methode werden alle move Methoden einem Tastatur-Knopf zugewiesen. (für die erste Schlange)
def gameListenToPresskey(self, basilisk):
self.rootWindow.listen()
self.rootWindow.onkeypress(basilisk.moveUpwards, "Up")
self.rootWindow.onkeypress(basilisk.moveDownwards, "Down")
self.rootWindow.onkeypress(basilisk.moveLeftwards, "Left")
self.rootWindow.onkeypress(basilisk.moveRightwards, "Right")
# In der gameListenToPresskey Methode werden alle move Methoden einem Tastatur-Knopf zugewiesen. (für die zweite Schlange)
def gameListenToPresskeyForTowPlayer(self, basilisk):
self.rootWindow.listen()
self.rootWindow.onkeypress(basilisk.moveUpwards, "w")
self.rootWindow.onkeypress(basilisk.moveDownwards, "s")
self.rootWindow.onkeypress(basilisk.moveLeftwards, "a")
self.rootWindow.onkeypress(basilisk.moveRightwards, "d")
def gamefieldUpdate(self):
self.rootWindow.update()
def gamefieldMainloop(self):
self.rootWindow.mainloop()
def addShape(self, gif):
self.rootWindow.addshape(gif)