def main():
points = [Point(x=230, y=450), Point(x=240, y=460), Point(x=230, y=470), Point(x=240, y=480)]
polygon(point_list=points)
points2 = [Point(p.x + 20, p.y + 20) for p in points]
lines(point_list=points2, color=COLOR_DARK_ORANGE)
line(start_point=Point(x=20, y=20), end_point=Point(x=40, y=300))
square(left_bottom=Point(400, 300, ), side=100)
rectangle(
left_bottom=Point(x=200, y=200),
right_top=Point(x=300, y=300),
color=COLOR_DARK_GREEN
)
rectangle(
left_bottom=Point(x=400, y=300),
right_top=Point(x=300, y=400),
color=COLOR_DARK_GREEN
)
sleep(2)
clear_screen()
vector(start=Point(x=230, y=260), angle=70, length=200, color=COLOR_PURPLE)
for i in range(10):
point = random_point()
color = random_color()
radius = random_number(20, 60)
circle(center_position=point, radius=radius, color=color, width=0)
sleep(2)
clear_screen()
for i in range(10):
point = random_point()
color = random_color()
dx = random_number(30, 100)
dy = random_number(30, 100)
right_top = Point(x=point.x + dx, y=point.y + dy)
ellipse(left_bottom=point, right_top=right_top, color=color)
v3 = Vector(start_point=Point(0, 0), direction=45, length=50)
for direction in range(0, 181, 20):
v = Vector(start_point=Point(x=300, y=300), direction=direction, length=100)
v.draw()
v2 = Vector(start_point=v.end_point, direction=direction + 30, length=50)
v2.draw(color=COLOR_GREEN)
v2.add(v3)
v2.draw(color=COLOR_ORANGE)
snowflake(center=Point(), length=60, factor_b=0.2, factor_c=100)
sleep(2)
for k in range(2):
y = 500
for i in range(10):
clear_screen()
y -= 30
for x in [100, 200, 300, 400, 500]:
radius = random_number(30, 50)
point = Point(x=x, y=y)
snowflake(center=point, length=radius)
mouse_point, mouse_buttons = get_mouse_state()
print("mouse_state is {} + {}".format(mouse_point, mouse_buttons))
if user_want_exit(sleep_time=0.1):
break
if user_want_exit(0):
break
def __init__(self):
self.length = sd.random_number(10, 101)
self.x = sd.random_number(0, sd.resolution[0])
self.y = sd.randint(sd.resolution[1] - 100, sd.resolution[1] + 100)
self.factor_a = sd.random_number(10, 100) / 100
self.factor_b = sd.random_number(10, 100) / 100
self.factor_c = sd.random_number(10, 100)
def move(self):
if self.x > 250:
self.x += sd.random_number(-14, 12)
self.y -= sd.random_number(4, 21)
else:
self.x += sd.random_number(-6, 18)
self.y -= sd.random_number(4, 21)
def draw_bunches(start_point, angle1, length, count_color_tree):
if length < 5:
return
if count_color_tree < 5:
v1 = sd.get_vector(start_point=start_point,
angle=angle1,
length=length)
v1.draw(color=sd.COLOR_PURPLE, width=2)
v1.draw()
else:
v1 = sd.get_vector(start_point=start_point,
angle=angle1,
length=length)
v1.draw(color=sd.COLOR_GREEN, width=2)
v1.draw()
next_count_color_tree = count_color_tree + 1
next_point = v1.end_point
next_angle1 = angle1 - sd.random_number(30 - 30 * .4, 30 + 30 * .4)
next_length = length * random.uniform(.75 - .75 * .2, .75 + .75 * .2)
draw_bunches(start_point=next_point,
angle1=next_angle1,
length=next_length,
count_color_tree=next_count_color_tree)
next_point = v1.end_point
next_angle1 = angle1 + sd.random_number(30 - 30 * .4, 30 + 30 * .4)
next_length = length * random.uniform(.75 - .75 * .2, .75 + .75 * .2)
draw_bunches(start_point=next_point,
angle1=next_angle1,
length=next_length,
count_color_tree=next_count_color_tree)
def leaves_fall(x_coordinates, y_coordinates, endpoint_of_laves_fall):
sd.start_drawing()
for index, x in enumerate(x_coordinates):
if y_coordinates[index] > endpoint_of_laves_fall:
# Назначаю рандомное значение падения и отклонения на каждом шагу
random_step_x = sd.random_number(-30, 30)
random_step_y = sd.random_number(5, 15)
# Создаю точку и рисую снежинку цветом фона
left_bottom_point = sd.get_point(x_coordinates[index],
y_coordinates[index])
right_top_point = sd.get_point(x_coordinates[index] + 3,
y_coordinates[index] + 3)
sd.ellipse(left_bottom=left_bottom_point,
right_top=right_top_point,
color=sd.background_color)
# Изменяю координаты
x_coordinates[index] += random_step_x
y_coordinates[index] -= random_step_y
# Создаю точку и рисую лист
left_bottom_point = sd.get_point(x_coordinates[index],
y_coordinates[index])
right_top_point = sd.get_point(x_coordinates[index] + 3,
y_coordinates[index] + 3)
sd.ellipse(left_bottom=left_bottom_point,
right_top=right_top_point,
color=sd.COLOR_DARK_RED)
sd.finish_drawing()
def tree_with_leaves_draw(point, angle, length, width, list_of_endpoints):
color = sd.COLOR_DARK_ORANGE
delta_angle1 = sd.random_number(18, 42)
delta_angle2 = sd.random_number(18, 42)
delta_length1 = (sd.random_number(60, 90)) * 0.01
delta_length2 = (sd.random_number(60, 90)) * 0.01
if length < 2:
list_of_endpoints.append([point.x, point.y])
return
if length < 8:
color = sd.COLOR_DARK_GREEN
branch1 = sd.get_vector(start_point=point,
angle=angle,
length=length,
width=width)
next_angle1 = angle + delta_angle1
next_angle2 = angle - delta_angle2
next_length1 = length * delta_length1
next_length2 = length * delta_length2
branch1.draw(color=color)
tree_with_leaves_draw(point=branch1.end_point,
angle=next_angle1,
length=next_length1,
width=int(width),
list_of_endpoints=list_of_endpoints)
tree_with_leaves_draw(point=branch1.end_point,
angle=next_angle2,
length=next_length2,
width=int(width),
list_of_endpoints=list_of_endpoints)
return list_of_endpoints
def snowflakes():
global height_snow
for i in range(N):
x = snowflake_points[i][0]
y = snowflake_points[i][1]
length = snowflake_points[i][2]
point = sd.get_point(x, y)
factor_a = snowflake_points[i][3]
factor_b = snowflake_points[i][4]
factor_c = snowflake_points[i][5]
sd.snowflake(point,
length,
color=sd.background_color,
factor_a=factor_a,
factor_b=factor_b,
factor_c=factor_c)
y -= sd.random_number(0, 3)
x += sd.random_number(-5, 5)
snowflake_points[i] = [x, y, length, factor_a, factor_b, factor_c]
if y < height_snow:
snowflake_points[i][1] = sd.random_number(550, 600)
height_snow += .5
point = sd.get_point(x, y)
sd.snowflake(point,
length,
factor_a=factor_a,
factor_b=factor_b,
factor_c=factor_c)
def draw_branches_rand(start_point, angle, length):
if length < 5:
return
v1 = sd.get_vector(start_point=start_point,
angle=angle + sd.random_number(15, 25),
length=length,
width=1)
v2 = sd.get_vector(start_point=start_point,
angle=angle - sd.random_number(15, 25),
length=length,
width=1)
v1.draw()
v2.draw()
next_point1 = v1.end_point
next_point2 = v2.end_point
next_angle1 = angle + sd.random_number(15, 25)
next_angle2 = angle - sd.random_number(15, 25)
random_number = rand.random()
if random_number < 0.25:
next_length = length * (0.72 + random_number)
elif random_number > 0.75:
next_length = length * (0.9 * random_number)
else:
next_length = length * 0.6
draw_branches_rand(start_point=next_point1,
angle=next_angle1,
length=next_length)
draw_branches_rand(start_point=next_point2,
angle=next_angle2,
length=next_length)
def draw_branches(point, angle, length):
if length < 10:
return
random_with = sd.random_number(1, 3)
random_angle = sd.random_number(-12, 12)
angle_1 = angle + 30 + random_angle
v1 = sd.get_vector(start_point=point,
angle=angle_1,
length=length,
width=random_with)
v1.draw()
angle_2 = angle - 30 + random_angle
v2 = sd.get_vector(start_point=point,
angle=angle_2,
length=length,
width=random_with)
v2.draw()
random_length = sd.random_number(-15, 15) / 100
draw_branches(point=v1.end_point,
angle=angle_1,
length=length * (.75 + random_length))
draw_branches(point=v2.end_point,
angle=angle_2,
length=length * (.75 + random_length))
def snow(y_drop):
drift = 5
sd.start_drawing()
for snowflake in range(N):
point = sd.get_point(x_coordinates_list[snowflake],
y_coordinates_list[snowflake])
sd.snowflake(center=point,
length=length_list[snowflake],
color=sd.background_color)
if y_coordinates_list[snowflake] > drift and x_coordinates_list[
snowflake] < 300:
y_coordinates_list[snowflake] -= y_drop
random_vector = sd.random_number(-8, 8)
if length_list[snowflake] < 35:
x_coordinates_list[snowflake] = x_coordinates_list[
snowflake] + random_vector * 1.4
else:
x_coordinates_list[
snowflake] = x_coordinates_list[snowflake] + random_vector
point_new = sd.get_point(x_coordinates_list[snowflake],
y_coordinates_list[snowflake])
sd.snowflake(center=point_new, length=length_list[snowflake])
else:
sd.snowflake(center=point, length=length_list[snowflake])
x_coordinates_list[snowflake] = sd.random_number(30, 200)
y_coordinates_list[snowflake] = sd.random_number(500, 900)
length_list[snowflake] = sd.random_number(1, 10)
drift += 0.1
sd.finish_drawing()
sd.sleep(0.02)
def draw_branches(start_point, angle, length, delta):
if length < 4:
return
v1 = sd.get_vector(
start_point,
angle=angle,
length=length,
)
v1.draw()
next_point = v1.end_point
x = int(30 / 100 * 40)
y = int(length / 100 * 20)
length = sd.random_number(length - y, length + y)
delta = sd.random_number(delta - x, delta + x)
next_length = int(0.75 * length)
draw_branches(
start_point=next_point,
angle=angle + delta,
length=next_length,
delta=delta,
)
draw_branches(
start_point=next_point,
angle=angle - delta,
length=next_length,
delta=delta,
)
def create_snowflakes(quantity=20,
resolution=(1200, 600),
len_beam_min_max=(15, 35)):
global quantity_snow_flakes, center_and_beams_snowflakes, lst_factor
count_create = quantity
quantity_snow_flakes += quantity
coord_x = (-100, resolution[0] + 100)
coord_y = (resolution[1] + 70, resolution[1] * 2)
for i in range(count_create):
coord_center_len_beam = []
x = sd.random_number(coord_x[0], coord_x[1])
y = sd.random_number(coord_y[0], coord_y[1])
len_beam = sd.random_number(len_beam_min_max[0], len_beam_min_max[1])
factor_a = rd.choice(lst_factor[0])
factor_b = rd.choice(lst_factor[1])
factor_c = rd.choice(lst_factor[2])
coord_center_len_beam.append(x)
coord_center_len_beam.append(y)
coord_center_len_beam.append(len_beam)
coord_center_len_beam.append(factor_a)
coord_center_len_beam.append(factor_b)
coord_center_len_beam.append(factor_c)
center_and_beams_snowflakes.append(coord_center_len_beam)
print("Снежинок стало", quantity_snow_flakes)
return quantity_snow_flakes
def create_snowflakes_pos(quantity=20,
position_add=0,
resolution=(1200, 600),
len_beam_min_max=(15, 20)):
global quantity_snow_flakes, center_and_beams_snowflakes, lst_factor
count_create = quantity
coord_x = (-100, resolution[0] + 100)
coord_y = (resolution[1] + 70, resolution[1] * 2)
if quantity != 1:
quantity_snow_flakes = quantity
else:
quantity_snow_flakes += 1
for i in range(count_create):
coord_center_len_beam = []
x = sd.random_number(coord_x[0], coord_x[1])
y = sd.random_number(coord_y[0], coord_y[1])
len_beam = sd.random_number(len_beam_min_max[0], len_beam_min_max[1])
factor_a = rd.choice(lst_factor[0])
factor_b = rd.choice(lst_factor[1])
factor_c = rd.choice(lst_factor[2])
coord_center_len_beam.append(x)
coord_center_len_beam.append(y)
coord_center_len_beam.append(len_beam)
coord_center_len_beam.append(factor_a)
coord_center_len_beam.append(factor_b)
coord_center_len_beam.append(factor_c)
if count_create != 1:
center_and_beams_snowflakes.append(coord_center_len_beam)
else:
center_and_beams_snowflakes.insert(position_add,
coord_center_len_beam)
def snowflake():
ground_level = 50
k = 0
while True:
sd.start_drawing()
for i in snowflakes_param:
x = i[0]
y = i[1]
point = sd.get_point(x, y)
snowflake_length = i[2]
sd.snowflake(center=point,
length=snowflake_length,
color=sd.background_color)
i[1] -= sd.random_number(0, 20)
i[0] += sd.random_number(-20, 20)
point_1 = sd.get_point(i[0], i[1])
sd.snowflake(center=point_1,
length=snowflake_length,
color='white')
if y < ground_level:
ind = snowflakes_param.index(i)
fallen.append(snowflakes_param.pop(ind))
flake_add(snowflakes_param, 1)
k += 1
if k >= 10:
ground_level += 5
k = 0
sd.finish_drawing()
sd.sleep(0.1)
if sd.user_want_exit():
break
def snowflakes_step():
global _index
for _index, x in enumerate(_x_coordinates):
random_step_x = sd.random_number(-30, 30)
random_step_y = sd.random_number(5, 15)
_x_coordinates[_index] += random_step_x
_y_coordinates[_index] -= random_step_y
def draw_branches_random(
start_point=sd.get_point(800, 0), angle=90.0, length=70.0, delta=30):
# Изменил аргументы по умолчанию с целых чисел на числа с плавающей запятой.
# Так не будет замечаний среды разработки.
# start_point = sd.get_point(800, 0)
# length = 70
# angle = 90
# delta = 30
if length < 5:
return
if length < 10:
color = sd.COLOR_GREEN
# Замените второй if на else, чтобы убрать предупреждение
# о том, что переменная color может не существовать.
else:
color = (91, 58, 41)
v1 = sd.get_vector(start_point, angle=angle, length=length, width=2)
v1.draw(color)
next_point = v1.end_point
variance_length = float(sd.random_number(6, 9) / 10)
variance_angle = float(sd.random_number(12, 42))
next_angle = angle - variance_angle
next_length = length * variance_length
draw_branches_random(start_point=next_point,
angle=next_angle,
length=next_length,
delta=delta)
next_angle = angle + variance_angle
draw_branches_random(start_point=next_point,
angle=next_angle,
length=next_length,
delta=delta)
def snowflakes(_x1, _y1, _x2, _y2):
def new_snowflake():
_x = sd.random_number(_x1, _y1)
_y = sd.random_number(_x2, _y2)
_length = sd.random_number(10, 20)
_my_dict = {'x': _x, 'y': _y, 'length': _length}
snowflakes[i] = _my_dict
snowflakes = {}
for i in range(50):
new_snowflake()
while True:
sd.start_drawing()
for i, snowflake in snowflakes.items():
sd.snowflake(center=sd.get_point(snowflake['x'], snowflake['y']), length=snowflake['length'],
color=sd.background_color)
snowflake['y'] -= 10
if snowflake['x'] >= 340:
snowflake['x'] += sd.random_number(-51, -50)
snowflake['x'] += sd.random_number(-50, 50)
sd.snowflake(center=sd.get_point(snowflake['x'], snowflake['y']), length=snowflake['length'],
color=sd.COLOR_WHITE)
if snowflake['y'] < snowflake['length']:
new_snowflake()
continue
sd.sleep(0.005)
sd.finish_drawing()
if sd.user_want_exit():
break
sd.pause()
def rand_delta(number, percent=50, is_positive=False):
if is_positive:
rand = sd.random_number(0, percent * 10) / 1000
else:
rand = sd.random_number(-percent * 10, percent * 10) / 1000
return number * rand
def create_snowflakes(n):
for quantity_snowflakes in range(n):
x = sd.random_number(50, 1000)
y = sd.random_number(720, 800)
length_of_snowflake = sd.random_number(10, 25)
snowflake = [x, y, length_of_snowflake]
snowflakes.append(snowflake)
def __init__(self):
self.length = sd.random_number(5, 15)
self.x = sd.random_number(0, sd.resolution[0])
self.y = 700
self.factor_a = sd.random_number(1, 10) / 10
self.factor_b = sd.random_number(1, 10) / 10
self.factor_c = sd.random_number(10, 120)
def create_flake(count_flake):
global _fallen_flake
_fallen_flake = []
global _snow_params
_snow_params = []
for _ in range(count_flake):
_snow_params.append([sd.random_number(0, 1000), sd.random_number(500, 600), sd.random_number(20, 40)])
def tree_draw(point, angle, length, width):
color = sd.COLOR_DARK_ORANGE
delta_angle1 = sd.random_number(18, 42)
delta_angle2 = sd.random_number(18, 42)
delta_length1 = (sd.random_number(60, 90)) * 0.01
delta_length2 = (sd.random_number(60, 90)) * 0.01
if length < 2:
return
if length < 8:
color = sd.COLOR_DARK_GREEN
branch1 = sd.get_vector(start_point=point,
angle=angle,
length=length,
width=width)
next_angle1 = angle + delta_angle1
next_angle2 = angle - delta_angle2
next_length1 = length * delta_length1
next_length2 = length * delta_length2
branch1.draw(color=color)
tree_draw(point=branch1.end_point,
angle=next_angle1,
length=next_length1,
width=int(width))
tree_draw(point=branch1.end_point,
angle=next_angle2,
length=next_length2,
width=int(width))
def snowflakes(quantity):
x_list = []
y_list = []
size_list = []
length_list = []
for _ in range(quantity):
new_x = sd.random_number(50, 1150)
x_list.append(new_x)
new_y = sd.random_number(0, 600)
y_list.append(new_y)
new_size = sd.random_number(10, 40)
size_list.append(new_size)
new_length = round(sd.random_number(10, 90) / 100, 1)
length_list.append(new_length)
while True:
sd.start_drawing()
sd.clear_screen()
for i, x in enumerate(x_list):
if y_list[i] < 0:
y_list[i] = 600
point = sd.get_point(x_list[i], y_list[i])
sd.snowflake(center=point, length=size_list[i], factor_b=length_list[i])
y_list[i] -= 10
sd.finish_drawing()
sd.sleep(0.1)
if sd.user_want_exit():
break
def snow_create(N):
global snow_list
for i in range(N):
x = sd.random_number(10, sd.resolution[0])
y = sd.random_number(sd.resolution[1] - 10, sd.resolution[1])
len_i = sd.random_number(10, 35)
snow_list.append([x, y, len_i])
def snowfall(coord_x=0, coord_y=500):
count_snowfall = 20
x = []
for _ in range(count_snowfall):
x.append(sd.random_number(coord_x, coord_y))
y = []
for _ in range(count_snowfall):
y.append(sd.random_number(coord_x, coord_y))
while True:
sd.start_drawing()
for i in range(len(x)):
if i > 0:
point1 = sd.get_point(x[i - 1], y[i - 1])
sd.snowflake(center=point1, length=10, color=sd.COLOR_WHITE)
point = sd.get_point(x[i], y[i])
if y[i] > 50:
sd.snowflake(center=point,
length=10,
color=sd.background_color)
y[i] -= sd.random_number(-1, 15)
x[i] = x[i] + sd.random_number(-15, 15)
sd.finish_drawing()
sd.sleep(0.1)
def draw_branches(starting_point,
angle,
length,
width=10,
color=sd.COLOR_ORANGE):
if length < 10:
return
if width <= 2:
width = 2
if length < 15:
width = 9
color = sd.COLOR_GREEN
v1 = sd.get_vector(start_point=starting_point,
angle=angle + sd.random_number(17, 47),
length=length)
v1.draw(width=width, color=color)
v2 = sd.get_vector(start_point=starting_point,
angle=angle - sd.random_number(17, 47),
length=length)
v2.draw(width=width, color=color)
start_point_v1 = v1.end_point
start_point_v2 = v2.end_point
random_len_v1 = sd.random_number(60, 90) / 100
random_len_v2 = sd.random_number(60, 90) / 100
draw_branches(start_point_v1, angle + 30, length * random_len_v1,
width - 2)
draw_branches(start_point_v2, angle - 30, length * random_len_v2,
width - 2)
def append_flakes(count):
for _ in range(count):
_flake = Snowflake()
_flake.x = sd.random_number(a=0, b=sd.resolution[0])
_flake.y = sd.random_number(a=sd.resolution[1] - 30,
b=sd.resolution[1])
flakes.append(_flake)
def draw_branches(point, angle, length=100):
if length < 10:
return
vector = sd.get_vector(start_point=point,
angle=angle,
length=length,
width=2)
vector.draw()
next_point = vector.end_point
delta = 30
delta_deviation = delta * 0.4
delta += sd.random_number(-delta_deviation, delta_deviation)
length = length * 0.75
length_deviation = round(length * 0.2)
length += sd.random_number(0, length_deviation)
next_angle = round(angle + delta)
draw_branches(next_point, next_angle, length)
next_angle = round(angle - delta)
draw_branches(next_point, next_angle, length)
def falling_snowflake():
snowflakes_length = [sd.random_number(10, 101) for _ in range(20)]
snowflakes_point = {
i: [sd.random_number(0, 500), 500, i]
for i in range(20)
}
old_points_arr = [[snowflakes_point[key][0], snowflakes_point[key][1]]
for key, val in snowflakes_point.items()]
while True:
sd.start_drawing()
for i in range(20):
if len(old_points_arr) < 20:
sd.snowflake(center=old_points_arr[i],
length=snowflakes_length[i],
color=sd.background_color)
x, y, delay = snowflakes_point[i]
if delay < 1:
point = sd.get_point(x, y)
sd.snowflake(center=sd.Point(old_points_arr[i][0],
old_points_arr[i][1]),
length=snowflakes_length[i],
color=sd.background_color)
sd.snowflake(center=point, length=snowflakes_length[i])
if y < 20:
snowflakes_point[i][1] = 500
continue
snowflakes_point[i][1] -= 9
snowflakes_point[i][0] += sd.random_number(-10, 10)
old_points_arr[i] = [x, y]
snowflakes_point[i][2] -= .2
sd.finish_drawing()
sd.sleep(0.1)
if sd.user_want_exit():
break
def next_random_branches(angle, length, next_point1, next_point2,
random_sign, color):
random_angle = sd.random_number(1, 12)
random_length = sd.random_number(1, 15)
if random_sign == 0:
next_angle1 = angle + (30 - random_angle)
next_angle2 = angle - (30 + random_angle)
next_length = length * (.75 - random_length / 100)
draw_branches(start_point=next_point1,
angle=next_angle1,
length=next_length,
color=color)
draw_branches(start_point=next_point2,
angle=next_angle2,
length=next_length,
color=color)
else:
next_angle1 = angle + (30 + random_angle)
next_angle2 = angle - (30 - random_angle)
next_length = length * (.75 + random_length / 100)
draw_branches(start_point=next_point1,
angle=next_angle1,
length=next_length,
color=color)
draw_branches(start_point=next_point2,
angle=next_angle2,
length=next_length,
color=color)
def __init__(self, y_min=0):
self.x = sd.random_number(0, sd.resolution[0])
self.y = sd.random_number(y_min, sd.resolution[1])
self.branch_len = sd.random_number(5, 15)
self.speed = sd.random_number(3, 8)
self.color = sd.COLOR_WHITE
self.move_flag = True
