Guest User

Untitled

a guest
Oct 18th, 2018
87
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.06 KB | None | 0 0
  1. """PyGame project
  2. Developer Ermokhin Stanislav Alexandrovich"""
  3.  
  4. import pygame
  5. from random import random
  6. from math import sqrt
  7.  
  8. SCREEN_SIZE = (1280, 720)
  9.  
  10.  
  11. class Py(object):
  12. """A fine class"""
  13.  
  14. game_display = pygame.display.set_mode(SCREEN_SIZE)
  15.  
  16. def __init__(self, _object=None):
  17. """A fine method"""
  18.  
  19. self._object = _object
  20. self.game_display = Py.game_display
  21. pygame.display.set_caption("Screen Saver")
  22.  
  23. self.steps = 20
  24. self.working = True
  25. self.points = []
  26. self.speeds = []
  27. self.show_help = False
  28. self.pause = False
  29.  
  30. self.color_param = 0
  31. self.color = pygame.Color(0)
  32.  
  33. def display_help(self):
  34. """A fine method"""
  35.  
  36. self.game_display.fill((50, 50, 50))
  37. font1 = pygame.font.SysFont("arial", 30)
  38. font2 = pygame.font.SysFont("serif", 30)
  39. data = [["F1", "Помощь"],
  40. ["R", "Перезапуск"],
  41. ["P", "Воспроизвести / Пауза"],
  42. ["Num+", "Добавить точку"],
  43. ["Num-", "Удалить точку"],
  44. ["W", "Быстрее (>> в обратную сторону)"],
  45. ["S", "Медленнее (>> в обратную сторону)"],
  46. ["BACKSPACE", "Удалить точку"],
  47. ["", ""],
  48. [str(self.steps), "текущих точек"]]
  49.  
  50. pygame.draw.lines(self.game_display, (255, 50, 50, 255), True, [
  51. (0, 0), (800, 0), (800, 600), (0, 600)], 5)
  52. for item, text in enumerate(data):
  53. self.game_display.blit(font1.render(
  54. text[0], True, (128, 128, 255)), (50, 100 + 30 * item))
  55. self.game_display.blit(font2.render(
  56. text[1], True, (128, 128, 255)), (200, 100 + 30 * item))
  57.  
  58. def main(self):
  59. """A fine main"""
  60.  
  61. pygame.init()
  62.  
  63. while self.working:
  64. for event in pygame.event.get():
  65. if event.type == pygame.QUIT:
  66. self.working = False
  67. if event.type == pygame.KEYDOWN:
  68. if event.key == pygame.K_ESCAPE:
  69. self.working = False
  70. if event.key == pygame.K_r:
  71. self.points = []
  72. self.speeds = []
  73. if event.key == pygame.K_p:
  74. self.pause = not self.pause
  75. if event.key == pygame.K_KP_PLUS:
  76. self.steps += 1
  77. if event.key == pygame.K_F1:
  78. self.show_help = not self.show_help
  79. if event.key == pygame.K_KP_MINUS:
  80. self.steps -= 1 if self.steps > 1 else 0
  81. if event.key == pygame.K_w:
  82. self.speeds = [(x+2, y+2) for (x, y) in self.speeds]
  83. if event.key == pygame.K_s:
  84. self.speeds = [(x-2, y-2) for (x, y) in self.speeds]
  85.  
  86. if event.key == pygame.K_BACKSPACE:
  87. self._object.del_point(self.points, self.speeds)
  88.  
  89. if event.type == pygame.MOUSEBUTTONDOWN:
  90. self.points.append(event.pos)
  91. if not len(self.speeds) == 0:
  92. self.speeds.append(self.speeds[-1])
  93.  
  94. else:
  95. self.speeds.append((random() * 2, random() * 2))
  96.  
  97. self.game_display.fill((0, 0, 0))
  98. self.color_param = (self.color_param + 1) % 360
  99. self.color.hsla = (self.color_param, 100, 50, 100)
  100. self._object.static_draw_points(self.points)
  101. self._object.static_draw_points(self._object.get_joint(self.steps), "line", 4, self.color)
  102. if not self.pause:
  103. self._object.set_points()
  104. if self.show_help:
  105. self.display_help()
  106.  
  107. pygame.display.flip()
  108.  
  109. pygame.display.quit()
  110. pygame.quit()
  111. exit(0)
  112.  
  113.  
  114. class Vector(object):
  115. """A fine class"""
  116.  
  117. def __init__(self, x1=0, x2=0):
  118. """A fine method"""
  119.  
  120. self.x1 = x1
  121. self.x2 = x2
  122.  
  123. def __getitem__(self, item):
  124. """A fine method"""
  125.  
  126. return self.x1 if item == 0 else self.x2
  127.  
  128. def __repr__(self):
  129. """A fine method"""
  130.  
  131. return self.x1, self.x2
  132.  
  133. def __str__(self):
  134. """A fine method"""
  135.  
  136. return str(self.x1) + ' ' + str(self.x2)
  137.  
  138. def __add__(self, other):
  139. """A fine method"""
  140.  
  141. return Vector(self.x1 + other.x1, self.x2 + other.x2)
  142.  
  143. def __sub__(self, other):
  144. """A fine method"""
  145.  
  146. return Vector(self.x1 - other.x1, self.x2 - other.x2)
  147.  
  148. def __mul__(self, k):
  149. """A fine method"""
  150.  
  151. return Vector(self.x1 * k, self.x2 * k)
  152.  
  153. def length(self):
  154. """A fine method"""
  155.  
  156. return sqrt(self.x1 * self.x1 + self.x2 * self.x2)
  157.  
  158. def int_pair(self):
  159. """A fine method"""
  160.  
  161. try:
  162. return int(self.x1), int(self.x2)
  163.  
  164. except ValueError:
  165. return 0, 0
  166.  
  167.  
  168. class Line(Py):
  169. """A fine class"""
  170.  
  171. def __init__(self, obj):
  172. """A fine method"""
  173.  
  174. super().__init__(obj)
  175.  
  176. def set_points(self):
  177. """A fine method"""
  178.  
  179. for point in range(len(self.points)):
  180. self.points[point] = Vector(self.points[point][0], self.points[point][1]) + \
  181. Vector(self.speeds[point][0], self.speeds[point][1])
  182. if self.points[point][0] > SCREEN_SIZE[0] or self.points[point][0] < 0:
  183. self.speeds[point] = (- self.speeds[point][0], self.speeds[point][1])
  184. if self.points[point][1] > SCREEN_SIZE[1] or self.points[point][1] < 0:
  185. self.speeds[point] = (self.speeds[point][0], -self.speeds[point][1])
  186.  
  187. def draw_points(self, style="points",
  188. width=4, color=(255, 255, 255)):
  189. """A fine method"""
  190.  
  191. if style == "line":
  192. for point_number in range(-1, len(self.points) - 1):
  193. pygame.draw.line(self.game_display, color,
  194. Vector(self.points[point_number][0],
  195. self.points[point_number][1]).int_pair(),
  196. Vector(self.points[point_number + 1][0],
  197. self.points[point_number + 1][1]).int_pair(), width)
  198.  
  199. elif style == "points":
  200. for point in self.points:
  201. pygame.draw.circle(self.game_display, color,
  202. Vector(point[0], point[1]).int_pair(), width)
  203.  
  204. @staticmethod
  205. def static_draw_points(lst, style="points",
  206. width=4, color=(255, 255, 255)):
  207. """A fine method"""
  208.  
  209. points = lst
  210. game_display = Line.game_display
  211.  
  212. if style == "line":
  213. for point_number in range(-1, len(points) - 1):
  214. pygame.draw.line(game_display, color,
  215. Vector(points[point_number][0],
  216. points[point_number][1]).int_pair(),
  217. Vector(points[point_number + 1][0],
  218. points[point_number + 1][1]).int_pair(), width)
  219.  
  220. elif style == "points":
  221. for point in points:
  222. pygame.draw.circle(game_display, color,
  223. Vector(point[0], point[1]).int_pair(), width)
  224.  
  225. @staticmethod
  226. def get_point(points, alpha, deg=None):
  227. """A fine method"""
  228.  
  229. if deg is None:
  230. deg = len(points) - 1
  231. if deg == 0:
  232. return points[0]
  233.  
  234. a = Joint.get_point(points, alpha, deg - 1)
  235.  
  236. return Vector(points[deg][0], points[deg][1])*alpha + Vector(a[0], a[1])*(1 - alpha)
  237.  
  238. def get_points(self, base_points, count):
  239. """A fine method"""
  240.  
  241. alpha = 1 / count
  242. result = list()
  243. for i in range(count):
  244. result.append(self.get_point(base_points, i * alpha))
  245. return result
  246.  
  247. @staticmethod
  248. def del_point(lst1, lst2, point=None):
  249. """A fine method"""
  250.  
  251. if point is None and len(lst1) != 0:
  252. lst1.pop()
  253. lst2.pop()
  254.  
  255. elif len(lst1) != 0:
  256. lst1.pop(point)
  257. lst2.pop(point)
  258.  
  259.  
  260. class Joint(Line):
  261. """A fine class"""
  262.  
  263. def __init__(self):
  264. """A fine method"""
  265.  
  266. super().__init__(self)
  267.  
  268. def get_joint(self, count):
  269. """A fine method"""
  270.  
  271. if len(self.points) < 3:
  272. return []
  273.  
  274. result = list()
  275.  
  276. for i in range(-2, len(self.points) - 2):
  277. pnt = list()
  278. pnt.append((Vector(self.points[i][0], self.points[i][1]) +
  279. Vector(self.points[i + 1][0], self.points[i + 1][1]))*0.5)
  280. pnt.append(Vector(self.points[i + 1][0], self.points[i + 1][1]))
  281. pnt.append((Vector(self.points[i + 1][0], self.points[i + 1][1]) +
  282. Vector(self.points[i + 2][0], self.points[i + 2][1]))*0.5)
  283.  
  284. result.extend(self._object.get_points(pnt, count))
  285.  
  286. return result
  287.  
  288.  
  289. Joint().main()
Add Comment
Please, Sign In to add comment