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):
""" Parent should be a tk frame - see fractal_drawing calls.
We will use this init function for all children..."""
# levels of recursion when calling recursive draws.
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 __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 Rank():
root = TK.Tk()
cv1 = TK.Canvas(root, width=400, height=200)
cv1.pack()
s1 = TurtleScreen(cv1)
s1.bgcolor("#42f4ad")
t = RawTurtle(s1)
t.hideturtle()
t.penup()
t.goto(-50,70)
t.write("내가 예측한 1등: "+ guess)
t.goto(-50,50)
if PlayerNumber>=1:
t.write("1등 : "+PlayerRank[0])
t.goto(-50,40)
if PlayerNumber>=2:
t.write("2등 : "+PlayerRank[1])
t.goto(-50,30)
if PlayerNumber>=3:
t.write("3등 : "+PlayerRank[2])
t.goto(-50,20)
if PlayerNumber>=4:
t.write("4등 : "+PlayerRank[3])
t.goto(-50,10)
if PlayerNumber>=5:
t.write("5등 : "+PlayerRank[4])
t.goto(-100,-20)
if(guess==PlayerRank[0]):
t.write("축하드립니다. 1등을 맞추셨습니다.")
else:
t.write("1등을 맞추지 못했습니다.")
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 pen(self):
turt = RawTurtle(self.screen)
turt.ht()
turt.speed(0)
turt.up()
turt.goto(-self.width, self.height)
turt.down()
return turt
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 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 __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():
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.left(36)
q.left(180)
for t in p, q:
t.begin_fill()
for i in range(5): #画五边形
for t in p, q:
t.forward(50)
t.left(72)
for t in p, q:
t.end_fill()
t.left(54)
t.penup()
t.back(50)
return "EVENTLOOP"
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 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 getReady():
for i in [ 5, 4, 3, 2, 1 ,0]:
time.sleep(1)
line = RawTurtle(myGameField.getRootWindow())
line.speed(0)
line.shape("square")
line.color("white")
line.penup()
line.hideturtle() # Versteckte Überschrift
line.goto(0,0)
line.write("Get ready %s" % i , align= "center", font=("Courier", 18 ,"normal"))
line.clear()
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 draw(ans):
"""Вывод топологической схемы"""
global xax, moves, oboz, window
turx, tury = xax - int(xax*0.3), int(yax*0.25)
bg_def = window.cget('bg')
canvas = Canvas(window, relief='sunken', borderwidth=5, width=turx, height=tury, background=bg_def)
canvas.place(relx=0.5, rely=0.1, y=int(yax*0.19), anchor=CENTER)
screen = TurtleScreen(canvas)
global turtle
turtle = RawTurtle(canvas)
turtle.speed(5)
turtle.hideturtle()
allen = (turx - int(xax*0.2))
global let
if len(ans) > 7:
if ans[5] == 1 and ans[8] == 1:
let = allen // 3
else:
if ans[5] == 1:
let = allen // 4
elif ans[8] == 1:
let = allen // 4
else:
let = allen // 5
if ans[5] == 2:
allen -= let//2
if ans[8] == 2:
allen -= let//2
else:
if ans[5] == 1:
let = allen // 2
else:
let = allen // 3
if ans[5] == 2:
allen -= let//2
turtle.color('white')
turtle.up()
turtle.goto(x=-allen // 2, y=-int(yax*0.09))
turtle.down()
turtle.color('black')
turtle.dot(5, 'black')
turtle.write('A')
for i in [moves[k + 1][x] for k, x in enumerate(ans) if k + 1 in moves]:
print(i)
eval(i)
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 main():
global obstacles
global obastacleUtil
global newMap
global newAstar
global drawUtil
width = Configurations.width
height = Configurations.height
initCanvasHere(width, height)
# root = TK.Tk()
# root1 = TK.Tk()
# cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff")
# cv2 = TK.Canvas(root1, 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)
obstacles = []
obastacleUtil = DrawObstacleUtils.DrawObstacleUtils((width, height),
obstacles)
turtle.onscreenclick(addObstacle)
initDrawUtil(width, height, Point(50, 50))
newMap = Array2D.Array2D(width, height)
turtle.mainloop()
turtle.done()
class TurtleCanvas:
window = tk.Tk()
canvas = ScrolledCanvas(master=window, width=800, height=600)
canvas.pack(fill=tk.BOTH, expand=tk.YES)
screen = TurtleScreen(canvas)
turtle = RawTurtle(screen)
def __init__(self, x, y):
cWidth = 800
cHeight = 600
self.x = x
self.y = y
self.turtle.speed("fastest")
self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y))
self.canvas.bind('<MouseWheel>', self.zoom)
def zoom(self, event):
amount = 0.9 if event.delta < 0 else 1.1
self.canvas.scale(tk.ALL, 0, 0, amount, amount)
def square(self, sidelength=50):
for i in range(4):
self.turtle.forward(sidelength)
self.turtle.right(90)
def triangle(self, sidelength=50):
point = self.turtle
point.color("black")
point.speed("fastest")
for i in range(3):
point.forward(sidelength)
point.right(120)
self.window.mainloop()
def star(self, sidelength=50):
point = self.turtle
point.color("black")
point.speed("fastest")
for i in range(5):
point.forward(sidelength)
point.right(145)
self.window.mainloop()
def squareDriver(self, steps):
i = 0
for j in range(steps):
self.square(20 + i)
self.turtle.right(2)
i += 1
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 __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 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()
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, turtle_window, id_number):
# comment here
self.turtle_window = turtle_window
self.id_number = id_number
self.name = 'Sugar'
# comment here
self.turtle_object = RawTurtle(self.turtle_window.wn)
self.turtle_object.hideturtle()
self.turtle_object.shape('square')
self.turtle_object.penup()
self.turtle_object.color("black", "white")
self.place()
self.turtle_object.showturtle()
# comment here
self.turtle_object.ondrag(self.drag)
def __init__(self, turtle_window, id_number):
self.speed_params = [20, 0.2, 6]
self.turn_parameters = [20]
self.turtle_window = turtle_window
self.max_location = self.turtle_window.screen_size / 2 - 10
self.vehicle = RawTurtle(self.turtle_window.wn)
self.vehicle.hideturtle()
self.id_number = id_number
self.type = random.choice(["crossed", "direct"])
self.vehicle.shape('turtle')
self.vehicle.turtlesize(1)
self.vehicle.penup()
if self.type == 'crossed':
self.vehicle.color("red", (1, 0.85, 0.85))
else:
self.vehicle.color("blue", (0.85, 0.85, 1))
self.place()
self.vehicle.showturtle()
def __init__(self, titulo, alto, ancho):
assert isinstance(titulo, str)
assert isinstance(alto, int) and alto > 0
assert isinstance(ancho, int) and ancho > 0
self.root = TK.Tk()
self.root.title(titulo)
self.canvas = TK.Canvas(self.root, width=ancho, height=alto)
self.canvas.pack()
self.fondo_ventana = TurtleScreen(self.canvas)
self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0)
self.canvas["bg"] = "gold"
self.canvas.pack()
self.pencil = RawTurtle(self.fondo_ventana)
self.pencil.pencolor("white")
