from pygame.locals import *
from random import randrange as rand
import pygame
import math

DELTA_TIME = 0.0001

def rad(n):
	return (n/360.0 - int(n/360.0)) * 360

class Point:
	def __init__(self, x, y):
		self.pos = [x, y]

		self.val = rand(0, 8)

		self.color = (255, 255, 255)

		self.spin = rand(1, 360)
		self.r = 0
		self.vel = 20

	def update(self):
		self.spin = rad(self.spin) * DELTA_TIME

		range = 5
		self.r += rand(int(self.spin-range), int(self.spin+range))

		self.r = rad(self.r)

		rr = math.radians(self.r)
		self.pos[0] += math.cos(rr) * self.vel * DELTA_TIME
		self.pos[1] += math.sin(rr) * self.vel * DELTA_TIME

class World:
	def __init__(self, scale):
		self.points = [
			Point(rand(0, scale[0]), rand(0, 30)) for x in xrange(50)
		]
		self.map = [[0] * scale[0] for x in xrange(scale[1])]
		self.scale = scale
		self.can_update = False

	def update(self):
		self.can_update = True

	def render(self, sf):
		sf.fill(0)

		for p in self.points:
			if self.can_update:
				p.update()

			if p.pos[0] < 0: p.pos[0] = self.scale[0] -1
			elif p.pos[0] > self.scale[0]: p.pos[0] = 0
			if p.pos[1] < 0: p.pos[1] = self.scale[1] -1
			elif p.pos[1] > self.scale[1]: p.pos[1] = 0

			ipos = [int(p.pos[0]), int(p.pos[1])]
			self.map[ipos[1]][ipos[0]] = p

			m = 2
			if self.can_update:
				r = self.map[ipos[1]-m : ipos[1]+m]
				t = []
				for x in r: t += x[ipos[0]-m:ipos[0]+m]

				spin = p.spin
				c = 1
				for pe in t:
					if pe != 0:
						spin += pe.spin
						c += 1
				p.spin = spin / float(c)

			sf.set_at(ipos, p.color)

		self.can_update = False

class App:
	def __init__(self):
		self.screen = pygame.display.set_mode((300, 300))
		self.render = pygame.Surface((60, 60))
		self.world = World([60, 60])

		self.old_keys = []
		self.keys = []

		self.run = False

	def update(self):
		self.events = pygame.event.get()
		self.old_keys = self.keys
		self.keys = pygame.key.get_pressed()

	def key_down(self, k):
		return self.keys[k] and not self.old_keys[k]

	def key_up(self, k):
		return not self.keys[k] and self.old_keys[k]

	def key_press(self, k):
		return self.keys[k]

	def mainloop(self):
		global DELTA_TIME
		update_in_next = False

		self.run = True
		clock = pygame.time.Clock()
		while self.run:
			DELTA_TIME = clock.tick() / 1000.0
			self.update()

			if self.key_down(K_s):
				update_in_next = True

			if self.key_press(K_c):
				update_in_next = True

			if update_in_next:
				self.world.update()
				update_in_next = False

			for event in self.events:
				if event.type == pygame.QUIT:
					self.run = False

			self.world.render(self.render)
			sg_rs = pygame.transform.scale(self.render, (300, 300))
			self.screen.blit(sg_rs, (0, 0))

			pygame.display.update()

def main():
	App().mainloop()

main()