# Starfields and Galaxies with Python

Last Update: 19.12.2007. By kerim in natural | pygame | python | tutorial | Algorithms

A long time ago i spend a lot of my resources programming fractals and “natural” phenomenons. Since my last adventure with pygame i was playing around with the idea of implementing some algorithms of old times in python anew and use pygame to test them. A small module that creates screens with stars on it is what i will speak about here.

I implemented three small but usefull algorithms:

1. A simple function that fills a screen with stars simulating a normal night
2. A function that creates clouds of stars similar to eliptic galaxies
3. A function that creates spiral galaxies

Although i used pygame for the implementation and although you need it if you want to test my code, it is independend of any (external) library you might use for your game, app, rendering. All you have to do is to overwrite the “draw” method in your own class.

So here is the way to do it:

1. Pygame Framework to test and Starfields-skeleton

Use the following code below for testing. Just take the comments away from the function call you want to use. As you can see i have put my class in a module called starfields located in a package called natural.

```#! /usr/bin/env python

import pygame, sys
from natural.starfields import Starfields
from pygame.color import THECOLORS
from math import pi

def main():
width=800
height=600
displaymode=(width,height)
screen = pygame.display.set_mode(displaymode)
pygame.display.set_caption('Starfield')
#an array of colors for the stars. probability is determined by the amount of times a color is mentioned
colors=[THECOLORS["white"],THECOLORS["yellow"], THECOLORS["white"],THECOLORS["red"],THECOLORS["white"]]

s=Starfields(screen,width,height)
#s.createRandomStars(100, colors)
#s.createStarsByProbability(10, colors)

turn = 45.0 * 2 * pi / 360.0 #calculate in rad
deg = 270.0 * 2 * pi / 360.0
#s.createElipticStarfield(1000, colors, (300,200), (200,100), turn)

s.createSpiralGalaxy(colors,(300,200), (100,50),turn,deg)

while True:
pygame.display.update()
event = pygame.event.poll()
if event.type == pygame.QUIT:
sys.exit()

if __name__=="__main__":
main()
```

Code for the Starfields - class (Skeleton):

```#!/usr/bin/env python
# -*- coding: utf-8 -*-
import random
from math import sin, cos,pi
try:
import pygame
except:
print "pygame not available, drawing won't work"

class Starfields():
def __init__(self,screen, width, height):
self.screen=screen
self.width=width
self.height=height
random.seed()

"""
overwrite this for your own graphics library
"""
def draw(self,x,y,color):
pygame.draw.circle(self.screen,color,(x,y),0)
```

Initialization needs some “screen” object and the width and height of it. pygame is NOT needed for you LATER. I only included it because i wanted to test the module. You can later adapt rather easily by supplying whatever “surface” you want to draw on and adapting the draw method. For example you might provice a screen of None and in the draw method only assemble an array of data etc.

2. Doing the starfield

First i used a somewhat simple way to create a starfield. I iterated over the whole screen (pixel by pixel) and rolled some dice checking if there would be a star at that pixel. If so then i would determine which color it had and draw it. The way works, but it costs you a huge amount of time. So instead of doing that you should rather implement a simple algorithm that takes the amount of stars to set and then just determines where to put them and how they should look like. ```def createRandomStars(self,amount,colors):
lencol=len(colors)
for star in range(0,amount):
self.draw(random.randint(0,self.width),random.randint(0,self.height),colors[random.randint(0,lencol-1)])
```

2: Doing the cloud

A cloud is normally deternmined by an elipse with a radius in x direction and one in y, as well as a center. The algorithm is rather simple again. For each star we pick one point at the outer border of the elipse. We first determine the degree randomly. If now we would calculate the positions for x and y position by multilying the radiuses (rx and ry) with the cosinus or sinus then we would create a dotted elipse with the stars all on the edge of it. So we need to move the stars randomly toward the center, with the majority of stars near it and only few at the edge of the elipse. This is done when calculating the insideFactor. It is allways below or equal to 1 and multiplying it with itself will further decrease the value. Around 50 % of all stars should be in the first 25% of the distance between center and outer rim. Finally i also included a variable “turn” which will turn the cloud by a given angle, so that you do not always have the standard “left to right” cloud. ```def createElipticStarfield(self, amount, colors, center, radius, turn=0):
lencol=len(colors)
x,y=center
for star in range(0,amount):
degree=random.randint(0,360)
degree= 2.0 * degree * pi / 360.0
#(sin(degree)*rx/ypos=cos(degree)*ry) would form the elipse
#since we need to draw inside with the density increaing near the center we must include
#some factor (0..1)
insideFactor=float(random.randint(0,10000))/10000
insideFactor=insideFactor*insideFactor
xpos=sin(degree)*round(insideFactor*rx)
ypos=cos(degree)*round(insideFactor*ry)
if turn!=0:
xptemp=cos(turn)*xpos+sin(turn)*ypos
yptemp=-sin(turn)*xpos+cos(turn)*ypos
xpos=xptemp
ypos=yptemp
self.draw(x+xpos,y+ypos,colors[random.randint(0,lencol-1)])
```

3: Doing the spiral galaxy

Now THIS was rather complicated. The first step is to create ONE single cloud in the center of the spiral galaxy. Then we must create the arms. thats done by putting smaller clouds on the path of those arms. In each iteration we swap between the two spiral arms when putting the clouds. The factors for sizes are actually just the result of several hours of trying. ```def createSpiralGalaxy(self, colors, center, size, turn=0, deg=0, dynsizefactor=50, sPCFactor=8):
sx,sy=size
sx=2.0*sx*pi/360.0
sy=2.0*sy*pi/360.0
x,y=center
swap=True
xp1=round(deg/pi*sx/1.7)*dynsizefactor
yp1=round(deg/pi*sy/1.7)*dynsizefactor #factors for dynamic sizing
print xp1,yp1
self.createElipticStarfield(5*(xp1+yp1),colors,center,(xp1,yp1),turn)
#this was the central cloud
#now for the smaller ones in the spiral arms
mulStarAmount=(xp1+yp1)/sPCFactor #factor for amount of stars per cloud
n=0.0
while n<=deg:
swap = not swap
xpos=(cos(n)*((n*sx))*dynsizefactor)
ypos=(sin(n)*((n*sy))*dynsizefactor)
xp1=cos(turn)*xpos  + sin(turn)*ypos
yp1=-sin(turn)*xpos + cos(turn)*ypos
sizetemp=2+(mulStarAmount*n)
if swap:
self.createElipticStarfield(int(sizetemp/2),colors,(x+xp1,y+yp1),(sizetemp,sizetemp), turn)
else:
self.createElipticStarfield(int(sizetemp/2),colors,(x-xp1,y-yp1),(sizetemp,sizetemp), turn)
angle=random.randint(0,4)+1
n+= 2.0* angle *pi / 360.0
```

Finally:

I would like to have some feedback on this. If you have a good picture send it to me. If you have an idea on how to improove the code or add some functionality to beautify the result … send it to me.

Want content like this in your inbox each workday irregularly? No BS, spam or tricks... just useful content: