def build_game_over(self):
"""
This method builds the 'Game Over' scene
"""
# delete the score
line = GLine(4, self.window.height - 18, 12 + self.score_sign.width,
self.window.height - 18)
line.color = 'crimson'
self.window.add(line)
# Clean up
self.window.remove(self.reward)
self.window.remove(self.hint_sign)
# Build up the 'Game Over' sign
self.game_over_w.font = "Mamelon-35"
self.game_over_w.color = 'midnightblue'
self.window.add(self.game_over_w,
x=(self.window.width - self.game_over_w.width) / 2,
y=self.window.height / 2)
# Create the movement of the 'Game Over' sign
speed = self.__dy
while True:
self.game_over_w.move(0, speed)
speed += 0.5
if self.game_over_w.y >= self.window.height * 2 // 3:
speed *= -0.7
pause(10)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: For how many times we are gonna do the recursions.
:param length: Equilateral triangle side length
:param upper_left_x: The x coordinate of the top left vertex of the triangles
:param upper_left_y: The y coordinate of the top left vertex of the triangles
:return:
"""
if order == 0:
return
else:
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
window.add(line1)
window.add(line2)
window.add(line3)
pause(10)
# Left Triangle
sierpinski_triangle(order - 1, 0.5 * length, upper_left_x,
upper_left_y)
# Right Triangle
sierpinski_triangle(order - 1, 0.5 * length,
upper_left_x + 0.5 * length, upper_left_y)
# Middle Triangle
sierpinski_triangle(order - 1, 0.5 * length,
upper_left_x + 0.25 * length,
upper_left_y + 0.433 * length)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: The order left of the Sierpinski Triangle
:param length: The length of each order of the Sierpinski Triangle
:param upper_left_x: The upper left x coordinate of each triangle
:param upper_left_y: The upper left y coordinate of each triangle
:return: The Sierpinski Triangle of the given order
"""
if order == 0:
return
else:
left_side = GLine(upper_left_x, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(left_side)
right_side = GLine(upper_left_x + length * 0.5,
upper_left_y + length * 0.866,
upper_left_x + length, upper_left_y)
window.add(right_side)
upper_side = GLine(upper_left_x + length, upper_left_y, upper_left_x,
upper_left_y)
window.add(upper_side)
# Draw a triangle
sierpinski_triangle(order - 1, length * 0.5, upper_left_x,
upper_left_y)
# Add the upper left triangle
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.5, upper_left_y)
# Add the upper right triangle
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.5 * 0.5,
upper_left_y + length * 0.5 * 0.866)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
if order == 0: # Base case
return
else:
pause(10)
# First Triangle
line = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
window.add(line)
line = GLine(upper_left_x, upper_left_y, upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(line)
line = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(line)
# left upper Sierpinski Triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# right upper Sierpinski Triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# lower Sierpinski Triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * 0.866 / 2)
def build_karel4():
"""
This function builds the fourth karel
"""
add = 3
head = GOval(80, 55, x=190 + 120 * add, y=167)
head.filled = True
head.color = 'black'
head.fill_color = 'gray'
window.add(head)
hair1 = GLine(590, 167, 590, 161)
hair2 = GLine(588, 168, 585, 162)
hair3 = GLine(592, 168, 595, 162)
hair4 = GLine(585, 168, 582, 162)
hair5 = GLine(595, 168, 598, 162)
window.add(hair1)
window.add(hair2)
window.add(hair3)
window.add(hair4)
window.add(hair5)
r_eye = GOval(14, 14, x=212 + 120 * add, y=189)
r_eye.filled = True
r_eye.color = 'black'
r_eye.fill_color = 'blue'
window.add(r_eye)
l_eye = GOval(14, 14, x=235 + 120 * add, y=189)
l_eye.filled = True
l_eye.color = 'black'
l_eye.fill_color = 'blue'
window.add(l_eye)
hands = GRect(105, 45, x=177 + 120 * add, y=237)
hands.filled = True
hands.color = 'black'
hands.fill_color = 'lime'
window.add(hands)
body_1 = GRect(60, 65, x=201 + 120 * add, y=223)
body_1.filled = True
body_1.color = 'black'
body_1.fill_color ='blue'
window.add(body_1)
body_2 = GRect(80, 60, x=190 + 120 * add, y=230)
body_2.filled = True
body_2.color = 'black'
body_2.fill_color = 'blue'
window.add(body_2)
r_foot = GOval(29, 24, x=190 + 120 * add, y=290)
r_foot.filled = True
r_foot.color = 'black'
r_foot.fill_color = 'red'
window.add(r_foot)
l_foot = GOval(29, 24, x=241 + 120 * add, y=290)
l_foot.filled = True
l_foot.color = 'black'
l_foot.fill_color = 'red'
window.add(l_foot)
label = GRect(20, 20, x=218+120*add, y=130)
label.filled = True
label.fill_color = 'forestgreen'
label.color = 'forestgreen'
window.add(label)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
order: number of layer should print.
:param length: length of triangle.
:param upper_left_x: x position of top-left point of triangle.
:param upper_left_y: y position of top-left point of triangle.
:return:
"""
pause(300)
if order == 0: # base point
pass
else:
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * 0.886 / 2)
point = [(upper_left_x, upper_left_y),
(upper_left_x + length, upper_left_y),
(upper_left_x + length / 2, upper_left_y + length * 0.886)]
line_top = GLine(point[0][0], point[0][1], point[1][0], point[1][1])
line_right = GLine(point[1][0], point[1][1], point[2][0], point[2][1])
line_left = GLine(point[2][0], point[2][1], point[0][0], point[0][1])
window.add(line_top)
window.add(line_right)
window.add(line_left)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: the order of Sierpinski Triangle
:param length: length of order 1 Sierpinski Triangle
:param upper_left_x: upper left x coordinate of order 1 Sierpinski Triangle
:param upper_left_y: upper left y coordinate of order 1 Sierpinski Triangle
:return: Sierpinski Triangle drawn by the recursive function
"""
pause(50)
if order == 0:
return
else:
# upper left
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# upper right
sierpinski_triangle(order - 1, length / 2, upper_left_x + 0.5 * length,
upper_left_y)
# lower
sierpinski_triangle(order - 1, length / 2,
upper_left_x + 0.25 * length,
upper_left_y + 0.433 * length)
S1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
window.add(S1)
S2 = GLine(upper_left_x, upper_left_y, upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
window.add(S2)
S3 = GLine(upper_left_x + 0.5 * length, upper_left_y + 0.866 * length,
upper_left_x + length, upper_left_y)
window.add(S3)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
if order == 0:
pass
else:
line_top = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line_left = GLine(upper_left_x, upper_left_y,
upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
line_right = GLine(upper_left_x + length, upper_left_y,
upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
window.add(line_top)
window.add(line_left)
window.add(line_right)
pause(50)
# upper left triangle
sierpinski_triangle(order - 1, 0.5 * length, upper_left_x,
upper_left_y)
# upper right triangle
sierpinski_triangle(order - 1, 0.5 * length,
upper_left_x + 0.5 * length, upper_left_y)
# lower triangle
sierpinski_triangle(order - 1, 0.5 * length,
upper_left_x + 0.25 * length,
upper_left_y + 0.433 * length)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
# break condition for recursion
if order == 0:
return
# draw triangle left edge
line_1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
window.add(line_1)
# draw triangle right edge
line_2 = GLine(upper_left_x, upper_left_y, upper_left_x + length / 2,
upper_left_y + length * math.sqrt(3) / 2)
window.add(line_2)
# draw triangle bottom edge
line_3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2,
upper_left_y + length * math.sqrt(3) / 2)
window.add(line_3)
# recursively draw the three smaller triangle
# upper left triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# upper right triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# bottom triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length / 2 * math.sqrt(3) / 2)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: int, the order of Sierpinski Triangle
:param length: int, the length of Sierpinski Triangle
:param upper_left_x: int, the upper left x coordinate of Sierpinski Triangle
:param upper_left_y: int, the upper left y coordinate of Sierpinski Triangle
"""
if order == 0:
pass
else:
top_s = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
left_s = GLine(upper_left_x, upper_left_y, upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
right_s = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(top_s)
window.add(left_s)
window.add(right_s)
sierpinski_triangle(order - 1, length * 0.5, upper_left_x,
upper_left_y)
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.5, upper_left_y)
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.5 * 0.5,
upper_left_y + length * 0.5 * 0.866)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
This function recursively prints a certain order of Sierpinski triangle.
:param order: Controls the order of Sierpinski triangle.
:param length: Controls the length of Sierpinski triangle.
:param upper_left_x: The x coordinate of the upper left vertex of a triangle.
:param upper_left_y: The y coordinate of the upper left vertex of a triangle.
"""
pause(10)
# Draw three line to create a triangle each time.
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5, upper_left_y + length * 0.866)
# Add lines to window.
window.add(line1)
window.add(line2)
window.add(line3)
# Pass when order reduce to 1.
if order == 1:
return
else:
# Execute three recursion respectively.
sierpinski_triangle(order - 1, length * 0.5, upper_left_x,
upper_left_y)
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.5, upper_left_y)
sierpinski_triangle(order - 1, length * 0.5,
upper_left_x + length * 0.25,
upper_left_y + length * 0.433)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: 畫到第幾層
:param length: 每一層三角形的邊常
:param upper_left_x: 每一層三角形的左上頂點的x座標
:param upper_left_y: 每一層三角形的左上頂點的y座標
:return: 畫好的遞迴三角形
"""
if order == 0: # Base Case
return
else: # Not Base Case
# 左上三角形最左邊頂點
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# 右上三角形最左邊頂點
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# 下方三角形最左邊頂點
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length / 2 * 0.866)
# 畫三角形
line_1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line_2 = GLine(upper_left_x, upper_left_y, upper_left_x + length / 2,
upper_left_y + length * 0.866)
line_3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2,
upper_left_y + length * 0.866)
window.add(line_1)
window.add(line_2)
window.add(line_3)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: level of triangles
:param length: the length of original triangle
:param upper_left_x: the initial x-coordination
:param upper_left_y: the initial y-coordination
:return: Sierpinski Triangle with specific order
"""
if order == 0:
return
else:
triangle_up = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
triangle_left = GLine(upper_left_x, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
triangle_right = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(triangle_up)
window.add(triangle_left)
window.add(triangle_right)
# triangle on the left : which has the same left corner as the biggest one
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# triangle on the right : which has the left corner on midpoint on the top one
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# triangle on the bottom : which has the left corner on midpoint on midpoint of left-side line
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * 0.866 / 2)
def lines():
"""
Draw lines from each side to center, alternating fade in each segment to create pattern.
:return: Nothing.
"""
for i in range(0, SEGMENTS * SIDES): # Start loop for total segments.
for x in range(0, LINES): # Start loop for lines in segment.
if i // SEGMENTS == 0: # Top side start points: x increment, y at top.
start_x = i % SEGMENTS * LINES + x # Increment starts after adding prior segment.
start_y = 0
elif i // SEGMENTS == 1: # Right side start points: x at right, y increment.
start_x = window.width
start_y = i % SEGMENTS * LINES + x
elif i // SEGMENTS == 2: # Bottom side start points: x decrement, y bottom.
start_x = window.width - (i % SEGMENTS * LINES + x) # Decrements by subtracting from edge.
start_y = window.height
elif i // SEGMENTS == 3: # Left side start points: x at left, y decrement.
start_x = 0
start_y = window.height - (i % SEGMENTS * LINES + x)
end_x = center_x # End points for line fixed at canvas center.
end_y = center_y
if i % 2 == 1: # Odd segments increment rgb values
rgb = x * INCREMENT
else: # Even segments decrement instead
rgb = LINES * INCREMENT - x * INCREMENT
line = GLine(start_x, start_y, end_x, end_y)
line.color = GColor(rgb, rgb, rgb)
window.add(line)
return
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
This function recursively prints the Sierpinski triangle on GWindow.
:param order: int, the order of Sierpinski Triangle
:param length: int, the length of order 1 Sierpinski Triangle
:param upper_left_x: int, the upper left x coordinate of order 1 Sierpinski Triangle
:param upper_left_y: int, the upper left y coordinate of order 1 Sierpinski Triangle
:return: nothing / this function only prints several tiangles
"""
if order == 0:
return
else:
# upper line of the triangle
triangle1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
# right line of triangle
triangle2 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2,
upper_left_y + length * 0.886)
# left line of the triangle
triangle3 = GLine(upper_left_x + length / 2,
upper_left_y + length * 0.886, upper_left_x,
upper_left_y)
window.add(triangle1)
window.add(triangle2)
window.add(triangle3)
# upper left triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# upper right triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# lower triangle
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + (length / 2 * 0.886))
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
This function helps draw the sierpinski triangle by using
recursion method.
------------------------------------------------
:param order: int, control when to end drawing
:param length: int, side length of the triangle
:param upper_left_x: int, the upper left x point of the triangle, which is also the start drawing point
:param upper_left_y: int, the upper left y point of the triangle, which is also the start drawing point
:return: None
"""
if order == 0:
return
else:
h = length * 0.866
w = length * 0.5
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x + length, upper_left_y, upper_left_x + w,
upper_left_y + h)
line3 = GLine(upper_left_x + w, upper_left_y + h, upper_left_x,
upper_left_y)
window.add(line1)
window.add(line2)
window.add(line3)
# Upper Left
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# Upper Right
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# Down
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + h / 2)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
if order == 0:
pass
else:
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
window.add(line1)
window.add(line2)
window.add(line3)
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
sierpinski_triangle(order - 1, length / 2,
upper_left_x + length * 0.252,
upper_left_y + length / 2 * 0.864)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
if order == 0:
return # 把function踢掉
else:
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + length / 2,
upper_left_y + length)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2, upper_left_y + length)
window.add(line1)
window.add(line2)
window.add(line3)
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length / 2)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: int, the times of triangle
:param length: the triangle side_length
:param upper_left_x: the upper_left x of the triangle
:param upper_left_y: the upper_left y of the triangle
:return: None
"""
pause(0)
if order == 1:
pass
else:
# ============================================ draw the triangle ============================================ #
l1 = GLine(upper_left_x + length * 0.5, upper_left_y,
upper_left_x + length // 2 * 0.5,
upper_left_y + length // 2 * H)
l2 = GLine(upper_left_x + length * 0.5, upper_left_y,
upper_left_x + length * 0.5 * 1.5,
upper_left_y + length // 2 * H)
l3 = GLine(upper_left_x + length // 2 * 0.5,
upper_left_y + length // 2 * H,
upper_left_x + length // 2 * 0.5 * 3,
upper_left_y + length // 2 * H)
# =========================================================================================================== #
sierpinski_triangle(order - 1, length // 2, upper_left_x, upper_left_y)
sierpinski_triangle(order - 1, length // 2,
upper_left_x + length * 0.5, upper_left_y)
sierpinski_triangle(order - 1, length // 2,
upper_left_x + length * 0.25,
upper_left_y + length / 2 * H)
window.add(l1)
window.add(l2)
window.add(l3)
def draw_line():
# Draw several vertical and horizontal lines.
for i in range(1, 10):
line_hor = GLine(0, i * 50, window.width, i * 50)
line_ver = GLine(i * 50, 0, i * 50, window.height)
window.add(line_hor)
window.add(line_ver)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: control how many times of loop
:param length: the length of the first triangle
:param upper_left_x: the upper left x coordinate
:param upper_left_y: the upper left y coordinate
:return: nothing
"""
if order == 0:
return
else:
# draw line to form a triangle
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5,
upper_left_y + 0.866 * length)
pause(20)
# add line on window
window.add(line1)
window.add(line2)
window.add(line3)
# enter recursion
# one at left, one at right, and one at the bottom
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
sierpinski_triangle(order - 1, length / 2, upper_left_x + 0.5 * length,
upper_left_y)
sierpinski_triangle(order - 1, length / 2,
upper_left_x + 0.25 * length,
upper_left_y + 0.433 * length)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: controls the order of Sierpinski Triangle
:param length: The length of the Sierpinski Triangle
:param upper_left_x: The upper left x coordinate of order 1 Sierpinski Triangle
:param upper_left_y: The upper left y coordinate of order 1 Sierpinski Triangle
:return: the Sierpinski Triangle
"""
if order == 0:
pass
else:
#pause(300)
# create a triangle
a = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
b = GLine(upper_left_x, upper_left_y, upper_left_x + length * 0.5,
upper_left_y + length * 0.866)
c = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length * 0.5, upper_left_y + length * 0.866)
window.add(a)
window.add(b)
window.add(c)
# add at upper left
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# add at upper right
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# add at bottom
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * 0.866 / 2)
def build_karel1():
"""
This function builds the first karel
"""
head = GOval(80, 55, x=190, y=167)
head.filled = True
head.color = 'black'
head.fill_color = 'gray'
window.add(head)
r_eye = GRect(13, 13, x=212, y=189)
r_eye.filled = True
r_eye.color = 'black'
r_eye.fill_color = 'blue'
window.add(r_eye)
l_eye = GRect(13, 13, x=235, y=189)
l_eye.filled = True
l_eye.color = 'black'
l_eye.fill_color = 'blue'
window.add(l_eye)
r_eyeb = GLine(212, 185, 225, 185)
window.add(r_eyeb)
l_eyeb = GLine(235, 185, 248, 185)
window.add(l_eyeb)
hands = GRect(105, 45, x=177, y=237)
hands.filled = True
hands.color = 'black'
hands.fill_color = 'lime'
window.add(hands)
body_1 = GRect(60, 65, x=201, y=223)
body_1.filled = True
body_1.color = 'black'
body_1.fill_color = 'blue'
window.add(body_1)
body_2 = GRect(80, 60, x=190, y=230)
body_2.filled = True
body_2.color = 'black'
body_2.fill_color = 'blue'
window.add(body_2)
r_foot = GOval(29, 24, x=190, y=290)
r_foot.filled = True
r_foot.color = 'black'
r_foot.fill_color = 'red'
window.add(r_foot)
l_foot = GOval(29, 24, x=241, y=290)
l_foot.filled = True
l_foot.color = 'black'
l_foot.fill_color = 'red'
window.add(l_foot)
label = GPolygon()
label.add_vertex((230, 130))
label.add_vertex((218, 150))
label.add_vertex((242, 150))
label.filled = True
label.fill_color = 'firebrick'
label.color = 'firebrick'
window.add(label)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order: the runs of recursion will be done
:param length: Sierpinski Triangle's length
:param upper_left_x: x position of the upper left Sierpinski Triangle
:param upper_left_y: x position of the upper left Sierpinski Triangle
:return: base case
"""
if order == 0:
return
else:
# create the first order triangle
line1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line2 = GLine(upper_left_x, upper_left_y, upper_left_x + length / 2,
upper_left_y + length * 0.866)
line3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2, upper_left_y + length * 0.866)
line1.color = 'magenta'
line2.color = 'magenta'
line3.color = 'magenta'
window.add(line1)
window.add(line2)
window.add(line3)
# upper left
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# upper right
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# lower one
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * 0.866 / 2)
def sierpinski_triangle(order, length, upper_left_x, upper_left_y):
"""
:param order:
:param length:
:param upper_left_x:
:param upper_left_y:
:return:
"""
if order == 0:
return
else:
tri1 = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
tri1.color = 'mediumblue'
tri2 = GLine(upper_left_x, upper_left_y, upper_left_x + length / 2,
upper_left_y + length * t_h)
tri2.color = 'steelblue'
tri3 = GLine(upper_left_x + length, upper_left_y,
upper_left_x + length / 2, upper_left_y + length * t_h)
tri3.color = 'dodgerblue'
window.add(tri1)
window.add(tri2)
window.add(tri3)
# Upper left triangle.
sierpinski_triangle(order - 1, length / 2, upper_left_x, upper_left_y)
# Upper right triangle.
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 2,
upper_left_y)
# Middle bottom triangle.
sierpinski_triangle(order - 1, length / 2, upper_left_x + length / 4,
upper_left_y + length * t_h / 2)
pause(PAUSE)
def plot_triangle(length, upper_left_x, upper_left_y):
line_up = GLine(upper_left_x, upper_left_y, upper_left_x + length,
upper_left_y)
line_left = GLine(upper_left_x, upper_left_y, upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length)
line_right = GLine(upper_left_x + 0.5 * length,
upper_left_y + 0.866 * length, upper_left_x + length,
upper_left_y)
window.add(line_up)
window.add(line_left)
window.add(line_right)
def draw_triangle(length, upper_left_x, upper_left_y): """ This function draws a triangle on GWindow. :param length: the length of Sierpinski Triangle :param upper_left_x: the upper left x coordinate of Sierpinski Triangle :param upper_left_y: the upper left y coordinate of Sierpinski Triangle """ line1 = GLine(upper_left_x, upper_left_y, upper_left_x+length, upper_left_y) line2 = GLine(upper_left_x, upper_left_y, upper_left_x+length*0.5, upper_left_y+length*0.866) line3 = GLine(upper_left_x+length*0.5, upper_left_y+length*0.866, upper_left_x + length, upper_left_y) window.add(line1) window.add(line2) window.add(line3)
def draw_first_triangle():
"""
draw the first triangle
"""
l1 = GLine(UPPER_LEFT_X, UPPER_LEFT_Y, UPPER_LEFT_X + LENGTH * 0.5,
UPPER_LEFT_Y + LENGTH * 0.866)
window.add(l1)
l2 = GLine(UPPER_LEFT_X, UPPER_LEFT_Y, UPPER_LEFT_X + LENGTH * 0.5 * 2,
UPPER_LEFT_Y)
window.add(l2)
l3 = GLine(UPPER_LEFT_X + LENGTH, UPPER_LEFT_Y,
UPPER_LEFT_X + LENGTH * 0.5, UPPER_LEFT_Y + LENGTH * 0.866)
window.add(l3)
def draw_line(point):
global first_point_x, first_point_y, first_hole
if first_point_x == 0 & first_point_y == 0:
first_hole = GOval(SIZE, SIZE, x=point.x - SIZE/2, y=point.y - SIZE/2) #圈圈在中間
window.add(first_hole)
first_point_x = point.x
first_point_y = point.y
else:
line = GLine(first_point_x,first_point_y,point.x,point.y)
window.add(line)
line.color = random_color()
window.remove(first_hole)
first_point_x = 0
first_point_y = 0
def point(a):
global count
global f_x
global f_y
global click1
count += 1
if count % 2 == 1:
window.add(click1, x=a.x - click1.width / 2, y=a.y - click1.height / 2)
f_x = a.x
f_y = a.y
else:
b_line = GLine(f_x, f_y, a.x, a.y)
b_line.color = 'black'
window.add(b_line)
window.remove(click1)
