def bottom_left(monk: turtle.Turtle, size):
monk.penup()
monk.backward(size)
monk.right(90)
monk.forward(size)
monk.left(90)
monk.pendown()
def draw_dotted_square(turtle: t.Turtle, space: float, number_of_points_per_side: int):
for _ in range(number_of_points_per_side):
draw_dotted_line(turtle, space, number_of_points_per_side)
turtle.backward(space*number_of_points_per_side)
turtle.left(90)
turtle.forward(space)
turtle.right(90)
class Paddles:
def __init__(self):
self.t_1 = Turtle()
self.t_1.shape('square')
self.t_1.color('white')
self.t_1.speed('fastest')
self.t_1.penup()
self.t_1.shapesize(1, 5)
self.t_1.goto(-350, 0)
self.t_2 = Turtle()
self.t_2.shape('square')
self.t_2.color('white')
self.t_2.penup()
self.t_2.speed('fastest')
self.t_2.shapesize(1, 5)
self.t_2.goto(350, 0)
self.t_1.seth(90)
self.t_2.seth(90)
self.pad_1 = self.t_1.ycor()
self.pad_2 = self.t_2.ycor()
def move_up_1(self):
self.t_1.forward(MOVE)
def move_down_1(self):
self.t_1.backward(MOVE)
def move_up_2(self):
self.t_2.forward(MOVE)
def move_down_2(self):
self.t_2.backward(MOVE)
def fuck_you():
window = Turtle().screen
window.bgcolor('black')
f = Turtle()
f.color('white')
f.left(90)
f.forward(100)
f.right(90)
f.forward(50)
u = Turtle()
u.color('white')
u.setpos(60.0, 100.0)
u.clear()
u.right(90)
u.forward(100)
u.left(90)
u.forward(50)
u.left(90)
u.forward(100)
c = Turtle()
c.color('white')
c.setpos(180.0, 100.0)
c.clear()
c.backward(50)
c.left(-90)
c.forward(100)
c.left(90)
c.forward(50)
k = Turtle()
k.color('white')
k.setpos(200.0, 100.0)
k.clear()
k.right(90)
k.forward(100)
k.sety(50)
k.right(-45)
k.forward(50)
k.backward(50)
k.right(-90)
k.forward(50)
u2 = Turtle()
u2.color('white')
u2.setpos(300.0, 100.0)
u2.clear()
u2.right(90)
u2.forward(100)
u2.left(90)
u2.forward(50)
u2.left(90)
u2.forward(100)
window.exitonclick()
def tree(branch, t: turtle.Turtle):
time.sleep(0.0005)
if branch > 3:
if 8 <= branch <= 12:
if random.randint(0, 2) == 0:
t.color('snow')
else:
t.color('lightcoral')
t.pensize(branch / 3)
elif branch < 8:
if random.randint(0, 1) == 0:
t.color('snow')
else:
t.color('lightcoral')
t.pensize(branch / 2)
else:
t.color('red')
t.pensize(branch / 10)
t.forward(branch)
a = 1.5 * random.random()
t.right(20 * a)
b = 1.5 * random.random()
tree(branch - 10 * b, t)
t.left(40 * a)
tree(branch - 10 * b, t)
t.right(20 * a)
t.up()
t.backward(branch)
t.down()
def setup():
A = Turtle() # Draws Circle in A
B = Turtle() # Draws Circle in B
X = Turtle() # Text Below A
Y = Turtle() # Text Below B
A.ht()
B.ht()
X.ht()
Y.ht()
A.speed(100)
B.speed(100)
X.speed(100)
Y.speed(100)
A.penup()
B.penup()
X.penup()
Y.penup()
A.setpos(-w / 4, -120)
B.setpos(w / 4, -120)
X.setpos(-w / 4, -200)
Y.setpos(w / 4, -200)
A.pendown()
B.pendown()
filler(A, Room_state['Limpo'], False)
filler(B, Room_state['Limpo'], False)
# Creates rooms and boundary
t1 = Turtle()
t1.ht()
t1.speed(20)
t1.penup()
t1.setposition(w / 2, h / 2)
t1.pendown()
t1.pensize(10)
t1.right(90)
t1.forward(h)
t1.right(90)
t1.forward(w)
t1.right(90)
t1.forward(h)
t1.right(90)
t1.forward(w)
t1.backward(w / 2)
t1.right(90)
t1.pensize(5)
t1.forward(h - 90)
t1.penup()
t1.setpos(-w / 4, h / 2 - 70)
t1.write("Lado A", align="center", font=("Arial", 20, "normal"))
t1.setpos(w / 4, h / 2 - 70)
t1.write("Lado B", align="center", font=("Arial", 20, "normal"))
return A, B, X, Y
def draw_star(t: turtle.Turtle, size):
t.backward(size / 2)
t.pendown()
for side in range(5):
t.forward(size)
t.right(180 - 36)
t.penup()
t.forward(size / 2)
def main():
t = Turtle()
my_win = Screen()
t.left(90)
t.up()
t.backward(100)
t.down()
t.color("green")
tree(35s, t)
my_win.exitonclick()
def main_tree():
t = Turtle()
window = Screen()
t.left(90)
t.up()
t.backward(100)
t.down()
t.color('green')
tree(75, t)
window.exitonclick()
def maketree():
p = Turtle(shape="triangle", visible=False)
p.setundobuffer(None)
p.fillcolor("green")
p.shapesize(0.4)
p.speed(0)
p.left(90)
p.penup()
p.backward(210)
p.pendown()
tree([p], 200, 65, 0.6375)
def winner(self, n):
t = Turtle()
t.color('white')
t.penup()
t.hideturtle()
t.backward(60)
t.write(f"Player {n} Win", font=FONT)
time.sleep(1)
t.clear()
self.clear()
self.score()
def maketree():
p = Turtle(shape="triangle", visible=False)
p.setundobuffer(None)
p.fillcolor("green")
p.shapesize(0.4)
p.speed(0)
p.left(90)
p.penup()
p.backward(210)
p.pendown()
tree([p], 200, 65, 0.6375)
def tree(branchlen, t: turtle.Turtle, width):
if branchlen > 5:
width -= 0.4
t.pen(pensize=width, pencolor='green')
t.forward(branchlen)
angle = random.randrange(15, 46)
t.right(angle)
tree(branchlen - random.randrange(10, 20), t, width)
t.left(2 * angle)
tree(branchlen - random.randrange(10, 20), t, width)
t.right(angle)
t.backward(branchlen)
def draw_unsorted(data_list):
tess = Turtle() # create tess and set some attributes
tess.color("blue")
tess.fillcolor("red")
tess.pensize(2)
tess.penup()
tess.backward(250)
tess.pendown()
for element in data_list:
draw_bar(tess, element)
def two(terpy: turtle.Turtle, place: int = 1):
if place in (100, 1000):
south(terpy)
else:
north(terpy)
terpy.backward(50)
if place in (10, 100):
terpy.left(90)
else:
terpy.right(90)
terpy.forward(50)
go_home(terpy, place)
def tree(t: turtle.Turtle, branchLen: int):
if branchLen > 5:
t.forward(branchLen)
t.right(20)
tree(t, branchLen - 15)
t.left(40)
tree(t, branchLen - 15)
t.right(20)
t.backward(branchLen)
def four(terpy: turtle.Turtle, place: int = 1):
if place in (100, 1000):
south(terpy)
else:
north(terpy)
terpy.backward(50)
if place in (10, 100):
terpy.left(45)
else:
terpy.right(45)
terpy.forward(hypotenuse)
go_home(terpy, place)
def draw_ch4(t: turtle.Turtle, size):
size = size / 2
t.pendown()
t.right(90)
for square in range(5):
t.backward(size / 2)
for side in range(4):
t.forward(size)
t.left(90)
t.forward(size / 2)
t.left(360 / 5)
t.left(90)
t.penup()
def draw(yoshi: Turtle, length: int) -> None:
"""Draw a recursive tree pattern.
"""
if length < 16:
return
yoshi.forward(length)
yoshi.left(30)
draw(yoshi, 3 * length // 4)
yoshi.right(60)
draw(yoshi, 3 * length // 4)
yoshi.left(30)
yoshi.backward(length)
class Player:
def __init__(self):
self.player = Turtle()
self.player.shape('turtle')
self.player.color('white')
self.player.penup()
self.player.goto(STARTING_POSITION)
self.player.setheading(90)
def move(self):
self.player.forward(MOVE_DISTANCE)
def move_back(self):
self.player.backward(MOVE_DISTANCE)
def petal(m, t: turtle.Turtle):
for i in range(m):
a = 200 - 400 * random.random()
b = 10 - 20 * random.random()
t.up()
t.forward(b)
t.left(90)
t.forward(a)
t.down()
t.color('pink')
t.circle(1)
t.up()
t.backward(a)
t.right(90)
t.backward(b)
class Grapher:
def __init__(self,Dim):
self.T = Turtle(visible = False)
self.T.speed('fastest')
self.draw_axis(Dim)
def axis(self,distance,tick):
pos = self.T.position()
self.T.pendown()
for _ in range(0,abs(distance['upper']),tick):
self.T.forward(tick)
self.T.dot()
self.T.setposition(pos)
for _ in range(0,abs(distance['lower']),tick):
self.T.backward(tick)
self.T.dot()
self.T.penup()
def draw_axis(self,Dim):
self.T.penup()
self.T.home()
self.axis(Dim['X'],1)
self.T.penup()
self.T.home()
self.T.setheading(90)
self.axis(Dim['Y'],1)
def plot(self,region):
self.T.speed('fast')
self.T.penup()
self.T.pencolor('blue')
for p in region:
self.T.goto(p)
self.T.pendown()
self.T.penup()
def cube(startx, starty, colno): #takes in start coords and the colour number
c = Turtle() #makes turtle
c.hideturtle() #hides it
c.penup()
c.goto(startx, starty) #goes to aforementioned start coords
c.speed(0) #no animation
c.right(30)
c.color(colours[colno]) #first shade (index from first array)
c.begin_fill() #starts filling
for i in range(6): #main 'honeycomb' shape outline
c.left(60)
c.forward(50)
c.end_fill()
c.left(120)
c.forward(100)
c.color(colours2[colno]) #second shade for second visible face
c.begin_fill()
c.right(180)
c.forward(50)
c.left(120)
c.forward(50)
c.end_fill()
c.backward(50)
c.left(60)
c.forward(50)
c.begin_fill()
c.left(180)
c.forward(50)
c.right(120)
c.forward(50)
c.end_fill()
c.color(colours3[colno]) #third shade for final face
c.begin_fill()
c.backward(50)
c.left(120)
c.forward(50)
c.right(120)
c.forward(50)
c.end_fill()
class TurtleGTX:
def __init__(self, name = ''):
from turtle import Turtle
self.odometer = 0
self.name = name
self.turtle = Turtle()
def forward(self, distance):
try:
if self.odometer > 1000:
raise ValueError("Need to switch for a new tyre")
if distance > 0:
self.odometer += distance
self.turtle.forward(distance)
if distance < 0:
self.odometer += distance*(-1)
self.turtle.backward(distance*(-1))
except:
print("Need to switch for a new tyre")
def change_tyre(self):
self.odometer = 0
class Racer:
def __init__(self, order, count, xpos):
self.order = order
self.count = count
self.xpos = xpos
self.col = COLS[self.order]
self.t = Turtle()
self.t.penup()
self.t.speed(4)
self.t.color(self.col)
self.t.shape("turtle")
self.t.setpos(self.xpos[self.order], -240)
self.t.left(90)
self.t.pendown()
# Write name (color)
self.t.penup()
self.t.backward(30)
self.t.write(self.col.upper(), font=FONT, align="center")
self.t.forward(30)
self.t.pendown()
def move(self):
step = random.randint(0, self.count * 2)
self.t.forward(step)
return None
def win(self):
if self.t.pos()[1] >= 240:
turtle.penup()
turtle.setpos(0, 0)
turtle.pendown()
turtle.color(self.col)
turtle.write(self.col.upper() + " WINS!",
font=TITLE_FONT,
align="center")
self.t.setpos(self.xpos[self.order], 250)
return True
class new_turtle:
def __init__(self, x=0, y=0):
self.segments = []
self.snappy = Turtle("square")
self.snappy.penup()
self.snappy.color("white")
self.snappy.goto(x, y)
def move_forward(self):
self.snappy.forward(20)
def turn_left(self):
if self.head() != RIGHT:
self.snappy.setheading(LEFT)
def turn_right(self):
if self.head() != LEFT:
self.snappy.setheading(RIGHT)
def up(self):
if self.head() != DOWN:
self.snappy.setheading(UP)
def down(self):
if self.head() != UP:
print("Down")
self.snappy.setheading(DOWN)
def xy(self):
return self.snappy.xcor(), self.snappy.ycor()
def follow(self, a, b):
self.snappy.goto(a, b)
def move(self):
self.snappy.backward(5)
def head(self):
self.snappy.heading()
class TurtleGTX:
def __init__(self, name=''):
from turtle import Turtle
self.odometer = 0
self.name = name
self.turtle = Turtle()
def forward(self, distance):
try:
if self.odometer > 1000:
raise ValueError("Need to switch for a new tyre")
if distance > 0:
self.odometer += distance
self.turtle.forward(distance)
if distance < 0:
self.odometer += distance * (-1)
self.turtle.backward(distance * (-1))
except:
print("Need to switch for a new tyre")
def change_tyre(self):
self.odometer = 0
def draw_ocean_water(ocean_water: Turtle, x: float, y: float) -> None:
"""This function draws the ocean water."""
colormode(255)
ocean_water.penup()
ocean_water.goto(x, y)
ocean_water.setheading(0.0)
ocean_water.pendown()
ocean_water.color(0, 191, 255)
ocean_water.speed(FASTEST_SPEED)
ocean_water.begin_fill()
i: int = 0
while (i < 9):
ocean_water.forward(41)
ocean_water.left(20)
ocean_water.forward(41)
ocean_water.right(22.25)
i = i + 1
ocean_water.left(110)
ocean_water.backward(260)
ocean_water.left(90)
ocean_water.forward(800)
ocean_water.end_fill()
return
def main():
wn = Screen()
wn.setup(300, 300)
wn.clear()
#turtle.delay(0)
travis = Turtle()
travis.hideturtle()
travis.speed(0)
travis.penup()
travis.goto(-150, 150)
travis.pendown()
travis.width(2)
for x in range(-150, 150, 20):
for y in range(-150, 150, 3):
random_switch = random.randint(0, 1)
if random_switch == 1:
travis.forward(random.randint(5, 40))
travis.right(90)
travis.forward(random.randint(5, 10))
travis.penup()
travis.goto(x, y)
travis.pendown()
else:
travis.backward(random.randint(5, 40))
travis.left(90)
travis.backward(random.randint(5, 10))
travis.penup()
travis.goto(x, y)
travis.pendown()
random_int = random.randint(0, 10)
if random_int == 10:
travis.color('red')
else:
travis.color('black')
now = datetime.today().strftime('%Y-%m-%d-%H:%M:%S')
turtle.getcanvas().postscript(file=f"circles_{now}.eps")
wn.exitonclick()
from turtle import Turtle
def treeBuilder(branch,turtle):
if branch > 5:
turtle.forward(branch)
turtle.right(20)
treeBuilder(branch-5,turtle)
turtle.left(40)
treeBuilder(branch-5,turtle)
turtle.right(20)
turtle.backward(branch)
turtle = Turtle()
turtle.left(90)
turtle.up()
turtle.backward(100)
turtle.down()
turtle.color("blue")
treeBuilder(50,turtle)
cursor.forward(100)
cursor.right(135)
cursor.forward(140)
cursor.left(135)
cursor.forward(100)
time.sleep(0.5)
cursor.clear()
cursor.penup()
cursor.setposition(-70,0)
cursor.color('black')
cursor.pendown()
cursor.right(90)
cursor.forward(100)
cursor.backward(50)
cursor.left(90)
cursor.forward(100)
cursor.left(90)
cursor.forward(50)
cursor.backward(100)
time.sleep(0.5)
cursor.clear()
cursor.penup()
cursor.right(180)
cursor.setposition(-300,0)
cursor.color('red')
cursor.pendown()
cursor.left(90)
screen = Screen()
screen.title("Dino game in turtle")
screen.bgcolor('white')
screen.setup(width=WIDTH, height=HEIGHT)
screen.tracer(False)
ground = Turtle()
ground.hideturtle()
ground.penup()
ground.sety(BASELINE)
ground.pendown()
ground.forward(WIDTH / 2)
ground.backward(WIDTH)
dino = Turtle()
dino.shape('square')
dino.penup()
dino.goto(-WIDTH / 3, BASELINE + CURSOR_SIZE / 2)
cacti = []
for _ in range(NUMBER_CACTI):
cactus = Turtle()
cactus.shape('square')
cactus.shapesize(CACTUS_HEIGHT / CURSOR_SIZE, CACTUS_WIDTH / CURSOR_SIZE)
cactus.color('green')
from turtle import Turtle
from random import random
def random_color():
return (random(),random(),random())
artist = Turtle()
artist.penup()
artist.pensize(400)
artist.speed(7)
artist.hideturtle()
artist.backward(200)
artist.left(90)
artist.forward(200)
artist.right(90)
artist.pendown()
while True:
for count in range(4):
artist.pencolor(random_color())
artist.forward(500)
artist.right(90)
input()
from turtle import Turtle, mainloop
raptor = Turtle()
raptor.pencolor("red")
raptor.backward(200)
duckbill = Turtle()
duckbill.pencolor("green")
duckbill.forward(200)
mainloop()
tortuga.pencolor('red')
tortuga.pensize(5)
tortuga.circle(20)
tortuga.forward(50)
tortuga.pensize(4)
tortuga.left(20)
tortuga.circle(20)
tortuga.forward(50)
tortuga.pensize(3)
tortuga.left(20)
tortuga.circle(20)
tortuga.forward(50)
tortuga.pensize(2)
tortuga.left(20)
tortuga.circle(20)
tortuga.forward(50)
tortuga.pensize(1)
tortuga.left(20)
tortuga.circle(20)
tortuga.forward(50)
tortuga.penup()
tortuga.goto(0, -100)
tortuga.towards(0, 0)
tortuga.write('Hola.')
tortuga.backward(20)
tortuga.write('Adios.')
pantalla.exitonclick()
class MazeGraphics(object):
def __init__(self, config):
self.width = config.getValueAsInt("maze", "maze_size")
self.height = config.getValueAsInt("maze", "maze_size")
self.bg_color = config.getValue("maze", "bg_color")
self.line_color = config.getValue("maze", "line_color")
self.line_centroid_color = config.getValue("maze", "line_centroid_color")
self.forward_centroid_color = config.getValue("maze", "forward_centroid_color")
self.reverse_centroid_color = config.getValue("maze", "reverse_centroid_color")
self.path_color = config.getValue("maze", "path_color")
self.screen = Screen()
self.setupTurtle(self.width, self.height)
def setupTurtle(self, width, height):
self.screen.tracer(False)
self.screen.screensize(width, height)
# some basic turtle settings
self.screen.setworldcoordinates(-1, -1, width + 1, height + 1)
self.screen.title("Random Turtle Maze")
self.screen.bgcolor(self.bg_color)
self.screen.delay(None)
self.designer = Turtle(visible=False)
def drawGrid(self):
for i in xrange(0, self.width + 1):
self.drawXLines(i, self.width, self.line_color)
for i in xrange(0, self.height + 1):
self.drawYLines(i, self.width, self.line_color)
self.screen.update()
def drawXLines(self, position, width, color):
self.drawLines(position, 0, width, color, 90)
def drawYLines(self, position, width, color):
self.drawLines(0, position, width, color, 0)
def drawLines(self, xPosition, yPosition, width, color, heading):
self.designer.up()
self.designer.setposition(xPosition, yPosition)
self.designer.color(color)
self.designer.down()
self.designer.setheading(heading)
self.designer.forward(width)
self.designer.up()
def drawCentroid(self, cell, color):
"""
Draw a centroid for animation purposes but then overwrite it.
"""
self.designer.setposition(cell.centroid)
self.designer.dot(5, color)
self.screen.update()
self.designer.dot(5, self.bg_color)
def removeWall(self, posx, posy, heading, color):
"""
We tear down walls to build the maze
"""
self.designer.up()
self.designer.setposition(posx, posy)
self.designer.down()
self.designer.color(color)
self.designer.setheading(heading)
self.designer.forward(1)
self.designer.up()
self.screen.update()
def drawPath(self, cell1, cell2):
"""
This draws a line for the solution as it's worked out.
"""
self.designer.setposition(cell1.centroid)
self.designer.color(self.path_color)
direction = self.getDirection(cell1, cell2)
if direction == "N":
self.designer.setheading(90)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "S":
self.designer.setheading(270)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "W":
self.designer.setheading(0)
self.designer.down()
self.designer.forward(1)
self.designer.up()
elif direction == "E":
self.designer.setheading(0)
self.designer.down()
self.designer.backward(1)
self.designer.up()
self.drawCentroid(cell2, self.line_centroid_color)
self.screen.update()
def getDirection(self, currCell, nextCell):
direction = None
if nextCell.x < currCell.x:
direction = "E"
elif nextCell.x > currCell.x:
direction = "W"
elif nextCell.y < currCell.y:
direction = "S"
elif nextCell.y > currCell.y:
direction = "N"
return direction
games. Bear in mind that the simplicity of the turtle library hurts its performance
considerabily. Therefore is is seen as a stepping stone to other more powerful low-level
libraries such as openGl, Vulkan and DirectX12
-------------------------------------- Jonas -------------------- """
from turtle import Turtle, Screen
# --- Create objects---
screen = Screen()
tut1 = Turtle()
tut2 = Turtle()
# --- INIT turtles ---
tut1.speed(1)
tut1.penup()
tut1.shape("circle")
tut1.shapesize(5)
tut1.color("red")
tut2.speed(1)
tut2.penup()
tut2.shape("square")
tut2.shapesize(5)
tut2.color("blue")
# --- ACTION ---
tut1.forward(100)
tut2.backward(100)
screen.mainloop()
from turtle import Turtle
from random import random
def random_color():
return(random(),random(),random())
nibles = Turtle()
nibles.pensize(7)
nibles.speed(0)
for counter in range(1,200):
nibles.pencolor(random_color())
nibles.right(10)
nibles.left(20)
nibles.backward(1)
nibles.forward(10)
nibles.
from turtle import Turtle
from random import random
def random_color():
return(random(),random(),random())
MorganFreeman = Turtle()
MorganFreeman.pensize(9)
MorganFreeman.speed(0)
while True:
for counter in range(50):
MorganFreeman.pencolor(random_color())
MorganFreeman.forward(counter)
MorganFreeman.backward(counter+25)
MorganFreeman.right(25)
MorganFreeman.penup()
MorganFreeman.right(90)
MorganFreeman.forward(50)
MorganFreeman.pendown()
for counter in range(50):
MorganFreeman.pencolor(random_color())
MorganFreeman.forward(counter)
MorganFreeman.backward(counter+25)
MorganFreeman.left(25)
from turtle import Turtle, Screen
def snowflake(t, iterations, size):
if iterations == 0: # Base Case
t.forward(size)
else:
pass
atuin = Turtle()
window = Screen()
atuin.color("#FFFFFF")
window.bgcolor("#0191C8")
atuin.penup()
atuin.backward(50)
atuin.pendown()
atuin.pensize(4)
num_sides = 3
iterations = 0
for i in range(num_sides):
snowflake(atuin, iterations, 100)
atuin.right(360 / num_sides)
window.exitonclick()
class ParsonTurtle(Turtle):
def __init__(self):
self._turtle = Turtle()
self._turtle.shape('turtle')
self._commands = []
def forward(self, dist, log=True):
self._turtle.forward(dist)
if log:
self._commands.append("fwd" + str(dist))
def fd(self, dist, log=True):
return self.forward(dist, log=log)
def backward(self, dist, log=True):
self._turtle.backward(dist)
if log:
self._commands.append("bwd" + str(dist))
def back(self, dist, log=True):
return self.backward(dist, log=log)
def bk(self, dist, log=True):
return self.backward(dist, log=log)
def left(self, angle, log=True):
self._turtle.left(angle)
if log:
self._commands.append("lt" + str(angle))
def lt(self, angle, log=True):
return self.left(angle, log=log)
def right(self, angle, log=True):
self._turtle.right(angle)
if log:
self._commands.append("rt" + str(angle))
def rt(self, angle, log=True):
return self.right(angle, log=log)
def goto(self, nx, ny, log=True):
self._turtle.goto(nx, ny)
if log:
self._commands.append("gt" + str(nx) + "-" + str(ny))
def setposition(self, nx, ny, log=True):
self._turtle.setposition(nx, ny)
if log:
self._commands.append("setpos" + str(nx) + "-" + str(ny))
def setpos(self, nx, ny, log=True):
return self.setposition(nx, ny, log=log)
def setx(self, nx, log=True):
self._turtle.setx(nx)
if log:
self._commands.append("setx" + str(nx))
def sety(self, ny, log=True):
self._turtle.sety(ny)
if log:
self._commands.append("sety" + str(ny))
def dot(self, size, color, log=True):
self._turtle.dot(size, color)
if log:
self._commands.append("dot" + str(size) + "-" + str(color))
def circle(self, radius, extent, log=True):
self._turtle.circle(radius, extent)
if log:
self._commands.append("circle" + str(radius) + "-" + str(extent))
def up(self, log=True):
self._turtle.up()
if log:
self._commands.append("up")
def penup(self, log=True):
return self.up(log=log)
def pu(self, log=True):
return self.up(log=log)
def down(self, log=True):
self._turtle.down()
if log:
self._commands.append("down")
def pendown(self, log=True):
return self.down(log=log)
def pd(self, log=True):
return self.down(log=log)
def speed(self, spd):
self._turtle.speed(spd)
def _logColorChange(self, command, color, green, blue):
if blue is not None:
self._commands.append("%s(%d, %d, %d)"%(command, color, green, blue))
else:
self._commands.append("%s(%s)"%(command, color))
def pencolor(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.pencolor(color, green, blue)
else:
self._turtle.pencolor(color)
if log:
self._logColorChange("pcolor", color, green, blue)
def color(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.color(color, green, blue)
else:
self._turtle.color(color)
if log:
self._logColorChange("color", color, green, blue)
def fillcolor(self, color, green=None, blue=None, log=True):
if blue is not None:
self._turtle.fillcolor(color, green, blue)
else:
self._turtle.fillcolor(color)
if log:
self._logColorChange("fcolor", color, green, blue)
def width(self, size, log=True):
self._turtle.pensize(size)
if log:
self._commands.append("width%d"%size)
def pensize(self, size, log=True):
return self.width(size, log=log)
def commands(self):
return ':'.join(self._commands)
def main():
t = Turtle()
my_win = Screen()
t.width(12)
t.speed(10)
t.left(90)
t.up()
t.backward(100)
t.down()
t.color("brown")
tree(75, t)
my_win.exitonclick()
