Here's a simple sequencer that has some interesting features in PyGame.
See http://pobox.com/~kragen/sw/pygmusic/ for more details.
#!/usr/bin/python
# -*- encoding: utf-8 -*-
"""Pygmusic: A simple music sequencer in PyGame. By Kragen Sitaker,
2007-12-07, 08, and 09.
Drag things around with the mouse; the right mouse button exits.
I, the copyright holder of this work, hereby release it into the
public domain. This applies worldwide.
In case this is not legally possible, I grant any entity the right
to use this work for any purpose, without any conditions, unless
such conditions are required by law.
"""
import pygame, time, os, sys, math
### basic utility functions
def gray(x):
"Return a grayscale color tuple given an argument in [0,256)"
return (x, x, x)
black = gray(0)
white = gray(255)
def padd((x1, y1), (x2, y2)):
"Add an offset to a 2D point."
return (x2 + x1, y2 + y1)
def diff((x1, y1), (x2, y2)):
"Take the offset between two 2D points."
return (x2 - x1, y2 - y1)
### basic drawable objects
class Visible:
"""Things that get drawn on the screen and maybe handle mouse clicks
or make sounds.
These objects can be added to the world with world.add and are
expected to be able to do the following:
- obj.contains((x, y)): tell whether a mouse position is in the object
- obj.handle_click(world, event): handle a mouse button going down
- obj.play(world): make any appropriate sounds
- obj.center(): return (x, y) center to decide when to be played
- obj.draw(self, world, screen): display itself; called every frame.
- obj.is_drop_target_for(self, object, world): handle object being
dropped on us
Additionally, if an object is draggable, it needs to support these:
- obj.move(delta): move by delta x and delta y
- obj.handle_drop(world): finish being dragged
In order to use the default implementations of contains and
center, the object needs to have a rect property that acts like a
pygame.Rect.
"""
def contains(self, (x, y)): return self.rect.collidepoint(x, y)
def center(self): return self.rect.center
def is_drop_target_for(self, obj, world): "Default is to do nothing."
def handle_click(self, world, ev): "Default is to do nothing."
def play(self, world): "Default is to do nothing."
class Timer(Visible):
"A horizontal strip on the screen that plays things in it when triggered."
def __init__(self, rect, cycletime, color, active=True, divisions=8):
"cycletime is the time to go through the whole cycle."
self.rect = rect
self.cycletime = cycletime
self.color = color
self.active = active
self.start = time.time()
self.lastoffset = 0
self.divisions = divisions
def drawvbar(self, screen, offset, color):
"Draws a timing mark at a given offset."
screen.fill(color, ((self.rect.left + offset, self.rect.top),
(1, self.rect.h)))
def drawvbars(self, screen, n, color):
"Draw timing marks for odd intervals of every nth of a cycle."
for ii in range(1, n):
self.drawvbar(screen, ii * self.rect.w / float(n), color)
def draw(self, world, screen):
screen.fill(gray(self.color), self.rect)
self.drawvbars(screen, self.divisions*2, gray(136))
self.drawvbars(screen, self.divisions, gray(144))
self.drawvbars(screen, 2, gray(192))
if self.active: self.draw_cursor(world, screen)
def time(self):
"The time since the beginning of the current play cycle."
age = time.time() - self.start
if age > self.cycletime: return self.cycletime
return age
def offset(self):
"The current position of the cursor for this timer."
return int(self.time() / self.cycletime * self.rect.w + 0.5)
def handle_click(self, world, ev): self.trigger()
def trigger(self):
"Start playing the sounds within."
self.active = True
self.lastoffset = 0
self.start = time.time()
def cursor_rect(self, start, end):
"Returns a Rect from pixel offset 'start' to 'end' for a cursor."
return pygame.Rect((self.rect.left + start, self.rect.top),
(end - start, self.rect.h))
def cursor_rects(self, offset):
"Returns the Rects showing the currently playing period on the screen."
assert offset >= self.lastoffset
return [self.cursor_rect(self.lastoffset, offset)]
def draw_cursor(self, world, screen):
"""Draws the white box that represents the currently playing period,
and also plays the sounds found within."""
offset = self.offset()
for rect in self.cursor_rects(offset):
screen.fill(white, rect)
# If we .play() things immediately, there could be
# surprising effects (e.g. if we're playing ourselves).
# So we enqueue the playing for later.
for obj in world.objects_in(rect):
world.defer(lambda obj=obj: obj.play(world))
self.lastoffset = offset
class RepeatingTimer(Timer):
"A horizontal strip on the screen that plays things in it repeatedly."
def time(self):
return (time.time() - self.start) % self.cycletime
def handle_click(self, world, ev):
"Turns the timer on and off when clicked."
if not self.active: self.lastoffset = self.offset()
self.active = not self.active
def cursor_rects(self, offset):
if offset >= self.lastoffset:
return [self.cursor_rect(self.lastoffset, offset)]
else:
return [self.cursor_rect(self.lastoffset, self.rect.w),
self.cursor_rect(0, offset)]
class ImageDisplay(Visible):
"A visible object that displays by merely blitting an image."
def __init__(self, pos, image):
self.image = image
self.rect = pygame.Rect(pos, image.get_size()) # to satisfy Visible
def draw(self, world, surface):
"ImageDisplay.draw just blits the object's image."
surface.blit(self.image, self.rect.topleft)
class UglyHalo(ImageDisplay):
"""A white square that fades to nothing over 0.6 seconds to show
that something has happened."""
def __init__(self, rect):
"rect is the area to draw the halo around."
halosize = rect.h * 2
# I wanted to do a circle, but it turns out that in SDL you can't
# have both a per-pixel alpha and a per-surface alpha, and I
# figured that fading the per-pixel alpha in a Python nested loop
# would be too slow, so for now, it's a white square. See the
# NumericHalo class for an alternative.
image = pygame.surface.Surface((halosize, halosize))
image.fill(white)
ImageDisplay.__init__(self, diff(image.get_rect().center, rect.center),
image)
self.start = time.time()
def draw(self, world, surface):
"Blits the halo image with the current opacity; possibly suicides."
age = time.time() - self.start
opacity = int(255 * (0.6 - age))
if opacity <= 0: world.delete(self)
else:
self.image.set_alpha(opacity)
ImageDisplay.draw(self, world, surface)
### rendering haloes with Numeric
def scale(mask, component):
"Encode a floating-point color component in [0, 1] with a bitmask."
mask = mask % (2**32) # make unsigned
rv = int(mask * component) & mask # scale mask by weight
if rv >= 2**31: rv -= 2**32 # convert back to signed
rv = int(rv) # convert back to non-long
return rv
def pixel(masks, components):
"Encode an (r, g, b, alpha) tuple according to given masks."
return sum(map(scale, masks, components))
class NumericHaloMovie:
"Renders frames of a halo on demand, then caches them."
def __init__(self, args):
framelength, size, max_age, fuzz = args
self.framelength = framelength
self.size = size # size of the object halo is around
self.max_age = max_age
self.fuzzsq = fuzz**2
self.frames = {}
self.shape = (size*2, size*2)
cx = cy = size # x and y at center
xs, ys = Numeric.indices(self.shape) # x and y coords of each pixel
(dx, dy) = (xs - cx, ys - cy) # distances from center for each pixel
self.rsq = dx*dx + dy*dy # squared distance from center
def render_frame(self, ii):
age = ii * self.framelength # age in seconds when to show this frame
# create a surface that has an alpha channel, to render to and return
mysurf = pygame.Surface(self.shape).convert_alpha()
masks = mysurf.get_masks() # get bitmasks for r, g, b, alpha
global_alpha = (1.2 * self.max_age - age)/self.max_age
fsq = self.fuzzsq
# palette is the colors in delta-rsquared, from densest to
# most rarefied. Most rarefied is transparent, 0. Densest is
# nearly white.
palette = Numeric.array(
[pixel(masks, (1, 1, # r and g are always 100%
0.8 * float(fsq-ii)/fsq, # b is 0-80%
0.9 * float(fsq-ii)/fsq * global_alpha))
for ii in range(fsq)] + [0])
# This is the r-squared where that maximum density is found.
# The formula is just voodoo --- I whacked on it until the
# effect looked OK. It doesn't scale properly with max_age.
max_level = self.size**2/2 * (1 - (1 - age*2)**2)
# Take absolute difference of r-squared from the point of the
# current maximum, clamp it between 0 and fuzz**2, convert to
# integer so we can use it to index the palette.
density = Numeric.clip(Numeric.absolute(self.rsq - max_level),
0, fsq).astype(Numeric.Int)
colors = Numeric.take(palette, density)
pygame.surfarray.blit_array(mysurf, colors)
return mysurf
def __getitem__(self, framenum):
"Get a frame."
try: return self.frames[framenum]
except KeyError:
frame = self.render_frame(framenum)
self.frames[framenum] = frame
return frame
halo_movies = {}
def get_halo_movie(*args):
"Find a requested halo movie."
# This way multiple haloes of the same size (and other attributes)
# can share the same rendered frames.
if halo_movies.has_key(args): return halo_movies[args]
halo_movies[args] = NumericHaloMovie(args)
return halo_movies[args]
class NumericHalo(Visible):
"Draws a fading halo computed with Numerical Python."
def __init__(self, rect):
"rect is the area to draw the halo around."
fuzz = 10
self.framelength = 1/120.0 # of a second.
self.max_age = 0.4 # of a second
self.frames = get_halo_movie(self.framelength, rect.h,
self.max_age, fuzz)
pos = diff(self.frames[0].get_rect().center, rect.center)
self.rect = pygame.Rect(pos, self.frames[0].get_size())
self.start = time.time()
def draw(self, world, surface):
"Blits the best frame for the halo's current age; possibly suicides."
age = time.time() - self.start
if age > self.max_age: world.delete(self)
else:
surface.blit(self.frames[int(age / self.framelength + 0.5)],
self.rect.topleft)
try:
# test to see if Numeric and surfarray are available
import Numeric
pygame.surfarray.blit_array
except:
make_halo = UglyHalo
else:
make_halo = NumericHalo
### Sound-making objects
class DragSource(ImageDisplay):
"Here is a source you can drag new Visibles from."
def __init__(self, pos, image, instance):
"instance is a callable to call with (x, y) to make the new thing."
ImageDisplay.__init__(self, pos, image)
self.instance = instance
def handle_click(self, world, ev):
"Start a drag with a new instance of, say, a Sound."
# The (15, 15) offset has two purposes:
# - it makes it clear that the new thing is a new thing, and
# not a change of color of the old thing;
# - it happens to put that thing by default into one of the
# timers, so that if you don't drag it anywhere, it will still
# get played.
new = self.instance(padd(self.rect.topleft, (15, 15)))
world.add(new)
new.start_drag(world, ev)
new.play(world)
class Sound(ImageDisplay):
"A draggable sound that you can put in the tracks."
def __init__(self, pos, image, sound):
ImageDisplay.__init__(self, pos, image)
self.sound = sound
def move(self, delta): self.rect = self.rect.move(delta)
def start_drag(self, world, ev):
world.raise_to_top(self)
world.grab(self, ev.pos)
def handle_drop(self, world):
"Handle being dropped; called by the world."
# we cheat and look a pixel up and left
droptarget = world.object_at(padd(self.rect.topleft, (-1, -1)))
if droptarget: droptarget.is_drop_target_for(self, world)
def handle_click(self, world, ev):
self.start_drag(world, ev)
self.play(world)
def play(self, world):
"Plays the object's sound and kicks off a halo; called by timer."
self.sound.play()
world.add_nonclickable(make_halo(self.rect))
class Trigger(Sound):
"""A draggable object that you can put in a timer to trigger some
other thing, such as another timer."""
# XXX currently inherits from Sound so as to be draggable.
def __init__(self, pos, image, gun):
ImageDisplay.__init__(self, pos, image)
self.gun = gun
def play(self, world):
world.add_nonclickable(make_halo(self.rect))
self.gun.trigger()
### miscellaneous including the world
class Trash(ImageDisplay):
"""The trashcan deletes things dropped on it."""
def is_drop_target_for(self, object, world):
"Delete the dropped thing and make a halo."
world.delete(object)
world.add_nonclickable(make_halo(self.rect))
class Profiler:
def __init__(self):
self.times = {}
def __str__(self): return str(self.times)
def start(self): self.last_time = time.time()
def note(self, what):
now = time.time()
dur = now - self.last_time
self.last_time = now
if not self.times.has_key(what): self.times[what] = 0
self.times[what] += dur
class World:
"""Manages the set of stuff you see on the screen and routes
events. I think this is basically the Smalltalk MVC Controller."""
def __init__(self, screen):
"screen is an SDL/PyGame surface to draw on."
self.screen = screen
self.objects = [] # clickable visible objects
self.nonclickable_objects = [] # halos and such
self.grab(None, None) # initialize drag state
self.redraw_profiler = Profiler()
self.deferreds = []
def redraw(self):
"This gets called whenever there's idle time, i.e. each frame."
self.screen.fill(black)
self.redraw_profiler.start()
for obj in self.objects + self.nonclickable_objects:
obj.draw(self, self.screen)
self.redraw_profiler.note(obj.__class__.__name__)
for task in self.deferreds: task()
self.deferreds = []
def defer(self, task):
"Enqueue a task to be done as soon as possible after redraw."
self.deferreds.append(task)
def add(self, obj):
"Call to put a new visible, clickable object on the screen."
self.objects.append(obj)
def add_nonclickable(self, obj):
"""Like add, but for nonclickable objects above everything.
I added this for halos because they were accidentally getting
drawn underneath other screen objects, and they aren't
supposed to impede the clickability of the objects they're
haloing around.
"""
self.nonclickable_objects.append(obj)
def object_at(self, pos):
"Return the topmost object at pos, or None."
# iterate backwards so objects drawn "on top" get first choice
for ii in range(len(self.objects)-1, -1, -1):
if self.objects[ii].contains(pos): return self.objects[ii]
def handle_click(self, ev):
"Route a click event to the relevant object."
obj = self.object_at(ev.pos)
if obj: obj.handle_click(self, ev)
else: self.ungrab()
def handle_release(self, ev):
"Handle a button release event."
self.ungrab()
def handle_motion(self, ev):
"Handle mouse motion, by doing a mouse drag if needed."
if self.dragobj is None: return
self.dragobj.move(diff(self.dragpos, ev.pos))
self.dragpos = ev.pos
def ungrab(self):
"Terminate any drag."
if self.dragobj is not None: self.dragobj.handle_drop(self)
self.grab(None, None)
def grab(self, obj, pos):
"Start dragging some object."
(self.dragobj, self.dragpos) = (obj, pos)
def delete(self, obj):
"Remove a visible object (clickable or not) from the world."
if obj in self.nonclickable_objects:
self.nonclickable_objects.remove(obj)
else:
self.objects.remove(obj)
def raise_to_top(self, obj):
"Move an object to the top of the drawing stack."
self.delete(obj)
self.add(obj)
def objects_in(self, arect):
"""Find all the objects whose centers are in a rectangle.
This is used by the timer to figure out what to play.
"""
return [obj for obj in self.objects
if arect.contains(pygame.Rect(obj.center(), (1, 1,)))]
def main(argv):
"Main program."
mydir = os.path.split(argv[0])[0]
pygame.init()
screen = pygame.display.set_mode((640, 480), pygame.FULLSCREEN)
world = World(screen)
timerwidth = 440
def timer(y, cycletime, color, active=True):
world.add(RepeatingTimer(rect=pygame.Rect((100, y), (timerwidth,30)),
cycletime=cycletime*0.16667, color=color, active=active,
divisions=cycletime))
font = pygame.font.Font(None, 24) # use default font, 24 pixels high
def getsound(soundname):
path = os.path.join(mydir, soundname + '.wav')
return pygame.mixer.Sound(path)
def renderletter(letter, color): return font.render(letter, 1, color)
def addsource(xpos, letter, soundname):
image = renderletter(letter, white)
sound = getsound(soundname)
make = lambda pos: Sound(pos=pos, image=image, sound=sound)
source = DragSource(pos=(xpos, 80),
image=renderletter(letter, (255, 128, 128)),
instance=make)
world.add(source)
return lambda pos: world.add(source.instance(pos))
yy = addsource(100, 'Y', 'score')
zz = addsource(120, 'Z', 'extraball')
aa = addsource(140, 'A', 'reflect_paddle')
bb = addsource(160, 'B', 'reflect_brick')
addsource(180, 'C', 'menu_click')
addsource(200, 'D', 'shrink')
timer(100, 3, 128)
bb((95, 100))
timer(130, 5, 120, active=False)
zz((95, 130))
timer(160, 7, 128, active=False)
yy((95, 160))
timer(190, 8, 120)
aa((95, 190))
aa((95 + timerwidth/2, 190))
mytimer = Timer(rect=pygame.Rect((100, 250), (timerwidth,30)),
cycletime=1, color=128, active=True,
divisions=6)
world.add(mytimer)
world.add(DragSource((75, 250), image=renderletter("E", (255, 128, 128)),
instance = lambda pos:
Trigger(pos, renderletter("E", white), mytimer)))
trashf = os.path.join(mydir, 'trashcan_empty.png')
world.add(Trash((100, 300), pygame.image.load(trashf).convert()))
# Some basic instructions.
world.add(ImageDisplay((200, 300),
font.render("Drag things around with the mouse.", 1, white)))
world.add(ImageDisplay((200, 320),
font.render("The right mouse button exits.", 1, white)))
frames = 0
start = time.time()
while 1:
ev = pygame.event.poll()
if ev.type == pygame.NOEVENT:
world.redraw()
frames += 1
pygame.display.flip()
elif ev.type == pygame.MOUSEMOTION:
world.handle_motion(ev)
elif ev.type == pygame.MOUSEBUTTONDOWN:
if ev.button == 3: break
world.handle_click(ev)
elif ev.type == pygame.MOUSEBUTTONUP:
world.handle_release(ev)
elif ev.type == pygame.QUIT: break
end = time.time()
print "%.2f seconds, %.2f fps" % ((end - start), frames / (end - start))
print 'redraw times', world.redraw_profiler
if __name__ == '__main__': main(sys.argv)
