initial commit from cvs 1.6.2

1 files changed, 1470 insertions, 0 deletions

diff --git a/bubbob/boards.py b/bubbob/boards.py
new file mode 100644
index 0000000..dced6f5
--- /dev/null
+++ b/bubbob/boards.py
@@ -0,0 +1,1470 @@
+from __future__ import generators
+import random, os, sys, math
+import gamesrv
+import images
+
+CELL = 16    # this constant is inlined at some places, don't change
+HALFCELL = CELL//2
+FRAME_TIME = 0.025
+#DEFAULT_LEVEL_FILE = 'levels/scratch.py'
+
+BOARD_BKGND = 1    # 0 = black, 1 = darker larger wall tiles
+
+
+class Copyable:
+    pass   # see bonuses.py, class Clock
+
+
+class Board(Copyable):
+    letter    = 0
+    fire      = 0
+    lightning = 0
+    water     = 0
+    top       = 0
+    
+    WIND_DELTA = HALFCELL
+
+    def __init__(self, num):
+        # the subclasses should define 'walls', 'winds', 'monsters'
+        self.walls = walls = [line for line in self.walls.split('\n') if line]
+        self.winds = winds = [line for line in self.winds.split('\n') if line]
+        self.num = num
+        self.width = len(walls[0])
+        self.height = len(walls)
+        for line in walls:
+            assert len(line) == self.width, "some wall lines are longer than others"
+        for line in winds:
+            assert len(line) == self.width, "some wind lines are longer than others"
+        #assert walls[0] ==  walls[-1], "first and last lines must be identical"
+        assert len(winds) == self.height, "wall and wind heights differ"
+        self.walls_by_pos = {}
+        self.sprites = {}
+        if self.top:
+            testline = self.walls[0]
+        else:
+            testline = self.walls[-1]
+        self.holes = testline.find('  ') >= 0
+        self.playingboard = 0
+        self.bonuslevel = not self.monsters or (gamesrv.game.finalboard is not None and self.num >= gamesrv.game.finalboard)
+        self.cleaning_gen_state = 0
+
+    def set_musics(self, prefix=[]):
+        if (self.num+1) % 20 < 10:
+            gamesrv.set_musics(prefix + [images.music_intro], [images.music_game],
+                               reset=0)
+        else:
+            gamesrv.set_musics(prefix + [], [images.music_game2], reset=0)
+
+    def writesprites(self, name, xyicolist):
+        sprlist = self.sprites.setdefault(name, [])
+        xyicolist = xyicolist[:]
+        xyicolist.reverse()
+        for s in sprlist[:]:
+            if xyicolist:
+                s.move(*xyicolist.pop())
+            else:
+                s.kill()
+                sprlist.remove(s)
+        while xyicolist:
+            x, y, ico = xyicolist.pop()
+            sprlist.append(gamesrv.Sprite(ico, x, y))
+
+    def enter(self, complete=1, inplace=0, fastreenter=False):
+        global curboard
+        if inplace:
+            print "Re -",
+        print "Entering board", self.num+1
+        self.set_musics()
+        # add board walls
+        l = self.sprites.setdefault('walls', [])
+        bl = self.sprites.setdefault('borderwalls', [])
+        if inplace:
+            deltay = 0
+        else:
+            deltay = bheight
+        wnx = wny = 1
+        while haspat((self.num, wnx, 0)):
+            wnx += 1
+        while haspat((self.num, 0, wny)):
+            wny += 1
+        self.wnx = wnx
+        self.wny = wny
+
+        if haspat((self.num, 'l')):
+            lefticon = patget((self.num, 'l'))
+            if haspat((self.num, 'r')):
+                righticon = patget((self.num, 'r'))
+            else:
+                righticon = lefticon
+            xrange = range(2, self.width-2)
+        else:
+            xrange = range(self.width)
+            lefticon = righticon = None
+
+        if BOARD_BKGND == 1:
+            gl = self.sprites.setdefault('background', [])
+            xmax = (self.width-2)*CELL
+            ymax = self.height*CELL
+            y = -HALFCELL
+            ystep = 0
+            firstextra = 1
+            while y < ymax:
+                x = 2*CELL+HALFCELL
+                xstep = 0
+                while x < xmax:
+                    bitmap, rect = loadpattern((self.num, xstep, ystep),
+                                               images.KEYCOL)
+                    bitmap, rect = images.makebkgndpattern(bitmap, rect)
+                    if firstextra:
+                        # special position where a bit of black might show up
+                        x -= rect[2]
+                        xstep = (xstep-1) % wnx
+                        firstextra = 0
+                        continue
+                    bkgndicon = bitmap.geticon(*rect)
+                    w = gamesrv.Sprite(bkgndicon, x, y + deltay)
+                    gl.append(w)
+                    x += rect[2]
+                    xstep = (xstep+1) % wnx
+                y += rect[3]
+                ystep = (ystep+1) % wny
+        else:
+            gl = []
+
+        if lefticon is not None:
+            for y in range(0, self.height, lefticon.h // CELL):
+                bl.append(gamesrv.Sprite(lefticon, 0, y*CELL + deltay))
+
+        for y in range(self.height):
+            for x in xrange:
+                c = self.walls[y][x]
+                if c == '#':
+                    wallicon = patget((self.num, x%wnx, y%wny), images.KEYCOL)
+                    w = gamesrv.Sprite(wallicon, x*CELL, y*CELL + deltay)
+                    l.append(w)
+                    self.walls_by_pos[y,x] = w
+
+        if not l:
+            # self.sprites['walls'] must not be empty, for putwall
+            wallicon = patget((self.num, 0, 0), images.KEYCOL)
+            w = gamesrv.Sprite(wallicon, 0, -wallicon.h)
+            l.append(w)
+
+        if righticon is not None:
+            for y in range(0, self.height, lefticon.h // CELL):
+                bl.append(gamesrv.Sprite(righticon, (self.width-2)*CELL, y*CELL + deltay))
+
+        while deltay:
+            dy = -min(deltay, 8)
+            for w in gl:
+                w.step(0, dy)
+            for w in l:
+                w.step(0, dy)
+            for w in bl:
+                w.step(0, dy)
+            deltay += dy
+            yield 1
+
+        if inplace:
+            for w in images.ActiveSprites:
+                w.to_front()
+
+        curboard = self
+        if gamesrv.game:
+            gamesrv.game.updateboard()
+        if not complete:
+            return
+        # add players
+        from player import BubPlayer, scoreboard
+        if not inplace:
+            random.shuffle(BubPlayer.PlayerList)
+        scoreboard(1, inplace=inplace)
+        if not fastreenter:
+            random.shuffle(BubPlayer.PlayerList)
+            playing = []
+            for p in BubPlayer.PlayerList:
+                if p.isplaying():
+                    p.enterboard(playing)
+                    p.zarkon()
+                    playing.append(p)
+            for d in BubPlayer.DragonList:
+                d.enter_new_board()
+        else:
+            # kill stuff left over from leave(inplace=1) (Big Clock bonus only)
+            import bonuses
+            keepme = bonuses.Points
+            dragons = {}
+            playing = []
+            for p in BubPlayer.PlayerList:
+                if p.isplaying():
+                    for d in p.dragons:
+                        if hasattr(d, 'dcap'):
+                            d.dcap['shield'] = 90
+                        dragons[d] = True
+                    playing.append(p)
+            for s in images.ActiveSprites[:]:
+                if isinstance(s, keepme) or s in dragons:
+                    pass
+                else:
+                    s.kill()
+        # add monsters
+        if not self.bonuslevel:
+            import monsters
+            f_monsters = gamesrv.game.f_monsters
+            if f_monsters < 0.1:
+                f_monsters = max(1.0, min(2.0, (len(playing)-2)/2.2+1.0))
+            for mdef in self.monsters:
+                if not fastreenter:
+                    yield 2
+                cls = getattr(monsters, mdef.__class__.__name__)
+                dir = mdef.dir
+                i = random.random()
+                while i < f_monsters:
+                    cls(mdef, dir=dir)
+                    dir = -dir
+                    i += 1.0
+        self.playingboard = 1
+
+    def putwall(self, x, y, w=None):
+        wallicon = patget((self.num, x%self.wnx, y%self.wny), images.KEYCOL)
+        if w is None:
+            w = gamesrv.Sprite(wallicon, 0, bheight)
+            l = self.sprites['walls']
+            w.to_back(l[-1])
+            l.append(w)
+        self.walls_by_pos[y,x] = w
+        if y >= 0:
+            line = self.walls[y]
+            self.walls[y] = line[:x] + '#' + line[x+1:]
+
+    def killwall(self, x, y, kill=1):
+        w = self.walls_by_pos[y,x]
+        if kill:
+            l = self.sprites['walls']
+            if len(l) > 1:
+                l.remove(w)
+                w.kill()
+            else:
+                # self.sprites['walls'] must never be empty
+                # or putwall will crash!
+                w.move(0, -bheight)
+        del self.walls_by_pos[y,x]
+        line = self.walls[y]
+        self.walls[y] = line[:x] + ' ' + line[x+1:]
+        return w
+
+    def reorder_walls(self):
+        walls_by_pos = self.walls_by_pos
+        items = [(yx, w1.ico) for yx, w1 in walls_by_pos.items()]
+        if not items:
+            return   # otherwise self.sprites['walls'] would be emptied
+        items.sort()
+        l = self.sprites['walls']
+        while len(l) > len(items):
+            l.pop().kill()
+        assert len(items) == len(l)
+        for ((y,x), ico), w2 in zip(items, l):
+            w2.move(x*CELL, y*CELL, ico)
+            walls_by_pos[y,x] = w2
+
+    def leave(self, inplace=0):
+        global curboard
+        if not gamesrv.has_loop_music():
+            gamesrv.fadeout(1.5)
+        from player import BubPlayer
+        for p in BubPlayer.PlayerList:
+            if p.isplaying():
+                p.savecaps()
+        if BubPlayer.LeaveBonus:
+            for t in BubPlayer.LeaveBonus:
+                yield t
+            BubPlayer.LeaveBonus = None
+        curboard = None
+        if inplace:
+            i = -1
+        else:
+            while images.ActiveSprites:
+                s = random.choice(images.ActiveSprites)
+                s.kill()
+                yield 0.9
+            i = 0
+        sprites = []
+        for l in self.sprites.values():
+            sprites += l
+        self.sprites.clear()
+        self.walls_by_pos.clear()
+        random.shuffle(sprites)
+        for s in sprites:
+            s.kill()
+            if i:
+                i -= 1
+            else:
+                yield 0.32
+                i = 3
+        if not inplace:
+            for p in BubPlayer.PlayerList:
+                if p.isplaying():
+                    p.zarkoff()
+            yield 4
+
+    def clean_gen_state(self):
+        self.cleaning_gen_state = 1
+        while len(BoardGen) > 1:
+            #yield force_singlegen()
+            #if 'flood' in self.sprites:
+            #    for s in self.sprites['flood']:
+            #        s.kill()
+            #    del self.sprites['flood']
+            yield normal_frame()
+        self.cleaning_gen_state = 0
+
+def bget(x, y):
+    if 0 <= x < curboard.width:
+        if y < 0 or y >= curboard.height:
+            y = 0
+        return curboard.walls[y][x]
+    else:
+        return '#'
+
+def wget(x, y):
+    delta = curboard.WIND_DELTA
+    x = (x + delta) // 16
+    y = (y + delta) // 16
+    if 0 <= x < curboard.width:
+        if y < 0:
+            y = 0
+        elif y >= curboard.height:
+            y = -1
+        return curboard.winds[y][x]
+    elif x < 0:
+        return '>'
+    else:
+        return '<'
+
+def onground(x, y):
+    if y & 15:
+        return 0
+    x0 = (x+5) // 16
+    x1 = (x+16) // 16
+    x2 = (x+27) // 16
+    y0 = y // 16 + 2
+
+    if x0 < 0 or x2 >= curboard.width:
+        return 0
+    y1 = y0 - 1
+    if not (0 < y0 < curboard.height):
+        if y0 != curboard.height:
+            y1 = 0
+        y0 = 0
+    y0 = curboard.walls[y0]
+    y1 = curboard.walls[y1]
+    return (' ' == y1[x0] == y1[x1] == y1[x2] and
+            not (' ' == y0[x0] == y0[x1] == y0[x2]))
+    #return (' ' == bget(x0,y0-1) == bget(x1,y0-1) == bget(x2,y0-1) and
+    #        not (' ' == bget(x0,y0) == bget(x1,y0) == bget(x2,y0)))
+    #return (bget(x1,y0-1)==' ' and
+    #        ((bget(x1,y0)=='#') or
+    #         (bget(x0,y0)=='#' and bget(x0,y0-1)==' ') or
+    #         (bget(x2,y0)=='#' and bget(x2,y0-1)==' ')))
+
+def onground_nobottom(x, y):
+    return onground(x, y) and y+32 < bheight
+
+def underground(x, y):
+    if y % CELL:
+        return 0
+    x0 = (x+5) // CELL
+    x1 = (x+CELL) // CELL
+    x2 = (x+2*CELL-5) // CELL
+    y0 = y // CELL
+
+    if x0 < 0 or x2 >= curboard.width:
+        return 0
+    y1 = y0 - 1
+    if not (0 < y0 < curboard.height):
+        if y0 != curboard.height:
+            y1 = 0
+        y0 = 0
+    y0 = curboard.walls[y0]
+    y1 = curboard.walls[y1]
+    return (' ' == y0[x0] == y0[x1] == y0[x2] and
+            not (' ' == y1[x0] == y1[x1] == y1[x2]))
+
+def x2bounds(x):
+    if x < 32:
+        return 32
+    elif x > bwidth - 64:
+        return bwidth - 64
+    else:
+        return x
+
+def vertical_warp(nx, ny):
+    if ny >= bheight:
+        ny -= bheightmod
+    elif ny < -32:
+        ny += bheightmod
+    return nx, ny
+
+def vertical_warp_sprite(spr):
+    if spr.y >= bheight:
+        spr.step(0, -bheightmod)
+    elif spr.y < -32:
+        spr.step(0, bheightmod)
+
+##def vertical_warp(nx, ny):
+##    if ny >= bheight:
+##        ny -= bheightmod
+##    elif ny < -32:
+##        ny += bheightmod
+##    else:
+##        return (nx, ny), 0
+##    from player import BubPlayer
+##    if BubPlayer.Moebius:
+##        nx = bwidth - 2*CELL - nx
+##        return (nx, ny), 1
+##    else:
+##        return (nx, ny), 0
+
+
+MODULES = ['boards', 'bonuses', 'bubbles', 'images',
+           'mnstrmap', 'monsters', 'player', 'ranking',
+           'binboards', 'macbinary', 'boarddef',
+           'ext1', 'ext2', 'ext3', 'ext4', 'ext5', 'ext6', 'ext7']
+
+def loadmodules(force=0):
+    levelfilename = gamesrv.game.levelfile
+    modulefiles = {None: levelfilename}
+    for m in MODULES:
+        if os.path.isfile(m+'.py'):
+            modulefiles[m] = m+'.py'
+        elif os.path.isfile(os.path.join(m, '__init__.py')):
+            modulefiles[m] = os.path.join(m, '__init__.py')
+    mtimes = {}
+    for m, mfile in modulefiles.items():
+        mtimes[m] = os.stat(mfile).st_mtime
+    reload = force or (mtimes != getattr(sys, 'ST_MTIMES', None))
+    import player
+    playerlist = player.BubPlayer.PlayerList
+    if reload:
+        delete = hasattr(sys, 'ST_MTIMES')
+        sys.ST_MTIMES = mtimes
+        if delete:
+            print "Reloading modules."
+            for m, mfile in modulefiles.items():
+                if m is not None and m in sys.modules:
+                    del sys.modules[m]
+
+    # Clear
+    clearallsprites()
+
+    import player
+    for p in playerlist:
+        player.upgrade(p)
+    for n in range(len(playerlist), images.MAX):
+        playerlist.append(player.BubPlayer(n))
+    player.BubPlayer.PlayerList = playerlist
+    if reload:
+        import boards
+        from images import haspat, loadpattern
+        boards.haspat = haspat
+        boards.loadpattern = loadpattern
+        del boards.BoardList[:]
+        if levelfilename.lower().endswith('.py'):
+            levels = {}
+            print 'Source level file:', levelfilename
+            execfile(levelfilename, levels)
+            if 'GenerateLevels' in levels:
+                levels = levels['GenerateLevels']()
+                if isinstance(levels, list):
+                    levels = dict(zip(range(len(levels)), levels))
+        else:
+            import binboards
+            levels = binboards.load(levelfilename)
+        boards.register(levels)
+    return reload
+
+def clearallsprites():
+    gamesrv.clearsprites()
+    import images
+    del images.ActiveSprites[:]
+    images.SpritesByLoc.clear()
+
+def wait_for_one_player():
+    from player import BubPlayer
+    clearallsprites()
+    nimages = None
+    while not [p for p in BubPlayer.PlayerList if p.isplaying()]:
+        yield 3
+        if not nimages:
+            desc = getattr(gamesrv.game, 'FnDesc', '?')
+            host, port = getattr(gamesrv.game, 'address', ('?', '?'))
+            images.writestrlines([
+                "Welcome to",
+                desc.upper(),
+                "at %s:%s" % (host.lower(), port),
+                None,
+                "Click on your Favorite Color's Dragon",
+                "Choose four keys: Right, Left, Jump, Shoot",
+                "and Let's Go!",
+                None,
+                "Click again for more than one player",
+                "on the same machine.",
+                ])
+            
+            from mnstrmap import PlayerBubbles
+            nimages = [PlayerBubbles.bubble[0],
+                       PlayerBubbles.bubble[1],
+                       PlayerBubbles.bubble[1],
+                       PlayerBubbles.bubble[0],
+                       PlayerBubbles.bubble[2],
+                       PlayerBubbles.bubble[2]]
+            screenwidth = bwidth + 9*CELL
+            screenheight = bheight
+
+            def welcomebubbling(self):
+                fx = self.x
+                dx = (random.random() - 0.5) * 1.9
+                for y in range(self.y-3, -self.ico.h, -3):
+                    fx += dx
+                    self.move(int(fx), y)
+                    yield None
+                    if y == self.ypop:
+                        from mnstrmap import PlayerBubbles
+                        self.setimages(None)
+                        self.gen.append(self.die(PlayerBubbles.explosion))
+                self.kill()
+
+            yield 10
+            gamesrv.set_musics([], [images.music_game2], reset=0)
+        
+        if ((not images.ActiveSprites or random.random() < 0.05678) and
+            gamesrv.clients):
+            # make sure the extension's images are loaded too
+            # NB. this is also needed for import auto-detection
+            import ext1; import ext2; import ext3
+            import ext4; import ext5; import ext6
+            import ext7
+            
+            ico = images.sprget(nimages[0])
+            s = images.ActiveSprite(ico,
+                                    random.randrange(0, screenwidth-ico.w),
+                                    screenheight)
+            s.ypop = random.randrange(-ico.h, screenheight)
+            s.gen = [welcomebubbling(s)]
+            s.setimages(s.cyclic(nimages, speed=1))
+            if random.random() > 0.4321:
+                try:
+                    key, (filename, (x, y, w, h)) = random.choice(
+                        images.sprmap.items())
+                except:
+                    w = h = 0
+                if w == h == 32:
+                    s2 = images.ActiveSprite(images.sprget(key), -32, 0)
+                    s2.gen = [s2.following(s, (s.ico.w-32)//2, (s.ico.h-32)//2)]
+                    s.ypop = None
+        images.action(images.ActiveSprites[:])
+
+def patget(n, keycol=None):
+    bitmap, rect = loadpattern(n, keycol)
+    return bitmap.geticon(*rect)
+
+def get_lives():
+    return gamesrv.game.limitlives
+
+def do_nothing():
+    while True:
+        yield 5
+
+BoardList = []
+curboard = None
+BoardGen = [do_nothing()]
+
+def next_board(num=0, complete=1, fastreenter=False):
+    yield force_singlegen()
+    set_frametime(1.0)
+    brd = curboard
+    inplace = 0
+    if brd:
+        inplace = brd.bonuslevel or fastreenter
+        num = brd.num
+        if not inplace:
+            num += gamesrv.game.stepboard
+            if num >= len(BoardList):
+                num = len(BoardList)-1
+            if (gamesrv.game.finalboard is not None and num > gamesrv.game.finalboard):
+                num = gamesrv.game.finalboard
+        for t in brd.leave(inplace=inplace):
+            yield t
+
+    # reset global board state
+    from player import BubPlayer, reset_global_board_state
+    reset_global_board_state()
+    if not inplace:
+        del BubPlayer.MonsterList[:]
+        # wait for at least one player
+        for t in wait_for_one_player():
+            yield t
+        # reload modules if changed
+        if loadmodules():
+            import boards
+            boards.BoardGen = [boards.next_board(num)]
+            return
+
+    if num < 0:
+        num = 0
+    elif num >= len(BoardList):
+        num = len(BoardList)-1
+    brd = BoardList[num](num)
+    for t in brd.enter(complete, inplace=inplace, fastreenter=fastreenter):
+        yield t
+
+    if brd.bonuslevel:
+        gen = bonus_play
+    else:
+        gen = normal_play
+    BoardGen[0] = gen()
+
+def set_frametime(ft, privtime=100):
+    from player import BubPlayer
+    BubPlayer.BaseFrametime = ft
+    BubPlayer.PlayersPrivateTime = privtime
+    images.loadsounds(1.0 / ft)
+
+def extra_boardgen(gen, at_end=0):
+    if curboard.playingboard:
+        if at_end or not BoardGen:
+            BoardGen.append(gen)
+        else:
+            BoardGen.insert(1, gen)
+
+def replace_boardgen(gen, force=0):
+    if curboard.playingboard or force:
+        curboard.playingboard = 0
+        BoardGen[0] = gen
+
+def force_singlegen():
+    del BoardGen[1:]
+    return 0
+
+def has_singlegen():
+    return len(BoardGen) <= 1
+
+def display_hat(p, d):
+    if p.team == -1 or getattr(d,'isdying',0) or hasattr(d,'no_hat'):
+        return
+    try:
+        bottom_up = d.bottom_up()
+    except AttributeError:
+        bottom_up = 0
+    try:
+        image = ('hat', p.team, d.dir, d.hatangle)
+    except AttributeError:
+        image = ('hat', p.team)
+    if bottom_up:
+        image = 'vflip', image
+        y = d.y
+    else:
+        y = d.y - 16
+    ico = images.sprget(image)
+    if (getattr(d,'hatsprite',None) is None or
+        not d.hatsprite.alive):
+        d.hatsprite = images.ActiveSprite(ico, d.x, y)
+    else:
+        d.hatsprite.to_front()
+        d.hatsprite.move(d.x, y, ico)
+    d.hatsprite.gen = [d.hatsprite.die([None])]
+
+def normal_frame():
+    from player import BubPlayer
+    BubPlayer.FrameCounter += 1
+
+    # main generator dispatch loop
+    images.action(images.ActiveSprites[:])
+    
+    frametime = 10
+    for p in BubPlayer.PlayerList:
+        if p.isplaying():
+            frametime = BubPlayer.BaseFrametime
+            p.zarkon()
+            for d in p.dragons:
+                d.to_front()
+                display_hat(p, d)
+                d.prefix(p.pn)
+    if not (BubPlayer.FrameCounter & 31):
+        gamesrv.compactsprites()
+        reset = getattr(BubPlayer, 'MultiplyerReset', 0)
+        if reset and BubPlayer.FrameCounter >= reset:
+            BubPlayer.MultiplyerReset = 0
+            set_frametime(1.0)
+    return frametime
+
+def normal_play():
+    from player import BubPlayer
+    import bonuses
+    framecounter = 0
+    bonus_callback = bonuses.start_normal_play()
+    while BubPlayer.MonsterList:
+        bonus_callback()
+        yield normal_frame()
+        if not BubPlayer.DragonList:
+            continue
+        framecounter += 1
+        BASE = 500
+        if not (framecounter % BASE):
+            if framecounter == 4*BASE:
+                from monsters import Monster
+                from mnstrmap import BigImages
+                ico = images.sprget(BigImages.hurryup[1])
+                s = images.ActiveSprite(ico, (bwidth-ico.w)//2, (bheight-ico.h)//2)
+                s.setimages(s.die(BigImages.hurryup * 12, 2))
+                images.Snd.Hurry.play()
+                mlist = [s for s in images.ActiveSprites
+                         if (isinstance(s, Monster) and s.regular() and
+                             not s.angry)]
+                if mlist:
+                    s = random.choice(mlist)
+                    s.angry = [s.genangry()]
+                    s.resetimages()
+            if framecounter >= 6*BASE:
+                mlist = [s for s in images.ActiveSprites
+                         if isinstance(s, Monster) and s.regular() and s.angry]
+                if mlist:
+                    images.Snd.Hell.play()
+                    gamesrv.set_musics([], [])
+                    s = random.choice(mlist)
+                    s.become_ghost()
+                    framecounter = -200
+                else:
+                    framecounter = 2*BASE
+            if framecounter == 0:
+                curboard.set_musics()
+    replace_boardgen(last_monster_killed(), 1)
+
+##def normal_play():
+##    # TESTING!!
+##    from player import BubPlayer
+##    for p in BubPlayer.PlayerList:
+##        if not p.icons:
+##            p.loadicons(p.icons, images.sprget)
+##    results = {BubPlayer.PlayerList[0]: 100,
+##               BubPlayer.PlayerList[1]: 200,
+##               BubPlayer.PlayerList[2]: 300,
+##               BubPlayer.PlayerList[3]: 400,
+##               BubPlayer.PlayerList[4]: 100,
+##               BubPlayer.PlayerList[5]: 200,
+##               BubPlayer.PlayerList[6]: 300,
+##               BubPlayer.PlayerList[7]: 400,
+##               BubPlayer.PlayerList[8]:1000,
+##               BubPlayer.PlayerList[9]:1000,
+##               }
+##    maximum = None
+##    for t in result_ranking(results, maximum):
+##        yield t
+
+def last_monster_killed(end_delay=390, music=None):
+    from player import BubPlayer
+    for t in exit_board(music=music):
+        yield t
+    if curboard.bonuslevel:
+        curboard.playingboard = 1
+        for t in bonus_play():
+            yield t
+            end_delay -= 1
+            if end_delay <= 0:
+                replace_boardgen(next_board(), 1)
+                break
+    else:
+        for i in range(end_delay):
+            yield normal_frame()
+        replace_boardgen(next_board(), 1)
+
+##def bonus_play():
+##    from player import BubPlayer
+##    import bubbles
+##    while BubPlayer.LimitScoreColor is None:
+##        yield normal_frame()
+##        players = [(p.points, p.pn) for p in BubPlayer.PlayerList
+##                   if p.isplaying()]
+##        if players:
+##            players.sort()
+##            points, BubPlayer.LimitScoreColor = players[-1]
+##            BubPlayer.LimitScore = ((points + limit) // 100000) * 100000
+##    for p in BubPlayer.PlayerList:
+##        if p.isplaying():
+##            p.givepoints(0)  # check LimitScore and update scoreboard()
+##    while not (BubPlayer.BubblesBecome or BubPlayer.MegaBonus):
+##        if random.random() < 0.06:
+##            bubbles.newbonusbubble()
+##        yield normal_frame()
+##    # special board end
+##    import monsters
+##    monsters.argh_em_all()
+##    replace_boardgen(last_monster_killed(), 1)
+
+class TimeCounter(Copyable):
+    def __init__(self, limittime, blink=0):
+        from player import BubPlayer
+        self.saved_time = BubPlayer.LimitTime
+        self.time = limittime / FRAME_TIME
+        self.prev = None
+        self.blink = blink
+    def update(self, t):
+        from player import BubPlayer, scoreboard
+        self.time -= t
+        if self.time < 0.0:
+            self.time = 0.0
+        BubPlayer.LimitTime = self.time * FRAME_TIME
+        next = int(BubPlayer.LimitTime)
+        if self.blink and BubPlayer.LimitTime - next >= 0.5:
+            BubPlayer.LimitTime = next = None
+        if self.prev != next:
+            scoreboard(compresslimittime=1)
+            self.prev = next
+    def restore(self):
+        from player import BubPlayer
+        BubPlayer.LimitTime = self.saved_time
+
+def bonus_play():
+    from player import BubPlayer
+    import bubbles
+    BubPlayer.MegaBonus = None
+    BubPlayer.BubblesBecome = None
+    Time0 = 5.0 / FRAME_TIME  # when to slow down time
+    tc = TimeCounter(BubPlayer.LimitTime or 180.9)   # 3:00
+    prev = None
+    while not (BubPlayer.BubblesBecome or BubPlayer.MegaBonus):
+        if random.random() < 0.099:
+            bubbles.newbonusbubble()
+        t = normal_frame()
+        tc.update(t)
+        if tc.time < Time0:
+            if tc.time <= 0.5:
+                tc.time = 0.5
+                BubPlayer.LimitTime = 0.0
+            t *= math.sqrt(Time0 / tc.time)
+        yield t
+        if tc.time == 0.5:
+            gamesrv.game.End = 'gameover'
+            gamesrv.game.updateboard()
+            replace_boardgen(game_over(), 1)
+            return
+    # special board end
+    import monsters
+    monsters.argh_em_all()
+    replace_boardgen(last_monster_killed(), 1)
+
+def game_over():
+    yield force_singlegen()
+    from player import scoreboard
+    import ranking
+    images.Snd.Extralife.play()
+    gamesrv.set_musics([], [images.music_potion])
+    scoreboard()
+    for t in ranking.game_over():
+        yield t
+
+def game_reset():
+    import time
+    from player import BubPlayer
+    t1 = time.time()
+    while 1:
+        yield 0
+        if BubPlayer.LimitTime and BubPlayer.LimitTime >= 1.0:
+            # someone else ticking the clock, try again later
+            return
+        if abs(time.time() - t1) > 2.0:
+            break
+    # anyone playing ?
+    if not gamesrv.game.End:
+        return  # yes -> cancel game_reset()
+    # let's tick the clock !
+    tc = TimeCounter(60.9, blink=1)   # 1:00
+    t1 = time.time()
+    while tc.time:
+        yield 0
+        # anyone playing now ?
+        if not gamesrv.game.End:
+            tc.restore()
+            return  # yes -> cancel game_reset()
+        t = time.time()  # use real time
+        deltat = (t-t1)/FRAME_TIME
+        if deltat < 1.0:
+            deltat = 1.0
+        elif deltat > 100.0:
+            deltat = 100.0
+        tc.update(deltat)
+        t1 = t
+    gamesrv.game.reset()
+
+##def wasting_play():
+##    from player import BubPlayer, scoreboard
+##    import bubbles
+##    curboard.wastingplay = {}
+##    for p in BubPlayer.PlayerList:
+##        if p.isplaying():
+##            p.letters = {}
+##            p.bonbons = p.points // 50000
+##    scoreboard()
+    
+##    while len(BubPlayer.DragonList) > 1:
+##        if random.random() < 0.03:
+##            bubbles.newbubble(1)
+##        yield normal_frame()
+##    for d in BubPlayer.DragonList:
+##        curboard.wastingplay[d.bubber] = len(curboard.wastingplay)
+##    for i in range(50):
+##        yield normal_frame()
+
+##    total = len(curboard.wastingplay)
+##    results = [(total-n, p) for p, n in curboard.wastingplay.items()]
+##    results.sort()
+##    results = [(p, str(n)) for n, p in results]
+##    for t in display_ranking(results):
+##        yield t
+##    # never ending
+
+def skiplevels(blink, skip):
+    # (not used any more)
+    saved = BoardGen[:]
+    while skip:
+        skip -= 1
+        BoardGen[:] = saved
+        for i in range(10):  # frozen pause
+            yield 3
+            if blink:
+                blink.step(-bwidth, 0)
+                yield 3.33
+                blink.step(bwidth, 0)
+        blink = None
+        for t in next_board(complete=(skip==0)):
+            yield t
+
+def exit_board(delay=8, music=None, repeatmusic=[]):
+    from bubbles import Bubble
+    from bonuses import RandomBonus, end_normal_play
+    from player import BubPlayer
+    from monsters import Monster
+    end_normal_play()
+    curboard.playingboard = 0
+    actives = images.ActiveSprites[:]
+    for s in actives:
+        if ((isinstance(s, Monster) and s.still_playing())
+            or isinstance(s, RandomBonus)):
+            s.kill()
+    music = music or []
+    if BubPlayer.MegaBonus:
+        music[:1] = [images.music_modern]
+    if music or repeatmusic:
+        gamesrv.set_musics(music, repeatmusic)
+    for i in range(delay):
+        yield normal_frame()
+    bubble_outcome = BubPlayer.BubblesBecome or Bubble.pop
+    for s in actives:
+        if isinstance(s, Bubble):
+            bubble_outcome(s)
+            yield normal_frame()
+    if BubPlayer.MegaBonus:
+        BubPlayer.MegaBonus()
+
+def potion_fill(blist, big=0):
+    from player import BubPlayer
+    from bonuses import Bonus
+    #timeleft = 1680.0
+    for t in exit_board(0, music=[images.music_potion]):
+        #timeleft -= t
+        yield t
+    notes = all_notes = []
+    y = 1
+    while y < 11 or (y < height-2 and (len(all_notes) < 10 or big)):
+        for x in range(2, width-3, 2):
+            if ' ' == bget(x,y) == bget(x+1,y) == bget(x,y+1) == bget(x+1,y+1):
+                b = Bonus(x*CELL, y*CELL, falling=0, *blist[((x+y)//2)%len(blist)])
+                b.timeout = (444,666)[big]
+                all_notes.append(b)
+        for i in range(2):
+            t = normal_frame()
+            #timeleft -= t
+            yield t
+        y += 2
+    while notes: #and timeleft > 0.0:
+        notes = [b for b in notes if b.alive]
+        t = normal_frame()
+        #timeleft -= t
+        yield t
+    for i in range(10):
+        t = normal_frame()
+        #timeleft -= t
+        yield t
+    results = {}
+    for b in all_notes:
+        for d in b.taken_by:
+            bubber = d.bubber
+            results[bubber] = results.get(bubber, 0) + 1
+    for t in result_ranking(results, len(all_notes)):
+        yield t
+    #fadeouttime = 3.33
+    #fullsoundframes = bonusframes - 10 - int(fadeouttime / FRAME_TIME)
+    #for i in range(fullsoundframes):
+    #    yield normal_frame()
+    #gamesrv.fadeout(fadeouttime)
+    #for i in range(fullsoundframes, 490):
+    #    yield normal_frame()
+
+def result_ranking(results, maximum=None, timeleft=200):
+    import ranking
+    results = ranking.ranking_picture(results, maximum, timeleft is not None)
+    if curboard.bonuslevel and timeleft is not None:
+        play_again = bonus_play()
+    else:
+        play_again = None
+    for t in ranking.display(results, timeleft, play_again):
+        yield t
+    if gamesrv.game.End != 'gameover':
+        gamesrv.set_musics([], [])
+        replace_boardgen(next_board(), 1)
+
+def extra_water_flood():
+    from mnstrmap import Flood
+    from monsters import Monster
+    waves_icons = [images.sprget(n) for n in Flood.waves]
+    fill_icon = images.sprget(Flood.fill)
+    bspr = []
+    if 'flood' in curboard.sprites:
+        return    # only one flooding at a time
+    curboard.sprites['flood'] = bspr
+    waves_sprites = [gamesrv.Sprite(waves_icons[0], x, bheight-CELL)
+                     for x in range(0, bwidth, CELL)]
+    bspr += waves_sprites
+    fill_by_line = []
+    poplist = [None]
+    while waves_sprites[0].y > 0:
+        yield 0
+        waves_icons.insert(0, waves_icons.pop())
+        for s in waves_sprites:
+            s.seticon(waves_icons[0])
+        yield 0
+        sprites = [gamesrv.Sprite(fill_icon, s.x, s.y) for s in waves_sprites]
+        bspr += sprites
+        fill_by_line.append(sprites)
+        for s in waves_sprites:
+            s.step(0, -16)
+        for s in images.touching(0, waves_sprites[0].y, bwidth, bheight):
+            if isinstance(s, Monster):
+                s.argh(poplist)
+    while 1:
+        for i in range(2):
+            yield 0
+            waves_icons.insert(0, waves_icons.pop())
+            for s in waves_sprites:
+                s.seticon(waves_icons[0])
+        if not fill_by_line:
+            break
+        for s in fill_by_line.pop():
+            s.kill()
+        for s in waves_sprites:
+            s.step(0, 16)
+    for s in waves_sprites:
+        s.kill()
+    del curboard.sprites['flood']
+
+def extra_aquarium():
+    from mnstrmap import Flood
+    from player import BubPlayer
+    for i in range(200):
+        if 'flood' not in curboard.sprites:  # only one flooding at a time
+            break
+        yield 0
+        if curboard.cleaning_gen_state:
+            return
+    else:
+        return
+    curboard.sprites['flood'] = []
+    gl = curboard.sprites.setdefault('background', [])
+    curboard.holes = True     # so that random PlainBubbles show up anyway
+    walls = curboard.sprites['walls']
+    seen = {}
+
+    def newsprite(ico, x, y):
+        s = gamesrv.Sprite(ico, x, y)
+        s.to_back(walls[0])
+        gl.append(s)
+        return s
+
+    def fishplayers(ymin):
+        for d in BubPlayer.DragonList:
+            if d not in seen and d.y >= ymin:
+                seen[d] = True
+                d.become_fish()
+                d.bubber.emotic(d, 4)
+
+    waves_icons = [images.sprget(n) for n in Flood.waves]
+    fill_icon = images.sprget(Flood.fill)
+    waves_sprites = [newsprite(waves_icons[0], x, bheight-CELL)
+                     for x in range(2*CELL + HALFCELL, bwidth - 2*CELL, CELL)]
+    while waves_sprites[0].y > -fill_icon.h:
+        fishplayers(waves_sprites[0].y)
+        yield 0
+        waves_icons.append(waves_icons.pop(0))
+        for s in waves_sprites:
+            s.seticon(waves_icons[0])
+        fishplayers(waves_sprites[0].y)
+        yield 0
+        for s in waves_sprites:
+            newsprite(fill_icon, s.x, s.y)
+        for s in waves_sprites:
+            s.step(0, -16)
+    for s in waves_sprites:
+        s.kill()
+    BubPlayer.SuperFish = True
+    fishplayers(-sys.maxint)
+
+def extra_walls_falling():
+    walls_by_pos = curboard.walls_by_pos
+    moves = 1
+    while moves and not curboard.cleaning_gen_state:
+        moves = 0
+        for y in range(height-3, -1, -1):
+            for x in range(2, width-2):
+                if ((y,x) in walls_by_pos and
+                    (y+1,x) not in walls_by_pos and
+                    (y+2,x) not in walls_by_pos):
+                    y0 = y
+                    while (y0-1,x) in walls_by_pos:
+                        y0 -= 1
+                    w = curboard.killwall(x, y0, 0)
+                    curboard.putwall(x, y+1, w)
+                    moves = 1
+        curboard.reorder_walls()
+        for y in range(6):
+            yield 0
+
+def single_blocks_falling(xylist):
+    walls_by_pos = curboard.walls_by_pos
+    while xylist:
+        newlist = []
+        for x, y in xylist:
+            if ((y,x) in walls_by_pos and (y+1,x) not in walls_by_pos and
+                y < curboard.height-1):
+                newlist.append((x, y+1))
+        for x, y in newlist:
+            w = curboard.killwall(x, y-1, 0)
+            curboard.putwall(x, y, w)
+        xylist = newlist
+        curboard.reorder_walls()
+        for i in range(7):
+            yield 0
+
+def extra_display_repulse(cx, cy, dlimit=5000, dfactor=1000):
+    offsets = {}
+    for s in gamesrv.sprites_by_n.values():
+        x, y = s.getdisplaypos()
+        if x is not None:
+            dx = x - cx
+            dy = y - cy
+            d = dx*dx + dy*dy + 100
+            if d <= dlimit:
+                dx = (dx*dfactor)//d
+                dy = (dy*dfactor)//d
+                offsets[s] = dx, dy
+                s.setdisplaypos(int(x+dx), int(y+dy))
+    yield 0
+    yield 0
+    while offsets:
+        prevoffsets = offsets
+        offsets = {}
+        for s, (dx, dy) in prevoffsets.items():
+            if s.alive:
+                if dx < 0:
+                    dx += max(1, (-dx)//5)
+                elif dx:
+                    dx -= max(1, dx//5)
+                if dy < 0:
+                    dy += max(1, (-dy)//5)
+                elif dy:
+                    dy -= max(1, dy//5)
+                if dx or dy:
+                    offsets[s] = dx, dy
+                s.setdisplaypos(int(s.x+dx), int(s.y+dy))
+        yield 0
+
+def extra_bkgnd_black(cx, cy):
+    gl = curboard.sprites.get('background')
+    dist = 0
+    while gl:
+        dist += 17
+        dist2 = dist * dist
+        gl2 = []
+        for s in gl:
+            if (s.x-cx)*(s.x-cx) + (s.y-cy)*(s.y-cy) < dist2:
+                s.kill()
+            else:
+                gl2.append(s)
+        gl[:] = gl2
+        yield 0
+
+def extra_light_off(timeout, icocache={}):
+    for i in range(timeout):
+        if curboard.cleaning_gen_state:
+            break
+        dragons = {}
+        import player
+        playerlist = player.BubPlayer.PlayerList
+        for bubber in playerlist:
+            for dragon in bubber.dragons:
+                dragons[dragon] = True
+        for s in gamesrv.sprites_by_n.values():
+            try:
+                ico = icocache[s.ico, s in dragons]
+            except KeyError:
+                ico = images.make_darker(s.ico, s in dragons)
+                icocache[s.ico, s in dragons] = ico
+            s.setdisplayicon(ico)
+        yield 0
+    for s in gamesrv.sprites_by_n.values():
+        s.setdisplayicon(s.ico)
+
+def extra_swap_up_down(N=27):
+    # unregister all walls
+    walls = curboard.walls_by_pos.items()
+    walls.sort()
+    if not walls:
+        return
+    curboard.walls_by_pos.clear()
+    emptyline = '##' + ' '*(width-4) + '##'
+    curboard.walls = [emptyline] * height
+    l = curboard.sprites['walls']
+    wallicon = l[0].ico
+    wallpool = l[:]
+    l[:] = [gamesrv.Sprite(wallicon, 0, -wallicon.h)]
+    
+    # force the top half of the walls on front
+    #for (y,x), w in walls:
+    #    if y*2 < height:
+    
+    # show the walls swapping up/down
+    ycenter = ((height-1)*CELL) // 2
+    for i in range(N):
+        alpha = math.cos((math.pi*(i+1))/N)
+        ymap = {}
+        for y in range(height):
+            ymap[y] = int(alpha*(y*CELL-ycenter)) + ycenter
+        for (y,x), w in walls:
+            if y in ymap:
+                w.move(x*CELL, ymap[y])
+        yield 0
+        if i == (N+1)//2:
+            # reorder the wall sprites in the middle of the swap
+            walls = [((-y,x), w) for (y,x), w in walls]
+            walls.sort()
+            for i in range(len(walls)):
+                (y,x), w = walls[i]
+                walls[i] = (y,x), wallpool[i]
+            walls = [((-y,x), w) for (y,x), w in walls]
+            walls.sort()
+            # reverse all dragons!
+            from player import BubPlayer
+            for dragon in BubPlayer.DragonList:
+                dragon.dcap['gravity'] *= -1.0
+    
+    # freeze the walls in their new position
+    i = 0
+    for (y,x), w in walls:
+        y = height-1 - y
+        if 0 <= y < height and (y,x) not in curboard.walls_by_pos:
+            w = wallpool[i]
+            i += 1
+            curboard.putwall(x, y, w)
+    l[:0] = wallpool[:i]
+    for w in wallpool[i:]:
+        w.kill()
+    curboard.reorder_walls()
+
+def extra_catch_all_monsters(dragons=[], everything=False):
+    from monsters import Monster
+    from bubbles import BigBubbleCatcher
+    from bonuses import Bonus, BonusMaker
+    if not dragons:
+        from player import BubPlayer
+        dragons = BubPlayer.DragonList
+    i = 0
+    give_up = 33
+    for s in images.ActiveSprites[:]:
+        if curboard.cleaning_gen_state:
+            break
+        while not dragons:
+            give_up -= 1
+            if give_up == 0:
+                return
+            yield 0
+        if not s.alive or not s.touchable:
+            continue
+        if isinstance(s, Bonus):
+            ok = s.bubblable
+        elif isinstance(s, BonusMaker):
+            ok = everything
+        else:
+            ok = isinstance(s, Monster)
+        if ok:
+            dragon = dragons[i%len(dragons)]
+            BigBubbleCatcher(dragon, s, 542 + 17*i)
+            i += 1
+            yield 0
+            yield 0
+
+def extra_make_random_level(cx=None, cy=None, repeat_delay=200):
+    from bonuses import DustStar
+    # generate any random level
+    localdir = os.path.dirname(__file__)
+    filename = os.path.join(localdir, 'levels', 'RandomLevels.py')
+    d = {}
+    execfile(filename, d)
+    Level = d['GenerateSingleLevel'](curboard.width, curboard.height)
+    lvl = Level(curboard.num)
+    walllist = []
+    if cx is None: cx = bwidth // 2
+    if cy is None: cy = bheight // 2
+    for y in range(curboard.height):
+        dy = cy - (y*16+8)
+        dy2 = dy*dy*0.75
+        for x in range(2, curboard.width-2):
+            dx = cx - (x*16+8)
+            d2 = dx*dx + dy2
+            walllist.append((d2, x, y))
+    walllist.sort()
+
+    # dynamically replace the current level's walls with the new level's
+    dist = 0
+    speedf = 15.0
+    added = 0
+    for d2, x, y in walllist:
+        while d2 > dist*dist:
+            if added:
+                curboard.reorder_walls()
+                added = 0
+            yield 0
+            dist += 4.1
+            speedf *= 0.99
+        if curboard.walls[y][x] == ' ':
+            if lvl.walls[y][x] == ' ':
+                continue
+            else:
+                curboard.putwall(x, y)
+                added = 1
+                big = 1
+        else:
+            if lvl.walls[y][x] == ' ':
+                curboard.killwall(x, y)
+                big = 1
+            else:
+                big = 0
+        sx = x*16
+        sy = y*16
+        DustStar(sx - 8*big,
+                 sy - 8*big,
+                 speedf * (sx-cx) / dist,
+                 speedf * (sy-cy) / dist,
+                 big=big)
+    # patch the winds too
+    curboard.winds = lvl.winds
+    curboard.reorder_walls()
+    yield 0
+    # wait a bit and restart
+    if repeat_delay < 1000:
+        for i in range(repeat_delay):
+            yield 0
+            if curboard.cleaning_gen_state:
+                return
+        extra_boardgen(extra_make_random_level(
+            repeat_delay = repeat_delay * 3 // 2))
+
+def extra_bubbles(timeout):
+    from bubbles import newforcedbubble
+    falloff = 0.25
+    L = math.log(0.965)     # same speed falloff rate as in throwing_bubble()
+    cx = (bwidth - CELL) // 2
+    cy = (bheight - CELL) // 2
+    for i in range(timeout):
+        if curboard.cleaning_gen_state:
+            return
+        if random.random() < falloff:
+            bubble = newforcedbubble()
+            if bubble:
+                tx = random.randrange(CELL, bwidth - 2*CELL) - cx
+                ty = random.randrange(CELL, bheight - 2*CELL) - cy
+                if ty == 0:
+                    ty = 1
+                dist = math.sqrt(tx * tx + ty * ty)
+                acos = tx / dist
+                asin = ty / dist
+                hspeed = 4 - dist * L
+                bubble.thrown_bubble(cx, cy, hspeed, (acos, asin))
+        falloff *= 0.998
+        yield 0
+
+
+def initsubgame(music, displaypoints):
+    from player import BubPlayer, scoreboard
+    for t in exit_board(0, repeatmusic=[music]):
+        yield t
+    BubPlayer.DisplayPoints = displaypoints
+    scoreboard()
+    for t in curboard.clean_gen_state():
+        yield t
+
+def register(dict):
+    global width, height, bwidth, bheight, bheightmod
+    items = dict.items()
+    items.sort()
+    for name, board in items:
+        try:
+            if not issubclass(board, Board) or board is Board:
+                continue
+        except TypeError:
+            continue
+        BoardList.append(board)
+    # check sizes
+    assert BoardList, "board file does not define any board"
+    B = BoardList[0]
+    try:
+        test = B(-1)
+        width = test.width
+        height = test.height
+        for B in BoardList[1:]:
+            test = B(-1)
+            assert test.width == width, "some boards have a different width"
+            assert test.height == height, "some boards have a different height"
+    except Exception, e:
+        print 'Caught "%s" in level "%s":' % (e, B.__name__)
+        raise e
+    bwidth = width*CELL
+    bheight = height*CELL
+    bheightmod = (height+2)*CELL
+
+##def define_boards(filename):
+##    global curboard, boards, width, height, bwidth, bheight, bheightmod
+##    curboard = None
+##    boards = []
+##    def board((wallfile, wallrect), shape):
+##        lines = shape.strip().split('\n')
+##        bmp = gamesrv.getbitmap(wallfile)
+##        wallicon = bmp.geticon(*wallrect)
+##        boards.append(Board(lines, wallicon))
+##    d = {'board': board}
+##    execfile(filename, d)
+##    assert boards, "board file does not define any board"
+##    width = boards[0].width
+##    height = boards[0].height
+##    for b in boards[1:]:
+##        assert b.width == width, "some boards have a different width"
+##        assert b.height == height, "some boards have a different height"
+##    bwidth = width*CELL
+##    bheight = height*CELL
+##    bheightmod = len(boards[0].lines)*CELL
+
+
+#try:
+#    import psyco
+#except ImportError:
+#    pass
+#else:
+#    psyco.bind(normal_frame)