class Test(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.x = 0
self.y = 0
self.color = GREEN
self.phase = 1
self.timer = Timer(1 / 30.)
self.wave_range = 1
self.wave_step = 1
self.amplitude = 4
self.offset = matrix_width / 2
self.freq = 1. / matrix_height * 8
self.controlled = True
self.mc = MidiController()
def generate(self):
self.graphics.fill(BLACK)
if self.timer.valid():
self.phase += 1
for i in range(0, self.wave_range, self.wave_step):
for self.y in range(0, matrix_height):
if self.controlled:
self.freq = self.mc.getButton(0, 0) / 126.
self.amplitude = self.mc.getButton(0, 1)
self.timer.set_interval(self.mc.getButton(0, 2) / 126.)
self.x = math.sin(self.y * self.freq + self.phase
) * self.amplitude + self.offset + i
b = translate(i, 0, matrix_width, 0, 50)
g = translate(self.y, 0, matrix_height, 0, 80)
r = translate(self.x, 0, 12, 0, 24)
self.color = (255, 0, 0)
self.graphics.drawPixel(self.x, self.y, self.color)
return self.graphics.getSurface()
class RandomLife(object):
def __init__(self):
self.life = Life(matrix_width, matrix_height, 1, color=BLACK)
self.graphics = Graphics(matrix_width, matrix_height)
def pickRandomColor(self):
color = random.randint(0, len(COLORS) - 1)
# make sure that that color isn't black
while(COLORS[color] == BLACK):
color = random.randint(0, len(COLORS) - 1)
return COLORS[color]
def drawRandomColor(self):
life_matrix = self.graphics.toMatrix(self.life.field,
self.graphics.getSurfaceWidth())
for y in self.graphics.heightRange:
for x in self.graphics.widthRange:
if life_matrix[y][x]:
color = self.pickRandomColor()
# give every lifing cell a random color
self.graphics.drawPixel(x, y, color)
else:
self.graphics.drawPixel(x, y, BLACK)
def draw(self):
self.drawRandomColor()
def generate(self):
self.life.process()
self.draw()
return self.graphics.getSurface()
class GraphicsDotTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = (123, 111, 222)
def generate(self):
self.graphics.fill(BLACK)
for i in range(0, 5):
self.graphics.drawPixel(i, i, self.color)
return self.graphics.getSurface()
class PlasmaFirst(object):
def __init__(self, speed=20):
self.graphics = Graphics(matrix_width, matrix_height)
self.plasma = Graphics(matrix_width, matrix_height)
self.x_range = xrange(0, matrix_width, 1)
self.y_range = xrange(0, matrix_height, 1)
self.interval = .1/speed #interval/speed is how many ticks a second.
self.time = 0
self.previousTick = 0
self.generatePalette()
self.generatePlasmaSurface()
def generatePalette(self):
self.palette = []
for x in xrange(0, 256, 1):
colorRGB = HSVtoRGB((x,255,255,))
self.palette.append(colorRGB)
def generatePlasmaSurface(self):
for y in self.y_range:
for x in self.x_range:
#c = int(abs(256*sin((x+y+self.time)/3.0)))
c = int(
128.0 + (128.0*sin((x+6)/2.4))
+128.0 + (128.0*cos(y/3.4))
)/2
color = (c,)*3
self.plasma.drawPixel(x,y,color)
return list(self.plasma.getSurface())
def process(self):
if( (time.time()-self.previousTick) >= self.interval ):
self.previousTick = time.time()
self.time += 1
paletteShift = self.time
for y in self.y_range:
for x in self.x_range:
plasma_color = self.plasma.readPixel(x,y)
color_shift = self.palette[paletteShift%256]
r = (plasma_color[0]+color_shift[0])%256
g = (plasma_color[1]+color_shift[1])%256
b = (plasma_color[2]+color_shift[2])%256
color = (r,g,b,)
color = ColorRGBOps.darken(color, 50)
self.graphics.drawPixel(x,y, color)
def draw(self):
pass
def generate(self):
self.graphics.fill(BLACK)
self.process()
self.draw()
return self.graphics.getSurface()
class Sven(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = randColor()
def generate(self):
self.graphics.fill(BLACK)
b = 0
i = 0
while(i <= 10):
color2 = randColor()
a = random.randint(0, matrix_width)
b = random.randint(0, matrix_height)
self.graphics.drawPixel(a, b, color2)
i = i + 1
b = b + 1
return self.graphics.getSurface()
class BlueLife(object):
def __init__(self):
self.life = Life(matrix_width, matrix_height, 1, color=BLUE)
self.graphics = Graphics(matrix_width, matrix_height)
def draw(self):
life_matrix = self.graphics.toMatrix(self.life.field, self.graphics.getSurfaceWidth())
for y in self.graphics.heightRange:
for x in self.graphics.widthRange:
if life_matrix[y][x]:
color = BLUE
else:
color = BLACK
self.graphics.drawPixel(x, y, color)
def generate(self):
self.life.process()
self.draw()
return self.graphics.getSurface()
class DrawSegmentNumber(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.letter_width = 4
self.letter_height = 7
self.timer = Timer(1 / 2.)
self.number = 0
def generate(self):
self.graphics.fill(BLACK)
if self.timer.valid():
self.number += 1
if self.number > 9:
self.number = 0
for x, row in enumerate(numbers[self.number]):
for y, pixel in enumerate(row):
color = (0, 0, 0xff * pixel)
self.graphics.drawPixel(6 - x, y, color)
return self.graphics.getSurface()
class GraphicsPixelTest(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = GREEN
self.pos = (random.randint(1, matrix_width - 1),
random.randint(1, matrix_height - 1))
self.speed = 1
self.deltax, self.deltay = self.speed, self.speed
def generate(self):
self.graphics.fill(BLACK)
x, y = self.pos
self.graphics.drawPixel(x, y, self.color)
if x >= matrix_width - 1 or x <= 0:
self.deltax *= -1
if y >= matrix_height - 1 or y <= 0:
self.deltay *= -1
self.pos = x + self.deltax, y + self.deltay
return self.graphics.getSurface()
class SuperPixelBros(object):
"""
SuperPixelBros is a class that hanles function calling and processing.
makes sure the level is generated.
makes sure the player get the right data.
"""
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.players = []
self.player = Player((9, 7), BLUE, self.graphics, self)
self.level = level1
def handleInput(self):
self.player.handleInput()
def process(self):
self.player.process()
def draw(self):
self.graphics.fill(BLACK)
# draw the map.
surfaceheight = self.graphics.getSurfaceHeight()
level_matrix = self.graphics.toMatrix(self.level, surfaceheight)
for y in self.graphics.heightRange:
for x in self.graphics.widthRange:
tile = level_matrix[x][y]
# draw the map flipped
self.graphics.drawPixel(self.graphics.width - x - 1, y, tile)
# draw the player.
self.player.draw()
def generate(self):
# self.handleInput()
# self.process()
# self.draw()
return self.graphics.getSurface()
class Test(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = GREEN
self.x = 0
self.y = 0
self.x_offset = matrix_width / 2
self.y_offset = matrix_height / 2
self.angle = 0
self.radius = 5
self.timer = Timer(0.1)
def generate(self):
self.graphics.fill(BLACK)
for i in range(0, 360):
self.x = math.sin(math.radians(i)) * self.radius + self.x_offset
self.y = math.cos(math.radians(i)) * self.radius + self.y_offset
self.graphics.drawPixel(self.x, self.y, self.color)
#if self.timer.valid():
# self.angle += 1
# if self.angle > 360:
# self.angle = 0
return self.graphics.getSurface()
class SineWave(object):
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.x = 0
self.y = 0
self.color = GREEN
self.phase = 0
self.wave_range = 1
self.wave_step = 1
self.amplitude = 5
self.offset = matrix_width / 2
self.freq = 0.4
def generate(self):
self.graphics.fill(BLACK)
for i in range(0, self.wave_range, self.wave_step):
for self.y in range(0, matrix_height):
self.x = math.sin(self.y*self.freq+self.phase)*self.amplitude+self.offset + i
b = translate(i, 0, matrix_width, 0, 50)
g = translate(self.y, 0, matrix_height, 0, 80)
r = translate(self.x, 0, 12, 0, 24)
self.color = (int(r), int(g), int(b))
self.graphics.drawPixel(self.x, self.y, self.color)
return self.graphics.getSurface()
class OldTron(object):
# version before creating players that handle processing on thier own.
def __init__(self):
self.graphics = Graphics(matrix_width, matrix_height)
self.color = BLUE
x = 0 # random.randint(1, matrix_width - 1)
y = 0 # 3random.randint(1, matrix_height - 1)
self.pos = x, y
self.speed = 1
self.deltax, self.deltay = 0, 0
self.body = []
# add our head to our body :)
self.body.append(self.pos)
self.player1 = TronPlayer(BLUE, self)
self.player1.update(self)
self.player1.draw()
pygame.init()
self.window = pygame.display.set_mode((80, 60))
self.debug = False
pygame.key.set_repeat(1, 1)
def inputHandling(self):
keys_pressed = pygame.key.get_pressed()
if keys_pressed[pygame.K_UP]:
self.deltax = 0
self.deltay = 1
if keys_pressed[pygame.K_DOWN]:
self.deltax = 0
self.deltay = -1
if keys_pressed[pygame.K_LEFT]:
self.deltax = -1
self.deltay = 0
if keys_pressed[pygame.K_RIGHT]:
self.deltax = 1
self.deltay = 0
def update(self):
x, y = self.pos
# update position
x += self.deltax
y += self.deltay
# if the tail goes offscreen it appears on the other side.
if x >= matrix_width:
x = 0
self.pos = x, y
elif x < 0:
x = matrix_width - 1
self.pos = x, y
elif y >= matrix_height:
y = 0
self.pos = x, y
elif y < 0:
y = matrix_height - 1
self.pos = x, y
else:
self.pos = x, y
if self.debug:
print(self.deltax, self.deltay)
print(x, y)
# look if our "tail is in the way" and only if we have a tail.
if len(self.body) > 2:
if len(self.body) != len(set(self.body)):
print("GameOver!")
self.body = [self.pos]
self.deltax = 0
self.deltay = 0
# add current point to tail
# only if we moved though
if self.deltax or self.deltay:
self.body.append(self.pos)
def draw(self):
for x, y in self.body:
self.graphics.drawPixel(x, y, self.color)
def generate(self):
self.graphics.fill(BLACK)
self.inputHandling()
self.update()
self.draw()
# self.player1.draw()
return self.graphics.getSurface()
class Snake(object):
def __init__(self, speed=8, plugged=0):
self.graphics = Graphics(matrix_width, matrix_height)
self.controller = SnakeController(plugged)
self.body_color = GREEN
self.head_color = BLUE
x = random.randint(1, matrix_width - 1)
y = random.randint(1, matrix_height - 1)
self.pos = x, y
self.original_speed = speed
self.speed = speed
self.previousTick = 0
self.deltax, self.deltay = 0, 0
self.body = []
self.tailLen = 0
self.food = Food((0, 0), WHITE, self.graphics)
self.food.randPos()
# add our head to our body :)
self.body.append(self.pos)
def inputHandling(self):
if self.controller.getUp() and self.deltax != -1:
self.deltax = 1
self.deltay = 0
if self.controller.getDown() and self.deltax != 1:
self.deltax = -1
self.deltay = 0
if self.controller.getLeft() and self.deltay != 1:
self.deltax = 0
self.deltay = -1
if self.controller.getRight() and self.deltay != -1:
self.deltax = 0
self.deltay = 1
def update(self):
x, y = self.pos
# update position certain amount per second.
if((time.time() - self.previousTick) >= 1. / self.speed):
self.previousTick = time.time()
x += self.deltax
y += self.deltay
# if the snake goes offscreen it appears on the other side.
if x >= matrix_width:
x = 0
self.pos = x, y
elif x < 0:
x = matrix_width - 1
self.pos = x, y
elif y >= matrix_height:
y = 0
self.pos = x, y
elif y < 0:
y = matrix_height - 1
self.pos = x, y
else:
self.pos = x, y
if len(self.body) > self.tailLen:
del self.body[0]
self.body.append(self.pos)
# and if we hit food increase tail length
# also increase our speed
if self.food.pos == self.pos:
self.speed += 0.5
while self.food.pos in self.body:
self.food.randPos()
self.food.randColor()
self.tailLen += 1
# look if our "tail is in the way" and only if we have a tail.
if len(self.body) > 2:
# check if head colides with body
if len(self.body) != len(set(self.body)):
self.body = [self.pos]
self.tailLen = 0
self.speed = self.original_speed
self.deltax = 0
self.deltay = 0
def draw(self):
for i, (x, y) in enumerate(self.body):
if i == self.tailLen:
# draw our head a certain color
self.graphics.drawPixel(x, y, self.head_color)
else:
# else just draw our body this color
# self.graphics.drawPixel(x,y,Color.subtract(self.body_color, (int(255/(i+1)),)*3))
self.graphics.drawPixel(x, y, (255, 255, 255))
self.food.draw()
def generate(self):
self.graphics.fill(BLACK)
self.inputHandling()
self.update()
self.draw()
return self.graphics.getSurface()
class PlasmaThird(object):
def __init__(self, speed=10):
self.graphics = Graphics(matrix_width, matrix_height)
self.plasma = Graphics(matrix_width, matrix_height)
self.x_range = xrange(0, matrix_width, 1)
self.y_range = xrange(0, matrix_height, 1)
self.speed = speed
self.interval = speed
self.time = random.randint(0,100)
self.previousTick = 0
self.angle = 0
self.generatePalette()
self.generatePlasmaSurface()
def generatePalette(self):
self.palette = []
for x in xrange(0, (2**8), 1):
r = int(128+256*sin(x)/20)
g = int(128+256*sin(r)/100)
b = int(128+256*sin(g)/50)
colorRGB = (r,g,b)
self.palette.append(colorRGB)
def generatePlasmaSurface(self):
self.angle = self.time
x_offset = matrix_width*sin(radians(self.angle))+matrix_width
y_offset = matrix_height*cos(radians(self.angle))+matrix_height
for y in self.y_range:
for x in self.x_range:
c = int(
128+(128*sin((x+x_offset)/2.0))
+128+(128*sin((y+y_offset)/2.0))
+128+(128*sin(((x+x_offset)+(y+y_offset))/2.0))
+128+(128*sin(sqrt(float((x+x_offset)*(x+x_offset)+(y+y_offset)*(y+y_offset)))/2.0))
)/4
color = (c,)*3
self.plasma.drawPixel(x,y,color)
return list(self.plasma.getSurface())
def process(self):
if((time.time()-self.previousTick) >= 1./self.interval):
self.previousTick = time.time()
self.time+=1
def draw(self):
paletteShift = self.time
self.generatePlasmaSurface()
for y in self.y_range:
for x in self.x_range:
plasma_color = self.plasma.readPixel(x,y)
color_shift = self.palette[paletteShift%256]
r = (plasma_color[0]+color_shift[0])%256
g = (plasma_color[1]+color_shift[1])%256
b = (plasma_color[2]+color_shift[2])%256
color = (r,g,b,)
#darken the color to create a better contrast
color = ColorRGBOps.brighten(color, 20)
self.graphics.drawPixel(x,y, color)
def generate(self):
self.graphics.fill(BLACK)
self.process()
self.draw()
return self.graphics.getSurface()
