def __init__(self, turtle_window, id_number):
# comment here
self.turtle_window = turtle_window
self.id_number = id_number
# comment here
self.speed_params = [20, 0.2, 6]
self.turn_parameters = [20]
# comment here
self.turtle_object = RawTurtle(self.turtle_window.wn)
self.turtle_object.hideturtle()
self.turtle_object.shape('turtle')
self.turtle_object.turtlesize(1)
self.turtle_object.penup()
# comment here
self.likes_food_dict = {'Sugar': random.choice([True, False])}
# comment here
if self.likes_food_dict['Sugar']:
self.turtle_object.color("red", (1, 0.85, 0.85))
else:
self.turtle_object.color("blue", (0.85, 0.85, 1))
# comment here
self.place()
self.turtle_object.showturtle()
def __init__(self,x):
self.it=x
S="D+D+D+D"
for i in range(self.it):
pesan=""
for j in range(len(S)):
if S[j]=="D":
pesan+="D+D-D-DD+D+DD-D-D+D"
else:
pesan+=S[j]
S=pesan
root3=tk.Tk()
if self.it!=1:
root3.title('Batik Fractal with '+str(self.it)+' iterations')
else:
root3.title('Batik Fractal with an iteration')
self.canvas=ScrolledCanvas(master=root3,width=1000,height=1000)
self.canvas.pack(fill=tk.BOTH,expand=tk.YES)
screen=TurtleScreen(self.canvas)
screen.screensize(10000,10000)
self.turtle=RawTurtle(screen)
self.turtle.ht()
self.turtle.speed(0)
for i in range(len(S)):
if S[i]=="D":
self.turtle.forward(10)
elif S[i]=="+":
self.turtle.right(90)
else:
self.turtle.left(90)
self.canvas.bind('<MouseWheel>',self.zoom)
screen.mainloop()
def juhuslikud_konnad(n=100, t=100):
"""
Tekitab n juhuslikult liikuvat konna
"""
ekraan = Screen()
konnad = []
for i in range(n):
# Paigutame konna i juhuslikele koordinaatidele
konn_i = RawTurtle(ekraan)
konn_i.up()
x = randint(-100, 100)
y = randint(-100, 100)
konn_i.goto(x, y)
konn_i.down()
# Värvime konna juhusliku värviga
varv = choice(['green', 'brown', 'black', 'red', 'blue'])
konn_i.color(varv)
# Lisame konna i konnade hulka
konnad.append(konn_i)
# Teeme t juhuslikku liikumist juhusliku konnaga
for ti in range(t):
suunamuutus = randint(-60, 60)
konn = choice(konnad)
konn.left(suunamuutus)
konn.fd(20)
def __init__(self,turtleScreen,player_type,posVector,k_to_high,k_to_middle,k_to_low,k_to_producer,m,R):
RawTurtle.__init__(self,turtleScreen) #タートル生成
self.up() #軌跡は書かない
self.setpos(posVector) #初期位置
self.resizemode("user")
self.shape("circle") #プレイヤーの形
self.shapesize(0.5)
if player_type == "high_level_predator":
self.color("red") #高域捕食者
self.strengthpower = 3
self.shape("triangle")
elif player_type == "middle_level_predator":
self.color("yellow") #中域捕食者
self.strengthpower = 2
self.shape("square")
elif player_type == "low_level_predator":
self.color("blue") #低域捕食者
self.strengthpower = 1
self.shape("turtle")
else :
self.color("dark green") #生産者
self.strengthpower = 0
self.shape("circle")
#このクラスで新しく追加した変数
self.acc = Vec2D(0,0) #初期加速度ゼロ
self.v= Vec2D(0,0) #初期速度ゼロ
self.m = m #質量
self.k_to_high = k_to_high #高域捕食者に対するK
self.k_to_middle = k_to_middle #中域捕食者に対するK
self.k_to_low = k_to_low #低域捕食者に対するK
self.k_to_producer = k_to_producer #生産者に対するK
self.R = R #視野半径
self.energy = 10
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0, -80)
self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def __init__(self, scene, robot_id):
#sets variables
self.robot_id = robot_id
self.turtle = RawTurtle(scene.canvas)
self.scene = scene
self.scr = self.turtle.getscreen()
self.scr.setworldcoordinates(0, scene.height, scene.width, 0)
self.turtle.penup()
if robot_id == 1:
self.turtle.color("blue")
else:
self.turtle.color("red")
#create turtles sprite
## self.turtle.register_shape("ship",((-7,-2),(-6,-1),(-3,0),(-3,1),(-2,5),
## (0,7),(2,5),(3,1),(3,0),(6,-1),(7,-2),
## (3,-1),(3,-2),(2,-7),(-2,-7),(-3,-2),
## (-3,-1),(-2,-1),(-2,-2),(-1,-6),(1,-6),
## (2,-2),(2,-1),(-2,-1),(-2,0),(2,0),
## (2,1),(1,4),(0,5),(-1,4),(-2,1),
## (-2,-1),(-3,-1))
## )
## self.turtle.shape("ship")
## self.turtle.shapesize(2,2)
#place robot using reset
self.reset()
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.4, 25)
self.designer.goto(0, -81)
self.designer.stamp()
self.designer.shapesize(4, 0.5)
self.designer.fillcolor('Black')
for x in -150, 0, 150:
self.designer.goto(x, -5)
self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-150)
self.towerB = Tower(0)
self.towerC = Tower(150)
self.ts.tracer(True)
class Ventana():
def __init__(self, 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
self.root = TK.Tk()
self.root.title(titulo)
self.canvas = TK.Canvas(self.root, width=ancho, height=alto)
self.canvas.pack()
## Crea un TurtleScreen y la tortuga para dibujar
self.fondo_ventana = TurtleScreen(self.canvas)
self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0)
## Establece el color de fondo
self.canvas["bg"] = "blue"
self.canvas.pack()
## Crea una tortuga para dibujar
self.pencil = RawTurtle(self.fondo_ventana)
self.pencil.pencolor("white")
def test_board_full_4(board4):
"""Testing the board fulness"""
root = tkinter.Tk()
canvas = tkinter.Canvas(root)
t = RawTurtle(canvas)
screen = t.getscreen()
board = Board(None, screen)
root.destroy()
def board0():
root = tkinter.Tk()
canvas = tkinter.Canvas(root)
t = RawTurtle(canvas)
screen = t.getscreen()
board = Board(None, screen)
board.reset()
# root.destroy()
return board
def get_pen(self):
self.pen = RawTurtle(self.screen)
self.pen.color("#f0d1bf")
xpos = 0
ypos = self.screen.height - 30
self.pen.up()
self.pen.ht()
self.pen.goto(xpos, ypos)
self.pen.down()
def start_message(self):
""" Creates Pen for drawing game update messages above the board. """
self.pen = RawTurtle(self)
self.pen.ht()
self.pen.up()
self.pen.color(self.font[1])
self.pen.goto(0, self.y)
self.pen.write("New Game", align="center", font=self.font[0])
return
def __init__(self):
self.win = tk.Tk()
self.win.geometry("640x400")
self.canvas = Canvas()
self.canvas.pack()
self.scr = TurtleScreen(self.canvas)
self.t = RawTurtle(self.scr)
self.btn = Button(self.win, text="Press me!", command=self.do_action())
self.btn.pack()
def __init__(self, window, content, x, y):
self.headline = RawTurtle(window)
self.headline.speed(0)
self.headline.shape("square")
self.headline.color("white")
self.headline.penup()
self.headline.hideturtle()
self.headline.goto(x, y)
self.headline.write(content,
align="center",
font=("Courier", 18, "normal"))
def main(pattern: str) -> None:
master = Tk()
canvas = ScrolledCanvas(master)
canvas.pack()
screen = TurtleScreen(canvas)
screen.colormode(255)
turt = RawTurtle(screen)
draw_dots(turt)
turt.pencolor((178, 34, 34))
draw_pattern(turt, pattern)
screen.mainloop()
def initialize(self, hOptions):
self.screen = TurtleScreen(self.tkWidget)
self.tkTurtle = RawTurtle(self.screen)
self.screen.mode('world')
self.tkTurtle.setheading(90)
if 'speed' in hOptions:
self.curSpeed = int(hOptions['speed'])
else:
self.curSpeed = 1
self.lSaveStack = [] # stack to save/restore state on
def __init__(self,screen,corners,width,height,x,y):
self.corners = corners
self.screen = screen
self.pen = RawTurtle(screen)
self.pen.speed(8)
self.width = width
self.height = height
self.x = x
self.y = y
self.spaces = []
self.draw()
self.draw_spaces()
def __init__(self, turtle_window, id_number):
self.turtle_window = turtle_window
self.id_number = id_number
self.heat_source = RawTurtle(self.turtle_window.wn)
self.heat_source.hideturtle()
self.heat_source.shape('circle')
self.heat_source.penup()
self.heat_source.color("orange")
self.place()
self.heat_source.showturtle()
self.heat_source.ondrag(self.drag_heat_source)
def __init__(self, title="Hangman"):
super().__init__()
self.title(title)
self.geometry("720x600")
self.configurationFile = "level.conf"
self.dataFile = "hangman.dat"
self.dataPath = "data/"
self.__hp = HP.THangman(self)
if os.path.exists(self.dataPath + self.dataFile):
self.deserialize()
self.output = tk.StringVar()
self.output.set(self.__hp.getLetters)
self.info = tk.StringVar()
alphabets = 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', \
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Å', 'Ä', 'Ö', '-'
self.Buttons = ButtonsBlock(self, alphabets, 15)
self.Buttons.grid(row=0, column=0, columnspan=3, padx=10, pady=5)
self.frame2 = tk.Frame(self).grid(row=2)
tk.Label(self.frame2, textvariable=self.output).grid(pady=10,
columnspan=5)
self.frame3 = tk.Frame(self).grid(row=3)
tk.Label(self.frame3, textvariable=self.info).grid(padx=10,
pady=10,
columnspan=5,
sticky=tk.W + tk.E)
tk.Button(self, text="Guess a new word",
command=self.new).grid(row=5,
padx=30,
pady=5,
sticky=tk.E + tk.W,
columnspan=5)
self.canvas = Canvas(self, width=500, height=350)
self.canvas.grid(row=8,
column=0,
columnspan=5,
padx=10,
sticky=tk.W + tk.E + tk.S + tk.N)
self.turtle_screen = TurtleScreen(self.canvas)
self.raw_turtle = RawTurtle(self.canvas)
self.raw_turtle.hideturtle()
self.raw_turtle.speed(0)
self.restoreGUI()
message = "You are currently playing in " + levels[
self.__hp.level] + " level"
messagebox.showinfo("Level of difficulty", message)
self.protocol("WM_DELETE_WINDOW", self.close)
def __init__(self, screen, index=0, base=0, height=0, parent=None, color="#000"):
RawTurtle.__init__(self,screen)
self.base = base
self.height = height
self.__color = color
self.color(color)
self.value = str(height)
self.stage = parent
self.speed(screen.speed)
self.index = index
self.__tracer = self.screen.tracer()
self.ht()
self.up()
def create_widgets(self):
tk.Label(self.parent, text="Robot Driver Inc.",
font=('Arial', 25)).grid(row=0, column=0, columnspan=6)
self.forward_btn = tk.Button(self.parent, text="Jazda do przodu")
self.rotate_btn = tk.Button(self.parent, text="Obrót")
self.wait_btn = tk.Button(self.parent, text="Czekaj")
self.undo_btn = tk.Button(self.parent, text="Cofnij")
self.generate_btn = tk.Button(self.parent, text="Generuj kod")
self.canvas = tk.Canvas(self.parent, width=640, height=480)
self.draw = RawTurtle(self.canvas)
self.forward_btn.grid(row=1, column=0, sticky=tk.E + tk.W)
self.rotate_btn.grid(row=2, column=0, sticky=tk.E + tk.W)
self.wait_btn.grid(row=3, column=0, sticky=tk.E + tk.W)
self.undo_btn.grid(row=4, column=0, sticky=tk.E + tk.W)
self.generate_btn.grid(row=5, column=0, sticky=tk.E + tk.W)
self.canvas.grid(row=6, column=0, columnspan=6)
tk.Label(self.parent, text="Moc:").grid(row=1, column=1)
self.power_input = tk.Entry(self.parent, textvariable=self.power_var)
tk.Label(self.parent, text="Czas:").grid(row=1, column=3)
self.forward_wait_input = tk.Entry(self.parent,
textvariable=self.forward_wait_var)
tk.Label(self.parent, text="Stopnie:").grid(row=2, column=1)
self.rotate_input = tk.Entry(self.parent,
textvariable=self.degrees_var)
tk.Label(self.parent, text="Czas:").grid(row=3, column=1)
self.wait_wait_input = tk.Entry(self.parent,
textvariable=self.wait_wait_var)
tk.Label(self.parent, text="Ścieżka:").grid(row=4, column=1, rowspan=2)
self.filepath_label = tk.Label(self.parent,
text=self.filepath,
wraplength=150,
justify='center')
self.filepath_btn = tk.Button(self.parent, text="Wybierz")
self.power_input.grid(row=1, column=2)
self.forward_wait_input.grid(row=1, column=4)
self.rotate_input.grid(row=2, column=2)
self.wait_wait_input.grid(row=3, column=2)
self.filepath_label.grid(row=4, column=2, rowspan=2)
self.filepath_btn.grid(row=5,
column=3,
columnspan=2,
sticky=tk.E + tk.W)
def __init__(self, screen, cor, idx, population):
RawTurtle.__init__(self, screen)
x, y = cor
self.filled = False
self.color(gen_color())
self.idx = idx
self.pop = population
nw = (x - 12, y)
ne = (x, y)
sw = (x - 12, y - 12)
se = (x, y - 12)
self.corners = (nw, sw, se, ne)
self.speed(0)
self.ht()
def __init__(self, cv):
ts = TurtleScreen(cv)
RawTurtle.__init__(self, ts)
# self.turtleRef = turt
self.ts = ts
ts.listen()
self.isDrawing = False
self.penup()
self.speed(0)
canvas = cv
canvas.bind('<Button-1>', self.onDraw)
canvas.bind('<Button1-ButtonRelease>', self.onStopDrawing)
canvas.bind('<Motion>', self.move)
def __init__(self, window, shape):
self.speed = 0.1
self.score = 0
self.highScore = 0
self.mouth = RawTurtle(window)
self.mouth.speed(0)
self.mouth.shape(shape)
self.mouth.home()
self.mouth.direction = "stop"
self.mouth.penup()
self.deadFromPoison = False
self.tempScore = 1
self.body = []
def __init__(self,canvas):
#self.window = master
#self.canvas = ScrolledCanvas(master=self.window, width=800, height=600)
#self.canvas.pack(fill=tk.BOTH, expand=tk.YES)
self.canvas = canvas
self.screen = TurtleScreen(canvas)
self.turtle = RawTurtle(self.screen)
self.turtle.speed("fastest")
#self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y))
self.canvas.bind('<MouseWheel>', self.zoom)
self.canvas.bind("<ButtonPress-1>", self.scroll_start)
self.canvas.bind("<B1-Motion>", self.scroll_move)
self.canvas.bind("<ButtonPress-3>", self.changeDirection)
#self.canvas.bind("<c>", self.changeColor)
self.rightDirection = True
def __init__(self,board,center,radius,color,idx):
RawTurtle.__init__(self,board.screen)
self.board = board
self.center = center
self.radius = radius
self.state = None
self.idx = idx
self._bgcolor = color
self.color(color)
self.up()
self.speed(5)
self.goto(self.center[0],self.center[1]-self.radius)
self.ht()
self.down()
self.draw()
def __init__(self):
self.win = Tk()
self.btn = Button(self.win, text="확인", command=self.press)
self.btn.pack()
self.canvas = Canvas(self.win)
self.canvas.config(width=600, height=300)
self.canvas.pack()
self.src = TurtleScreen(self.canvas)
self.t = RawTurtle(self.src)
self.t.pensize(5)
# 서버와 소켓 연결
self.client = socket(AF_INET, SOCK_STREAM)
self.client.connect(('127.0.0.1',9999))
def test_minimax_param(board, evaluation):
"""Testing the minimax"""
root = tkinter.Tk()
canvas = tkinter.Canvas(root)
t = RawTurtle(canvas)
screen = t.getscreen()
tkboard = Board(None, screen)
tkboard.reset()
for i in range(3):
for j in range(3):
if board[i][j] == "O":
tkboard[i][j] = O(canvas)
elif board[i][j] == "X":
tkboard[i][j] = X(canvas)
# root.destroy()
assert minimax(1, tkboard, 4) == evaluation
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def __init__(self, parent, levels):
self.levels = levels
# Toggles screen update rate
self.slow_drawing = False
# Draw button
button = Button(parent, text='Draw Fractal', command=self._draw_click)
button.pack()
width, height = (600, 600)
self.canvas = Canvas(parent, width=600, height=600)
# Constrain resizing to a 1:1 aspect ratio
self.canvas.winfo_toplevel().aspect(1, 1, 1, 1)
self.canvas.pack(fill=BOTH, expand=YES)
# Setup a turtle
self.turtleScreen = TurtleScreen(self.canvas)
# 5px of padding
self.turtleScreen.setworldcoordinates(-5, -height - 5, width + 5, 5)
self.turtle = RawTurtle(self.turtleScreen)
self.turtleScreen.colormode(255)
# Listen to resize events
self.canvas.bind('<Configure>', self._resize_and_draw)
# Do an initial draw
self.slow_drawing = True
self._resize_and_draw()
self.slow_drawing = False
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 __init__(self,canvas,h,k,xr,yr,size,speed,screensize = 500):
screen = TurtleScreen(canvas)
RawTurtle.__init__(self,screen)
self.screen = screen
self.screen.tracer(0)
self.h = h
self.k = k
self.xr = xr
self.yr = yr
self.size = size
self.speedturt = speed
self.d = 0.05
self.nofunc = 0
self.screensize = screensize
self.hideturtle()
self.pensize(1)
self.reset_var()
def __init__(self, scene, robot_id):
self.robot_id = robot_id
self.done = False
self.signal = None
self.turtle = RawTurtle(scene.canvas)
self.scene = scene
self.scr = self.turtle.getscreen()
self.scr.setworldcoordinates(0, scene.height, scene.width, 0)
self.turtle.penup()
self.reset()
def render_system(system, n=0):
"""Renders the given system using a new turtle"""
# Expand if requested
system.expand(n)
# Draw it
turtle = RawTurtle(Screen())
turtle.speed(0)
turtle.ht()
turtle.lt(90)
system.render_turtle(turtle)
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('black')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
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()
class Robot:
def __init__(self, scene, robot_id):
self.robot_id = robot_id
self.done = False
self.signal = None
self.turtle = RawTurtle(scene.canvas)
self.scene = scene
self.scr = self.turtle.getscreen()
self.scr.setworldcoordinates(0, scene.height, scene.width, 0)
self.turtle.penup()
self.reset()
def reset(self):
positions = [((15,15), 45),
((self.scene.width-15, 15), 135),
((15, self.scene.height-15), 315),
((self.scene.height-15, self.scene.width-15), 135)]
self.turtle.speed(0)
self.turtle.setpos(positions[self.robot_id][0])
print positions[self.robot_id]
self.turtle.left(positions[self.robot_id][1])
self.turtle.forward(20)
self.turtle.speed("normal")
def process(self):
##sets variables for checking collision
turtle_x = self.turtle.xcor()
turtle_y = self.turtle.ycor()
t_heading = self.turtle.heading()
##variables used to check right
xr = turtle_x + 15*math.cos(math.radians(self.turtle.heading()+30))
yr = turtle_y + 15*math.sin(math.radians(self.turtle.heading()+30))
##variables used to check left
xl = turtle_x + 15*math.cos(math.radians(self.turtle.heading()-30))
yl = turtle_y + 15*math.sin(math.radians(self.turtle.heading()-30))
##turns the robot at window boundries
st_orient = [0, 90, 180, 270]
bounce_d = 20
if turtle_x - bounce_d < 0:
self.turtle.setheading(180-t_heading)
if turtle_x + bounce_d > self.scene.width:
self.turtle.setheading(180-t_heading)
if turtle_y - bounce_d < 0:
self.turtle.setheading(360-t_heading)
if turtle_y + bounce_d > self.scene.height:
self.turtle.setheading(360-t_heading)
##check collisions
left = self.scene.canvas.find_overlapping(xl-1,yl-1,xl+1,yl+1)
right = self.scene.canvas.find_overlapping(xr-1,yr-1,xr+1,yr+1)
if self.goal_id in left + right:
self.done = True
elif left:
##turn away
self.turtle.left(10)
elif right:
##turn away
self.turtle.right(10)
else:
##else move forward
self.turtle.forward(5)
##if goal not reached:
if self.signal:
if self.signal == "STOP":
self.signal = None
return
elif not self.done:
self.scene.master.after(20, self.process)
for drawing on two distinct canvases.
"""
from turtle import TurtleScreen, RawTurtle, TK
root = TK.Tk()
cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee")
cv1.pack()
cv2.pack()
s1 = TurtleScreen(cv1)
s1.bgcolor(0.85, 0.85, 1)
s2 = TurtleScreen(cv2)
s2.bgcolor(1, 0.85, 0.85)
p = RawTurtle(s1)
q = RawTurtle(s2)
p.color("red", (1, 0.85, 0.85))
p.width(3)
q.color("blue", (0.85, 0.85, 1))
q.width(3)
for t in p,q:
t.shape("turtle")
t.lt(36)
q.lt(180)
for t in p, q:
t.begin_fill()
def main():
root = TK.Tk()
cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee")
cv1.pack()
cv2.pack()
s1 = TurtleScreen(cv1)
s1.bgcolor(0.85, 0.85, 1)
s2 = TurtleScreen(cv2)
s2.bgcolor(1, 0.85, 0.85)
p = RawTurtle(s1)
q = RawTurtle(s2)
p.color("red", (1, 0.85, 0.85))
p.width(3)
q.color("blue", (0.85, 0.85, 1))
q.width(3)
for t in p,q:
t.shape("turtle")
t.lt(36)
q.lt(180)
for t in p, q:
t.begin_fill()
for i in range(5):
for t in p, q:
t.fd(50)
t.lt(72)
for t in p,q:
t.end_fill()
t.lt(54)
t.pu()
t.bk(50)
return "EVENTLOOP"
for drawing on two distinct canvases.
"""
from turtle import TurtleScreen, RawTurtle, TK
root = TK.Tk()
cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee")
cv1.pack()
cv2.pack()
s1 = TurtleScreen(cv1)
s1.bgcolor(0.85, 0.85, 1)
s2 = TurtleScreen(cv2)
s2.bgcolor(1, 0.85, 0.85)
p = RawTurtle(s1)
q = RawTurtle(s2)
p.color("red", "white")
p.width(3)
q.color("blue", "black")
q.width(3)
for t in p,q:
t.shape("turtle")
t.lt(36)
q.lt(180)
for i in range(5):
for t in p, q:
import math
# import Image
import Tkinter
# import turtle
from turtle import RawTurtle, TurtleScreen
import random
import json
import os
# import time
import numpy as np
root = Tkinter.Tk()
canvas = Tkinter.Canvas(root, width=1200, height=264, state=Tkinter.DISABLED)
canvas.pack()
screen = TurtleScreen(canvas)
turtle = RawTurtle(screen)
# screen.setworldcoordinates(0, 399, 999, 0)
turtle.hideturtle()
turtle.up()
turtle.tracer(50000, delay=0)
# turtle.register_shape("dot", ((-3,-3), (-3,3), (3,3), (3,-3)))
screen.register_shape("tri", ((-3, -2), (0, 3), (3, -2), (0, 0)))
turtle.speed(0)
UPDATE_EVERY = 0
DRAW_EVERY = 2
class Map(object):
"""
def __init__(self, cv):
RawTurtle.__init__(self, cv, shape="square", visible=False)
self.pu()
self.goto(-140,200)
class HanoiEngine:
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
self.ts = canvas
self.ts.tracer(False)
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('black')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
if n > 0:
for x in self.hanoi(n-1, src, temp, dest): yield None
yield self.move(src, dest)
for x in self.hanoi(n-1, temp, dest, src): yield None
def move(self, src_tower, dest_tower):
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
def run(self):
self.running = True
try:
while self.running:
result = self.step()
return result
except StopIteration:
return True
def step(self):
try:
next(self.HG)
return 2**self.nrOfDiscs-1 == self.moveCnt
except TclError:
return False
def stop(self):
self.running = False
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
ex7.play_hanoi(self, self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
return True
class HanoiEngine:
"""Play the Hanoi-game on a given TurtleScreen."""
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None):
"""Sets Canvas to play on as well as default values for
number of discs and animation-speed.
moveCntDisplay is a function with 1 parameter, which communicates
the count of the actual move to the GUI containing the
Hanoi-engine-canvas."""
self.ts = canvas
self.ts.tracer(False)
# setup scene
self.designer = RawTurtle(canvas, shape="square")
self.designer.penup()
self.designer.shapesize(0.5, 21)
self.designer.goto(0,-80); self.designer.stamp()
self.designer.shapesize(7, 0.5)
self.designer.fillcolor('darkgreen')
for x in -140, 0, 140:
self.designer.goto(x,-5); self.designer.stamp()
self.nrOfDiscs = nrOfDiscs
self.speed = speed
self.moveDisplay = moveCntDisplay
self.running = False
self.moveCnt = 0
self.discs = [Disc(canvas) for i in range(10)]
self.towerA = Tower(-140)
self.towerB = Tower(0)
self.towerC = Tower(140)
self.ts.tracer(True)
def setspeed(self):
for disc in self.discs: disc.speed(self.speed)
def hanoi(self, n, src, dest, temp):
"""The classical recursive Towers-Of-Hanoi algorithm,
implemented as a recursive generator, yielding always None
plus an 'important' side effect - the next Hanoi move."""
if n > 0:
for x in self.hanoi(n-1, src, temp, dest): yield None
yield self.move(src, dest)
for x in self.hanoi(n-1, temp, dest, src): yield None
def move(self, src_tower, dest_tower):
"""move uppermost disc of source tower to top of destination
tower."""
dest_tower.push(src_tower.pop())
self.moveCnt += 1
self.moveDisplay(self.moveCnt)
def reset(self):
"""Setup of (a new) game."""
self.ts.tracer(False)
self.moveCnt = 0
self.moveDisplay(0)
for t in self.towerA, self.towerB, self.towerC:
while t != []: t.pop(200)
for k in range(self.nrOfDiscs-1,-1,-1):
self.discs[k].config(k, self.nrOfDiscs)
self.towerA.push(self.discs[k])
self.ts.tracer(True)
self.HG = self.hanoi(self.nrOfDiscs,
self.towerA, self.towerC, self.towerB)
def run(self):
"""run game ;-)
return True if game is over, else False"""
self.running = True
try:
while self.running:
result = self.step()
return result # True iff done
except StopIteration: # game over
return True
def step(self):
"""perform one single step of the game,
returns True if finished, else False"""
try:
next(self.HG)
return 2**self.nrOfDiscs-1 == self.moveCnt
except TclError:
return False
def stop(self):
""" ;-) """
self.running = False
