Working nightSky port

Author: tildebyte

nightSky/nightSky.pyde

@@ -1,65 +1,82 @@
 # http://patakk.tumblr.com / nightSky
 from point import Point
-from line import Line
+# from line import Line
 
-ArrayList < Point> points = ArrayList < Point > ()
-ArrayList < Line> lines = ArrayList < Line > ()
-N = 500
-time = 0
-dst
-lim = 125
 
+points = []
+lines = []
+NumPoints = 0
+Limit = 0
+HalfWidth = 0
+HalfHeight = 0
+HalfDist = 0
+I_Dont_Know_What_This_Is = dist(0, 0, 960, 540)
 
 def setup():
+    global points, HalfWidth, HalfHeight, HalfDist, NumPoints, Limit
     size(700, 300)
-    smooth()
-    N = 500.0 * dist(0, 0, width / 2, height / 2) / dist(0, 0, 1920 / 2, 1080 / 2))
-    lim = 160.0 * dist(0, 0, width / 2, height / 2) / dist(0, 0, 1920 / 2, 1080 / 2)
     background(0)
-    n = 0
-    #noiseSeed(5)
-    #randomSeed(1200)
-    while (n < N)
-        x, y, rx, ry, a
-        rx = random(width / 2 * 0.74) + random(40)
-        ry = random(height / 2 * 0.84) + random(40)
-        a = random(2 * PI)
-        x = rx * cos(a)
-        y = ry * sin(a)
-        dx = map(x, 0, width / 2, 0, 1.15)
-        dy = map(y, 0, height / 2, 0, 1.35)
-        prob = pow(2.72, -(dx * dx * 2 + dy * dy * 2))
-        if random(1) < prob:
-            points.add(Point(x, y))
-            n++
-    for n = 0 in range( n < N - 1): # n++
-        x1 = points.get(n).cx
-        y1 = points.get(n).cy
-        for m = n + 1 in range( m < N): # m++
-            x2 = points.get(m).cx
-            y2 = points.get(m).cy
-            if dist(x1, y1, x2, y2) < lim / 3:
-                lines.add(Line(n, m))
+    smooth()
     strokeWeight(0.8)
+    HalfWidth = width / 2
+    HalfHeight = height / 2
+    HalfDist = dist(0, 0, HalfWidth, HalfHeight)
+    NumPoints = (500.0 * HalfDist / I_Dont_Know_What_This_Is)
+    Limit = (160.0 * HalfDist / I_Dont_Know_What_This_Is)
+    # n = 0
+    # noiseSeed(5)
+    # randomSeed(1200)
+    # makePoint()
+    points = [makePoint() for _ in range(NumPoints)]
+    for point1 in points:
+        x1 = point1.startX
+        y1 = point1.startY
+        for point2 in points:
+            x2 = point2.startX
+            y2 = point2.startY
+            if dist(x1, y1, x2, y2) < Limit / 3:
+                lines.append(PVector(points.index(point1),
+                                     points.index(point2)))
+
+def makePoint():
+    while True:
+        randX = random(HalfWidth * 0.74) + random(40)
+        randY = random(HalfHeight * 0.84) + random(40)
+        angle = random(2 * PI)
+        startX = randX * cos(angle)
+        startY = randY * sin(angle)
+        dx = map(startX,
+                 0, HalfWidth, 0, 1.15)
+        dy = map(startY,
+                 0, HalfHeight, 0, 1.35)
+        prob = pow(2.72, -(dx**2 * 2 + dy**2 * 2))
+        if random(1) < prob:
+            return(Point(startX, startY))
 
 
 def draw():
     background(0)
-    translate(width / 2, height / 2)
-    for n = 0 in range( n < N): # n++
-        points.get(n).update()
-        points.get(n).display()
-    for n = 0 in range( n < lines.size()): # n++
-        x1 = points.get(lines.get(n).j).x
-        y1 =    points.get(lines.get(n).j).y
-        x2 = points.get(lines.get(n).k).x
-        y2 =    points.get(lines.get(n).k).y
-        amp = map(dist((x1 + x2) / 2, (y1 + y2) / 2, 0, 0), 0, dist(width / 2, height / 2, 0, 0), 2, 8)
-        dst = map(noise((x1 + x2) / 2 * 0.03, (y1 + y2) / 2 * 0.03), 0, 1, 5, lim / 2)
-        if dist((x1 + x2) / 2, (y1 + y2) / 2, mouseX - width / 2, mouseY - height / 2) < lim:
-            dst = dst * map(dist((x1 + x2) / 2, (y1 + y2) / 2, mouseX - width / 2, mouseY - height / 2), 0, lim, amp, 1)
-        if dist(x1, y1, x2, y2) < dst:
-            strk = map(dist(x1, y1, x2, y2), 0, dst, 85, 0)
-            stroke(255, strk)
+    translate(HalfWidth, HalfHeight)
+    for _point in points:
+        _point.update(frameCount)
+    for _line in lines:
+        x1 = points[int(_line.x)].x
+        y1 = points[int(_line.x)].y
+        x2 = points[int(_line.y)].x
+        y2 = points[int(_line.y)].y
+        plusX = x1 + x2 / 2
+        plusY = y1 + y2 / 2
+        mouseWrapX = mouseX - HalfWidth
+        mouseWrapY = mouseY - HalfHeight
+        amp = (map(dist(plusX, plusY, 0, 0),
+                   0, HalfDist, 2, 8))
+        distance = (map(noise(plusX * 0.03, plusY * 0.03),
+                        0, 1, 5, Limit / 2))
+        if dist(plusX, plusY, mouseWrapX, mouseWrapY) < Limit:
+            distance = (distance * map(dist(plusX, plusY, mouseWrapX, mouseWrapY),
+                                       0, Limit, amp, 1))
+        if dist(x1, y1, x2, y2) < distance:
+            opacity = map(dist(x1, y1, x2, y2),
+                          0, distance, 85, 0)
+            stroke(255, opacity)
             line(x1, y1, x2, y2)
-    time = time + 1

nightSky/point.py

@@ -0,0 +1,28 @@
+class Point(object):
+    def __init__(self, startX, startY):
+        self.startX = startX
+        self.startY = startY
+        self.rnd = random(5, 30)
+        self.diameter = map(self.rnd, 5, 30, 0.5, 2)
+        if random(1) > 0.5:
+            self.rt = True
+        else:
+            self.rt = False
+        self.phi = random(360)
+        self.x = 0
+        self.y = 0
+
+    def update(self, time):
+        if self.rt:
+            self.x = self._calc(self.startX, cos, time)
+            self.y = self._calc(self.startY, sin, time)
+        else:
+            self.x = self._calc(self.startX, cos, -time)
+            self.y = self._calc(self.startY, sin, -time)
+        noStroke()
+        fill(255)
+        ellipse(self.x, self.y, self.diameter, self.diameter)
+
+
+    def _calc(self, coord, func, time):
+        return coord + self.rnd * func(radians(time * self.diameter + self.phi))