initial commit from cvs 1.6.2

1 files changed, 1284 insertions, 0 deletions

diff --git a/bubbob/bubbles.py b/bubbob/bubbles.py
new file mode 100644
index 0000000..9734826
--- /dev/null
+++ b/bubbob/bubbles.py
@@ -0,0 +1,1284 @@
+from __future__ import generators
+import random, math
+import gamesrv
+import images
+import boards
+from boards import *
+from images import ActiveSprite
+from mnstrmap import GreenAndBlue, LetterBubbles, Stars
+from mnstrmap import Lightning, Water, Fire, SpinningBalls, PlayerBubbles
+
+
+bubble_wind = {
+    '<': (-1, 0),
+    '>': (+1, 0),
+    '^': ( 0,-1),
+    'v': ( 0,+1),
+    'x': ( 0, 0),
+    }
+
+
+class Bubble(ActiveSprite):
+    exploding_bubbles = range(131,136)
+    red_bubbles       = [156, 157, 156, 155]
+    white_bubbles     = [164, 165, 164, 163]
+    pink_bubbles      = [172, 173, 172, 171]
+    check_onbubble    = ([(0,-1)], [(0,1)])
+
+    touchable = 1
+    warp = 0
+    default_windless = None
+    catch_dragons = None
+    nimages = GreenAndBlue.normal_bubbles
+
+    def touched(self, dragon):
+        dx, dy = dragon.x, dragon.y
+        o = []
+        if abs(self.x - dx) >= 25:
+            if self.x < dx:
+                o.append((1,0))
+            else:
+                o.append((-1,0))
+        if abs(self.y - dy) >= 25:
+            if self.y < dy:
+                o.append((0,1))
+            else:
+                o.append((0,-1))
+        if o:
+            self.obstacle = o
+        elif (self.catch_dragons and
+              abs(self.x - dx) < 15 and abs(self.y - dy) < 15):
+            if dragon not in self.catch_dragons:
+                self.catch_dragons.append(dragon)
+##        elif not self.pop(getattr(dragon, 'poplist', None)):
+##            if self.x < dx:
+##                o.append((1,0))
+##            else:
+##                o.append((-1,0))
+##            if self.y < dy:
+##                o.append((0,1))
+##            else:
+##                o.append((0,-1))
+##            self.obstacle = o
+        else:
+            self.pop(getattr(dragon, 'poplist', None))
+        return o == self.check_onbubble[dragon.bottom_up()]
+
+    def can_catch_dragons(self, author, catch_myself=0):
+        self.catch_dragons = [author]
+        if catch_myself:
+            self.catch_dragons.append(author)
+            self.move(author.x, author.y)
+        self.gen.append(self.catching_dragons())
+
+    def catching_dragons(self):
+        from player import Dragon
+        yield None   # time to catch several dragons
+        dragons = [d for d in self.catch_dragons if isinstance(d, Dragon)]
+        self.catch_dragons = None
+        if len(dragons) >= 2:
+            import bonuses
+            author = dragons.pop(0)
+            imglist = [self.nimages[d.dcap.get('bubbericons', 
+                                               d.bubber).pn][i]
+                       for d in dragons for i in [1,2,1,0]]
+            self.setimages(self.cyclic(imglist))
+            self.warp = 1
+            caught = [(bonus.points, bonus) for d in dragons
+                      if d.bubber is not author.bubber
+                      for bonus in d.listcarrybonuses()
+                      if isinstance(bonus, CatchNote)]
+            caught.sort()
+            # count caught dragons, excluding team mates, but including self
+            count = 0
+            for d in dragons:
+                if (d.bubber is author.bubber or
+                    not d.bubber.sameteam(author.bubber)):
+                    count += 1
+            if count:
+                if count == 1:
+                    points = 250
+                else:
+                    self.play(images.Snd.Extra)
+                    if count == 2:
+                        points = 10000
+                    elif count == 3:
+                        points = 30000
+                    else:
+                        points = 70000
+                caught.append((points, CatchNote(points)))
+            caught = caught[-3:]
+            for points, bonus in caught:
+                author.carrybonus(bonus, 111)
+                bonuses.points(self.x, self.y-HALFCELL, author, points)
+            for d in dragons:
+                d.become_bubblingeyes(self)
+                s_catch = author.bubber.stats.setdefault('catch', {})
+                s_catch[d.bubber] = s_catch.get(d.bubber, 0) + 1
+
+    def pop(self, poplist=None):
+        if self.touchable:
+            self.play(images.Snd.Pop)
+            self.poplist = poplist
+            self.untouchable()
+            self.gen = [self.die(Bubble.exploding_bubbles)]
+            if poplist:
+                dragon = poplist[0]
+                points = self.popped(dragon)
+                if dragon:
+                    dragon.bubber.givepoints(points)
+                    dragon.bubber.stats['bubble'] += 1
+                self.gen.append(self.poprec())
+            return 1
+        else:
+            return 0
+
+    def popped(self, dragon):
+        return 10
+
+    def poprec(self):
+        yield None
+        for s in self.touching(0):
+            if isinstance(s, Bubble):
+                s.pop(self.poplist)
+
+    def normal_movements(self, dx=0, dy=-1, timeout=800):
+        self.obstacle = []
+        time = 0
+        touchbubble = timeout = (timeout or 0) * 2
+        while 1:
+            del self.obstacle[:]
+            yield None
+            timeout -= 2
+            if not timeout:
+                self.setimages(self.bubble_red())
+            if timeout > touchbubble:
+                continue
+            if timeout&2:
+                for s in self.touching(13+(timeout&6)):
+                    if isinstance(s, Bubble) and s is not self:
+                        if (s.x-self.x)*dx > 0 or (s.y-self.y)*dy > 0:
+                            touchbubble = timeout - (timeout&12) - 3
+                            break
+                if timeout > touchbubble:
+                    continue
+            if (dx,dy) not in self.obstacle:
+                if dx==dy==0:
+                    if len(self.obstacle)==1:
+                        dx1, dy1 = self.obstacle[0]
+                        self.step(-dx1, -dy1)
+                else:
+                    self.step(dx, dy)
+                if self.y < -32 or self.y >= boards.bheight:
+                    if not self.warp:
+                        self.poplist = None
+                        self.kill()
+                        return
+                    self.vertical_warp()
+##                        dx = -dx
+                w = wget(self.x, self.y)
+                if w != ' ':
+                    dx, dy = bubble_wind[w]
+                elif self.default_windless:
+                    dx, dy = self.default_windless
+            
+                if dx == dy == 0:
+                    # this is the same as the whole loop but runs faster
+                    while len(self.obstacle) != 1:
+                        del self.obstacle[:]
+                        yield None
+                        timeout -= 2
+                        if not timeout:
+                            self.setimages(self.bubble_red())
+
+    def bubble_red(self, speed=5):
+        for n in self.imgseq(Bubble.white_bubbles, repeat=3):
+            yield n
+        for n in self.imgseq(Bubble.pink_bubbles, repeat=4):
+            yield n
+        for n in self.imgseq(Bubble.red_bubbles, repeat=4):
+            yield n
+        for n in self.imgseq([Bubble.pink_bubbles[0], Bubble.red_bubbles[0]],
+                             speed=2, repeat=10):
+            yield n
+        self.pop()
+
+    def startnormalbubble(self, dx=0, dy=-1, timeout=800):
+        self.touchable = 1
+        self.gen.append(self.normal_movements(dx=dx, dy=dy, timeout=timeout))
+        imglist = GreenAndBlue.normal_bubbles[self.d.bubber.pn]
+        self.setimages(self.cyclic([imglist[1],
+                                    imglist[2],
+                                    imglist[1],
+                                    imglist[0]]))
+
+    def startsnookerbubble(self, timeout, hspeed, monsterpoplist=None):
+        self.gen.append(self.snooker_movements(dir=hspeed, timeout=timeout))
+        self.gen.append(self.kill_touching_monsters(monsterpoplist))
+        colorname = random.choice(Stars.COLORS)
+        imglist = [('smstar', colorname, k) for k in range(2)]
+        self.to_front()
+        s = images.ActiveSprite(images.sprget(imglist[-1]), self.x, self.y)
+        s.setimages(s.cyclic(imglist, speed=2))
+        s.gen.append(s.following(self))
+        def to_front():
+            Bubble.to_front(self)
+            s.to_front()
+        self.to_front = to_front
+
+    def snooker_movements(self, dir, dy=0.3, timeout=500):
+        icons = [images.sprget(n)
+                 for n in GreenAndBlue.normal_bubbles[self.d.bubber.pn]]
+        icotimeout = 0
+        ico = icons[1]
+        yfrac = 0.0
+        self.dragon_jumped = False
+        for i in xrange(timeout):
+            hspeed = random.randrange(2, 4)
+            if ico is not icons[1]:
+                icotimeout += 1
+                if icotimeout >= 16:
+                    ico = icons[1]
+                    icotimeout = 0
+            elif abs(dy) > 16:
+                if dy > 0:
+                    dy = 16.0
+                else:
+                    dy = -16.0
+            self.touchable = 1
+            if self.dragon_jumped:
+                self.untouchable()
+                if self.dragon_jumped[1]:   # bottom-up dragon
+                    dy = -abs(dy)
+                else:
+                    dy = abs(dy)
+            self.dragon_jumped = False
+            stepx = 0
+            y1 = (self.y + 27) // CELL
+            if dir < 0:
+                x1 = (self.x + 5) // CELL
+                if bget(x1, y1) == ' ' == bget(x1, y1-1):
+                    stepx = -hspeed
+                else:
+                    ico = icons[0]
+                    dir = 1
+            else:
+                x1 = (self.x + 26) // CELL
+                if bget(x1, y1) == ' ' == bget(x1, y1-1):
+                    stepx = hspeed
+                else:
+                    ico = icons[0]
+                    dir = -1
+            x = self.x
+            deltay = yfrac
+            if x < 32:
+                x += hspeed
+                dir = 1
+            elif x > boards.bwidth - 64:
+                x -= hspeed
+                dir = -1
+            else:
+                x += stepx
+                dy += 0.21
+                deltay = yfrac + dy
+            y = self.y
+            while deltay >= 1.0:
+                deltay -= 1.0
+                if onground(x, y-4):
+                    ico = icons[2]
+                    deltay = -deltay
+                    dy = -abs(dy)
+                else:
+                    y += 1
+            while deltay < 0.0:
+                deltay += 1.0
+                if underground(x, y+4):
+                    ico = icons[2]
+                    dy = abs(dy) * 0.95
+                    break
+                y -= 1
+            self.move(x, y, ico)
+            self.vertical_warp()
+            yfrac = deltay
+            yield None
+        self.pop()
+
+    def kill_touching_monsters(self, poplist=None):
+        from monsters import Monster
+        poplist = poplist or [self.d]
+        while 1:
+            yield None
+            for s in self.touching(10):
+                if isinstance(s, Monster):
+                    s.argh(poplist)
+            yield None
+
+
+class NormalBubble(Bubble):
+    warp = 1
+
+    def __init__(self, dragon, x, y, timeout=800):
+        imglist1 = GreenAndBlue.new_bubbles[dragon.bubber.pn]
+        Bubble.__init__(self, images.sprget(imglist1[0]), x, y)
+        self.d = dragon
+        self.startnormalbubble(timeout=timeout)
+
+class SnookerBubble(Bubble):
+    warp = 1
+    touchable = 0
+
+    def __init__(self, dragon, x, y, timeout=500):
+        imglist1 = GreenAndBlue.new_bubbles[dragon.bubber.pn]
+        Bubble.__init__(self, images.sprget(imglist1[0]), x, y)
+        self.d = dragon
+        self.startsnookerbubble(timeout=timeout, hspeed=dragon.dir)
+
+
+class BigBubbleCatcher(ActiveSprite):
+    numlist = [(PlayerBubbles.explosion[2], 1),
+               (PlayerBubbles.explosion[1], 2),
+               (PlayerBubbles.explosion[0], 2),
+               (PlayerBubbles.bubble[1],    5),
+               (PlayerBubbles.appearing[4], 3),
+               (PlayerBubbles.appearing[3], 3),
+               (PlayerBubbles.appearing[2], 2),
+               (PlayerBubbles.appearing[1], 2),
+               (PlayerBubbles.appearing[0], 2)]
+
+    def __init__(self, dragon, target, timeout):
+        img = images.sprget(PlayerBubbles.explosion[2])
+        ActiveSprite.__init__(self, img, -img.w, 0)
+        self.dragon = dragon
+        self.target = target
+        self.timeout = timeout
+        self.gen.append(self.follow())
+        self.recenter(PlayerBubbles.explosion[2])
+        for imgnum, delay in self.numlist:
+            images.sprget(imgnum)     # preload
+
+    def recenter(self, imgnum):
+        s = self.target
+        if not s.alive or not s.touchable:
+            self.kill()
+        else:
+            img = images.sprget(imgnum)
+            self.move(s.x + (s.ico.w - img.w) // 2,
+                      s.y + (s.ico.h - img.h) // 2,
+                      img)
+
+    def follow(self):
+        for imgnum, delay in self.numlist:
+            for t in range(delay):
+                self.recenter(imgnum)
+                yield None
+        self.recenter(imgnum)
+        if self.alive:
+            s = self.target
+            s.in_bubble(NormalBubble(self.dragon, s.x, s.y, self.timeout))
+            self.kill()
+
+
+class CatchNote:
+    def __init__(self, points):
+        self.points = points
+    def endaction(self, dragon):
+        pass
+
+
+class DragonBubble(Bubble):
+    touchable = 0
+
+    def __init__(self, d, x, y, dir, special_bubble=None, angle=0,
+                 thrustfactor=None, shootthrust=None):
+        self.d = d
+        pn = d.bubber.pn
+        imglist1 = GreenAndBlue.new_bubbles[pn]
+        imglist2 = GreenAndBlue.normal_bubbles[pn]
+        if angle:
+            asin, acos = math.sin(angle), math.cos(angle)
+        else:
+            asin, acos = 0, 1
+        Bubble.__init__(self, images.sprget(imglist1[0]), x + 12*dir, y)
+        self.setimages(self.imgseq(imglist1[1:] + imglist2[2:3], 4))
+        if shootthrust is None:
+            shootthrust = d.dcap['shootthrust']
+        hspeed = dir * shootthrust
+        if thrustfactor is not None:
+            negative = hspeed < 0
+            hspeed = (abs(hspeed) - 4.0) * thrustfactor + 4.0
+            if negative:
+                hspeed = -hspeed
+        self.gen.append(self.throw_bubble(hspeed, special_bubble, (acos,asin)))
+
+    def throw_bubble(self, hspeed, special_bubble=None, (acos,asin)=(1,0)):
+        from monsters import Monster
+        nx = self.x
+        ny = self.y
+        stop = 0
+        withmonster = 0
+        specialangle = (acos,asin) != (1,0)
+        if special_bubble == 'BigFireBubble':
+            if not specialangle:
+                BigFireBubble(self.x, self.y, hspeed, self.d)
+            self.kill()
+            return
+
+        self.warp = 0
+        monsterpoplist = [self.d]
+        while abs(hspeed) >= 4.0:
+            touched_monsters = [s for s in self.touching(9)
+                                if isinstance(s, Monster)]
+            if touched_monsters:
+                if special_bubble == 'SnookerBubble':
+                    for monster in touched_monsters:
+                        monster.argh(monsterpoplist)
+                else:
+                    monster = random.choice(touched_monsters)
+                    in_bubble = monster.in_bubble(self)
+                    withmonster = self.withmonster = 1
+                    if in_bubble is None:
+                        self.warp = 1
+                        try:
+                            key = monster.mdef.jailed[0]
+                        except AttributeError:
+                            pass
+                        else:
+                            s_monster = self.d.bubber.stats.setdefault(
+                                'monster', {})
+                            s_monster[key] = s_monster.get(key, 0) + 1
+                        break
+            if specialangle:
+                nx, ny = vertical_warp(nx + hspeed*acos, ny + hspeed*asin)
+##                if moebius:
+##                    acos = -acos
+            else:
+                nx += hspeed
+            hspeed *= 0.965
+            xc = int(nx-3.8)//CELL+1
+            yc = (self.y+HALFCELL)//CELL
+            if bget(xc,yc) == '#' == bget(xc, yc+1):
+                stop += 1
+            if stop <= 1:
+                self.move(int(nx+0.5), int(ny+0.5))
+            yield None
+
+        if special_bubble == 'SnookerBubble':
+            if stop > 1:
+                hspeed = -hspeed
+            self.startsnookerbubble(self.d.dcap['bubbledelay'] or 800,
+                                    hspeed, monsterpoplist)
+            return
+        if not withmonster:
+            from bonuses import Bonus, BonusMaker
+            touched_bonuses = [s for s in self.touching(15)
+                               if isinstance(s, Bonus) and s.bubblable]
+            if touched_bonuses:
+                random.choice(touched_bonuses).in_bubble(self)
+                withmonster = 1
+            else:
+                touched_bonuses = [s for s in self.touching(7)
+                                   if isinstance(s, BonusMaker)]
+                if touched_bonuses:
+                    bonusmaker = random.choice(touched_bonuses)
+                    if bonusmaker.in_bubble(self):
+                        withmonster = 1
+        if not self.alive:
+            return
+        if special_bubble:
+            cls = globals()[special_bubble]
+            if not withmonster:
+                b = cls(self.d.bubber.pn)
+                b.move(self.x, self.y)
+                b.can_catch_dragons(self.d, hspeed == 0)
+                self.kill()
+                return
+        bubbledelay = self.d.dcap['bubbledelay']
+        if bubbledelay:
+            timeout = 1
+            if bubbledelay > 1:
+                self.gen.append(self.delayed_pop(7))
+        else:
+            timeout = 800
+        self.startnormalbubble(timeout=timeout)
+        if not withmonster:
+            self.can_catch_dragons(self.d, hspeed == 0)
+
+    def delayed_pop(self, delay):
+        for i in range(delay):
+            yield None
+        self.pop()
+
+
+class FishBubble(Bubble):
+    touchable = 0
+
+    def __init__(self, dragon):
+        ico = images.sprget(GreenAndBlue.new_bubbles[dragon.bubber.pn][0])
+        Bubble.__init__(self, ico, dragon.x + dragon.dir*12, dragon.y)
+        timeout = random.randrange(50, 150)
+        self.gen.append(self.normal_movements(timeout=timeout))
+        self.gen.append(self.fuzz())
+
+    def fuzz(self):
+        while 1:
+            prevx = self.x
+            yield None
+            yield None
+            yield None
+            if prevx == self.x:
+                self.step(random.choice([-1, 1]), 0)
+
+    def bubble_red(self, *args, **kwds):
+        self.gen.append(self.die([]))
+
+
+class BubblingEyes(ActiveSprite):
+    
+    def __init__(self, bubber, saved_caps, bubble):
+        ico = images.sprget(('eyes', 0, 0))
+        ActiveSprite.__init__(self, ico, bubble.x, bubble.y)
+        self.bubber = bubber
+        self.dcap = saved_caps
+        self.gen = [self.playing_bubble(bubble)]
+
+    def bottom_up(self):
+        return self.dcap['gravity'] < 0.0
+
+    def playing_bubble(self, bubble):
+        from player import Dragon
+        bottom_up = self.bottom_up()
+        flip = 'vflip'*bottom_up
+        timer = 0
+        red = 0
+        normalbub = bubble.imgsetter
+        redblinker = bubble.cyclic([Bubble.pink_bubbles[0], Bubble.red_bubbles[0]], 2)
+        bubber = self.bubber
+        ndir = random.choice([-1, 1])
+        prev_dx_dy = None
+        while not hasattr(bubble, 'poplist'):
+            dx = bubber.wannago(self.dcap)
+            if dx:
+                ndir = dx
+            if bubber.key_jump:
+                dy = -1
+            else:
+                dy = 0
+            if bubber.key_fire:
+                red += 1
+                if red > 20:
+                    d = Dragon(bubber, self.x, self.y, ndir, self.dcap)
+                    Bubble.pop(bubble, [d])  # hack to pop SolidBubbles too
+                    d.kill()
+                    break
+                if bubble.imgsetter is not redblinker:
+                    normalbub = bubble.imgsetter
+                    bubble.setimages(redblinker)
+            else:
+                #red = 0
+                if bubble.imgsetter is redblinker:
+                    bubble.setimages(normalbub)
+            key = ('eyes', dx, dy)
+            if timer < 50:
+                if (timer % 9) < 3:
+                    key = 'eyes-blink'
+            elif random.random() < 0.1:
+                key = 'eyes-blink'
+            timer += 1
+            if bubble.x <= 3*HALFCELL and dx < 0:
+                dx = 0
+            if bubble.x >= boards.bwidth - 7*HALFCELL and dx > 0:
+                dx = 0
+            if bottom_up:
+                dy = -dy
+            nx = bubble.x + dx
+            ny = bubble.y + dy
+            if timer&1:
+                nx += dx
+            else:
+                ny += dy
+            nx, ny = vertical_warp(nx, ny)
+            bubble.move(nx, ny)
+            self.move(nx+dx, ny+dy, images.sprget((flip, key)))
+##            if moebius:
+##                self.dcap['left2right'] *= -1
+            if dx == dy == 0:
+                bubble.default_windless = prev_dx_dy
+            else:
+                prev_dx_dy = dx, dy
+                bubble.default_windless = 0, 0
+            yield None
+        # jumping out of the bubble
+        if bottom_up:
+            kw = {'gravity': -0.3}
+        else:
+            kw = {}
+        from player import BubPlayer
+        bi = self.dcap.get('bubbericons', bubber)
+        if BubPlayer.SuperFish and 'fish' in bi.transformedicons:
+            self.setimages(None)
+            self.seticon(bi.transformedicons['fish'][0, +1])
+        else:
+            self.setimages(self.cyclic(
+                [(flip, n) for n in GreenAndBlue.comming[bi.pn]], 2))
+        dxy = [(random.random()-0.5) * 9.0,
+               (random.random()+0.5) * (-5.0,5.0)[bottom_up]]
+        for n in self.parabolic(dxy, 1, **kw):
+            yield n
+            if dxy[1] * (1,-1)[bottom_up] >= 4.0:
+                break
+        if dxy[0] < 0:
+            ndir = -1
+        else:
+            ndir = 1
+        d = Dragon(bubber, self.x, self.y, ndir, self.dcap)
+        d.dcap['shield'] = 50
+        bubber.dragons.append(d)
+        self.kill()
+
+    def kill(self):
+        try:
+            self.bubber.dragons.remove(self)
+        except ValueError:
+            pass
+        ActiveSprite.kill(self)
+
+
+class BonusBubble(Bubble):
+    max = None
+    timeout = None
+    flip = ''
+
+    def __init__(self, pn, nimages=None, top=None):
+        if nimages is None:
+            nimages = self.nimages[pn]
+        b = boards.curboard
+        if top is None:
+            top = b.top
+        if top == 0:
+            testline = b.walls[-1]
+            x, y = self.findhole(testline), boards.bheight
+            dx, dy = 0, -1
+        elif top == 1:
+            testline = b.walls[0]
+            x, y = self.findhole(testline), -2*CELL
+            dx, dy = 0, 1
+        elif top == 2:
+            x, y = -2*CELL, random.randint(2*CELL, boards.bheight-4*CELL)
+            dx, dy = 1, 0
+        else:  # top == 3:
+            x, y = (boards.bwidth - CELL,
+                    random.randint(2*CELL, boards.bheight-4*CELL))
+            dx, dy = -1, 0
+        Bubble.__init__(self, images.sprget((self.flip, nimages[0])), x, y)
+        self.gen.append(self.normal_movements(dx=dx, dy=dy,
+                                              timeout=self.timeout))
+        if len(nimages) == 3:
+            nimages = [nimages[1], nimages[2], nimages[1], nimages[0]]
+        if len(nimages) > 1:
+            self.setimages(self.cyclic([(self.flip, n) for n in nimages]))
+
+    def findhole(self, testline):
+        holes = [x for x in range(len(testline)-1) if testline[x:x+2]=='  ']
+        if not holes:
+            holes = range(2, len(testline)-3)
+        return random.choice(holes) * CELL
+
+    def thrown_bubble(self, x, y, hspeed, acossin):
+        self.untouchable()
+        self.move(x, y)
+        self.gen = [self.throwing_bubble(hspeed, acossin, self.imgsetter)]
+
+    def throwing_bubble(self, hspeed, (acos,asin), restore_img):
+        nx = self.x
+        ny = self.y
+        while abs(hspeed) >= 4.0:
+            nx, ny = vertical_warp(nx + hspeed*acos, ny + hspeed*asin)
+##            if moebius:
+##                acos = -acos
+            if nx <= CELL:
+                acos = abs(acos)
+            if nx >= boards.bwidth-3*CELL:
+                acos = -abs(acos)
+            hspeed *= 0.965
+            self.move(int(nx+0.5), int(ny+0.5))
+            yield None
+        self.touchable = 1
+        self.gen.append(self.normal_movements(timeout=self.timeout))
+        self.setimages(restore_img)
+
+
+class PlainBubble(BonusBubble):
+    timeout = 500
+    def condition():
+        return boards.curboard.holes
+
+def extend_name(l):
+    text = 'extend'
+    return text[:l] + text[l].upper() + text[l+1:]
+
+class LetterBubble(BonusBubble):
+    max = 2
+    def condition():
+        return boards.curboard.letter
+    def __init__(self, pn, l=None):
+        if l is None:
+            l = random.randint(0,5)
+        self.l = l
+        lettername = extend_name(self.l)
+        BonusBubble.__init__(self, pn, nimages=getattr(LetterBubbles, lettername))
+    def popped(self, dragon):
+        if dragon:
+            dragon.bubber.giveletter(self.l)
+        return 50
+
+class FireFlame(ActiveSprite):
+    timeout = 17
+    def __init__(self, x0, y0, poplist, dirs=None, countdown=0, flip=''):
+        ico = images.sprget((flip, Fire.ground[0]))
+        ActiveSprite.__init__(self, ico, x0*CELL, y0*CELL)
+        if not countdown:
+            dirs = []
+        self.poplist = poplist
+        self.gen.append(self.burning(dirs, countdown))
+        self.setimages(self.cyclic([(flip, n) for n in Fire.ground], 1))
+    def burning(self, dirs, countdown):
+        from monsters import Monster
+        x0 = self.x//CELL
+        y0 = self.y//CELL
+        for dir in dirs:
+            if bget(x0+dir, y0+1) == '#' and bget(x0+dir, y0) == ' ':
+                FireFlame(x0+dir, y0, self.poplist, [dir], countdown-1)
+        for i in range(self.timeout):
+            yield None
+            if self.poplist:
+                for s in self.touching(0):
+                    if isinstance(s, Monster):
+                        s.argh(self.poplist)
+            yield None
+        self.kill()
+
+class FireDrop(ActiveSprite):
+    def __init__(self, x, y, poplist=None):
+        ActiveSprite.__init__(self, images.sprget(Fire.drop), x, y)
+        self.poplist = poplist or [None]
+        self.gen.append(self.dropping())
+    def dropping(self):
+        x0 = self.x//CELL
+        while bget(x0, self.y//CELL) == '#' or bget(x0, self.y//CELL+1) != '#':
+            if self.y >= boards.bheight:
+                self.kill()
+                return
+            self.move(self.x, (self.y + 8) & ~7)
+            yield None
+        y0 = self.y//CELL
+        #if bget(x0-1, y0) == ' ':
+        FireFlame(x0, y0, self.poplist, [-1, 1], 5)
+        self.kill()
+
+class FireBubble(BonusBubble):
+    max = 4
+    nimages = GreenAndBlue.fire_bubbles
+    def condition():
+        return boards.curboard.fire
+    def popped(self, dragon):
+        if dragon:
+            x0 = self.x // CELL + 1
+            y0 = self.y // CELL + 1
+            if bget(x0, y0) == '#':
+                x1 = (self.x + HALFCELL) // CELL
+                if x1 == x0:
+                    tries = [x1+1, x1-1]
+                else:
+                    tries = [x1, x1+2]
+                for x1 in tries:
+                    if bget(x1, y0) == ' ':
+                        x0 = x1
+                        break
+            FireDrop(x0*CELL, self.y)
+        return 10
+
+##class BombBubble(FireBubble):
+##    flip = 'vflip'
+##    def popped(self, dragon):
+##        if dragon:
+##            import bonuses
+##            bonuses.bomb_explosion(self.x, self.y + CELL, starmul=1)
+##        return 100
+
+##class WaterCell(ActiveSprite):
+##    ICONS = {
+##        ( 0,1, None) : Water.bottom,
+##        ( 1,0, None) : Water.start_left,
+##        (-1,0, None) : Water.start_right,
+##        ( 0,0, None) : Water.bottom,
+        
+##        (0,1,   0,1) : Water.v_flow,
+##        (0,1,   1,0) : Water.bl_corner,
+##        (0,1,  -1,0) : Water.br_corner,
+
+##        (-1,0,  0,1) : Water.tl_corner,
+##        (-1,0,  1,0) : Water.start_right,
+##       #(-1,0, -1,0) : Water.h_flow,
+
+##        (1,0,   0,1) : Water.tr_corner,
+##       #(1,0,   1,0) : Water.h_flow,
+##        (1,0,  -1,0) : Water.start_left,
+
+##        (0,0,   0,1) : Water.top,
+##        (0,0,   1,0) : Water.top,
+##        (0,0,  -1,0) : Water.top,
+
+##        (None,  0,1) : Water.top,
+##        (None, -1,0) : Water.start_left,
+##        (None,  1,0) : Water.start_right,
+##        (None,  0,0) : Water.top,
+##        }
+    
+##    def __init__(self, x, y):
+##        ActiveSprite.__init__(self, images.sprget(Water.top), x, y)
+##        self.touchable = 1
+        
+##    def ready(self, celllist):
+##        self.gen.append(self.flooding(celllist))
+
+##    def flooding(self, celllist):
+##        from monsters import Monster
+##        x0 = self.x // 16
+##        y0 = self.y // 16
+##        ping = 0
+##        dir = random.choice([-1, 1])
+##        take_with_us = [[] for cell in celllist]
+##        poplist = [None]
+##        icons = {}
+##        for key, value in self.ICONS.items():
+##            icons[key] = images.sprget(value)
+##        icodef = images.sprget(Water.h_flow)
+##        stop = 0
+##        while not stop:
+##            dx = dy = 0
+##            if bget(x0, y0+1) == ' ':
+##                dy = y0*16 < boards.bheight
+##                ping = 0
+##            elif bget(x0+dir, y0) == ' ':
+##                dx = dir
+##            elif bget(x0-dir, y0) == ' ':
+##                ping += 1
+##                if ping < 3:
+##                    dir = -dir
+##                    dx = dir
+##            # change the head icon
+##            head = celllist[0]
+##            second = celllist[1]
+##            head.seticon(icons.get((x0-second.x//16, y0-second.y//16,
+##                                    dx, dy), icodef))
+##            # move the tail to the new head position
+##            x0 += dx
+##            y0 += dy
+##            newhead = celllist.pop()
+##            celllist.insert(0, newhead)
+##            newhead.move(x0*16, y0*16, icons.get((dx,dy, None), icodef))
+##            # change the new tail icon
+##            tail = celllist[-1]
+##            second = celllist[-2]
+##            tail.seticon(icons.get((None, (second.x-tail.x)//16,
+##                                          (second.y-tail.y)//16), icodef))
+##            # take monsters with us
+##            for i in range(0, len(celllist), 3):
+##                for s in celllist[i].touching(0):
+##                    if isinstance(s, Monster):
+##                        s.untouchable()
+##                        s.gen = []
+##                        take_with_us[i].append(s)
+##                    elif isinstance(s, Bubble):
+##                        s.pop(poplist)
+##            yield 0
+##            stop = dx == dy == 0
+##            for cell, takelist in zip(celllist, take_with_us):
+##                stop &= cell.x == newhead.x and cell.y == newhead.y
+##                for s in takelist:
+##                    if s.alive:
+##                        s.move(x2bounds(cell.x-8), cell.y-16)
+##                        if stop:
+##                            s.argh(poplist, onplace=1)
+##        for c in celllist:
+##            c.kill()
+##    def touched(self, dragon):
+##        dragon.watermove(x2bounds(self.x-HALFCELL), self.y-CELL+1)
+##        return 1
+
+class WaterCell(ActiveSprite):
+    TESTLIST = [(-CELL,0), (CELL,0), (0,CELL), (0,-CELL)]
+    ICONS = [Water.v_flow,
+             Water.start_left,
+             Water.start_right,
+             Water.h_flow,
+             Water.top,
+             Water.tr_corner,
+             Water.tl_corner,
+             Water.h_flow,
+             
+             Water.bottom,
+             Water.br_corner,
+             Water.bl_corner,
+             Water.h_flow,
+             Water.v_flow,
+             Water.v_flow,
+             Water.v_flow,
+             Water.v_flow]
+    
+    def __init__(self, x, y, dir, watercells, poplist, repeat):
+        ActiveSprite.__init__(self, images.sprget(Water.top), x, y)
+        self.poplist = poplist
+        self.take_with_me = []
+        self.ping = 0
+        self.repeat = repeat
+        self.watercells = watercells
+        self.touchable = repeat % 3 == 1
+        if (x, y, dir) not in watercells:
+            watercells[x,y,dir] = self
+            if None not in watercells or not watercells[None].alive:
+                self.in_charge()
+        else:
+            watercells[x,y,dir].join(self)
+
+    def join(self, other):
+        self.take_with_me += other.take_with_me
+        self.ping = min(self.ping, other.ping)
+        self.repeat += other.repeat
+        self.touchable = self.touchable or other.touchable
+        del other.take_with_me[:]
+        other.kill()
+
+    def in_charge(self):
+        self.gen = [self.flooding()]
+        self.watercells[None] = self
+
+    def kill(self):
+        from monsters import Monster
+        for s in self.take_with_me[:]:
+            if isinstance(s, Monster) and s.alive:
+                s.argh(self.poplist, onplace=1)
+        del self.take_with_me[:]
+        ActiveSprite.kill(self)
+        if not self.watercells[None].alive:
+            del self.watercells[None]
+            for s in self.watercells.values():
+                if s.alive:
+                    s.in_charge()
+                    break
+
+    def flooding(self):
+        from monsters import Monster
+        watercells = self.watercells
+        while watercells[None] is self:
+
+            new = []
+            nwatercells = {None: self}
+            for key, s in watercells.items():
+                if key:
+                    x, y, dir = key
+                    if s.repeat:
+                        new.append((x, y, dir, watercells,
+                                    s.poplist, s.repeat-1))
+                        s.repeat = 0
+                    x0 = x // CELL
+                    y0 = y // CELL
+                    if bget(x0, y0+1) == ' ':
+                        if y >= boards.bheight:
+                            s.kill()
+                            continue
+                        s.ping = 0
+                        y += CELL
+                    elif bget(x0+dir, y0) == ' ':
+                        x += dir*CELL
+                    elif bget(x0-dir, y0) == ' ':
+                        s.ping += 1
+                        if s.ping == 3:
+                            s.kill()
+                            continue
+                        dir = -dir
+                        x += dir*CELL
+                    else:
+                        s.kill()
+                        continue
+                    key = x, y, dir
+                    if key in nwatercells:
+                        nwatercells[key].join(s)
+                    else:
+                        nwatercells[key] = s
+            
+            watercells.clear()
+            watercells.update(nwatercells)
+            for args in new:
+                WaterCell(*args)
+            
+            for key, s in watercells.items():
+                if key:
+                    x, y, dir = key
+                    flag = 0
+                    for k in range(4):
+                        dx, dy = s.TESTLIST[k]
+                        if ((x+dx, y+dy, -1) in watercells or
+                            (x+dx, y+dy,  1) in watercells):
+                            flag += 1<<k
+                    ico = images.sprget(s.ICONS[flag])
+                    s.move(x, y, ico)
+                    if s.touchable:
+                        for s1 in s.touching(0):
+                            if isinstance(s1, Monster):
+                                s1.untouchable()
+                                s1.gen = []
+                                s.take_with_me.append(s1)
+                            elif isinstance(s1, Bubble):
+                                s1.pop(s.poplist)
+                        for s1 in s.take_with_me:
+                            if s1.alive:
+                                s1.move(x2bounds(x-HALFCELL), y-CELL)
+            yield None
+        if not watercells[None].alive:
+            self.in_charge()
+
+    def touched(self, dragon):
+        dragon.watermove(x2bounds(self.x-HALFCELL), self.y-CELL+1)
+        return 1
+
+def watercell(x, y, poplist, dir=None, repeat=4):
+    b = boards.curboard
+    if not hasattr(b, 'watercells'):
+        b.watercells = {}
+    dir = dir or random.choice([-1, 1])
+    WaterCell(x, y, dir, b.watercells, poplist, repeat)
+
+class WaterBubble(BonusBubble):
+    max = 4
+    nimages = GreenAndBlue.water_bubbles
+    def condition():
+        return boards.curboard.water
+    def popped(self, dragon):
+        if dragon:
+            x0 = self.x // CELL + 1
+            y0 = self.y // CELL + 1
+            for x1 in [x0, x0+1, x0-1]:
+                if bget(x1,y0) == ' ' or bget(x1,y0+1) == ' ':
+                    x0 = x1
+                    break
+            watercell(x0*CELL, y0*CELL, [None], repeat=19)
+        return 10
+
+##class SolidBubble(WaterBubble):
+##    timeout = 450
+##    solidbubble = 1
+##    flip = 'vflip'
+
+##    def bubble_red(self, *args):
+##        self.solidbubble = 0
+##        return WaterBubble.bubble_red(self, *args)
+
+##    def pop(self, poplist=None):
+##        return (not (self.solidbubble and poplist is not None)
+##                and WaterBubble.pop(self, poplist))
+
+##    def popped(self, dragon):
+##        return 100
+
+class FiredLightning(ActiveSprite):
+    def __init__(self, x, y, dir, poplist, diry=0):
+        ActiveSprite.__init__(self, images.sprget(Lightning.fired), x, y)
+        self.dir = int(13*dir)
+        self.diry = int(13*diry)
+        self.gen.append(self.moving(poplist))
+    def moving(self, poplist):
+        from monsters import Monster
+        while (-2*CELL < self.x < boards.bwidth and
+               -2*CELL < self.y < boards.bheight):
+            for s in self.touching(2):
+                if isinstance(s, Monster):
+                    s.argh(poplist)
+                elif isinstance(s, Bubble):
+                    s.pop(poplist)
+            self.step(self.dir, self.diry)
+            yield None
+        self.kill()
+
+class LightningBubble(BonusBubble):
+    max = 4
+    nimages = GreenAndBlue.light_bubbles
+    def condition():
+        return boards.curboard.lightning
+    def popped(self, dragon):
+        if dragon:
+            FiredLightning(self.x, self.y, -dragon.dir, self.poplist)
+        return 10
+
+class BigLightBubble(LightningBubble):
+    flip = 'vflip'
+    def popped(self, dragon):
+        base = random.random() * 2.0*math.pi
+        for a in range(7):
+            FiredLightning(self.x, self.y, math.cos(base+a), self.poplist,
+                                   diry = -math.sin(base+a))
+        return 100
+
+
+class BigFireBubble(ActiveSprite):
+    touchable = 1
+
+    def __init__(self, x, y, hspeed, author):
+        if hspeed > 0:
+            imgs = PlayerBubbles.right_weapon
+        else:
+            imgs = PlayerBubbles.left_weapon
+        ActiveSprite.__init__(self, images.sprget(imgs[-1]), x, y)
+        self.setimages(self.cyclic(imgs, 2))
+        self.author = author
+        self.gen.append(self.moving(hspeed))
+        self.play(images.Snd.Shh)
+
+    def moving(self, hspeed):
+        from monsters import Monster
+        if abs(hspeed) < 3:
+            if hspeed > 0:
+                hspeed = 3
+            else:
+                hspeed = -3
+        fx = self.x
+        poplist = [self.author]
+        while 1:
+            fx += hspeed
+            self.move(int(fx), self.y)
+            xc = int(fx)//CELL + 1
+            yc = (self.y+HALFCELL)//CELL
+            if bget(xc,yc) == '#' == bget(xc, yc+1):
+                break
+            yield None
+            for s in self.touching(4):
+                if isinstance(s, Monster):
+                    s.argh(poplist)
+        self.kill()
+
+    def touched(self, dragon):
+        if dragon is not self.author:
+            import bonuses
+            bonuses.repulse_dragon(dragon)
+
+
+class SpinningBall(ActiveSprite):
+    def __init__(self, x, y, poplist):
+        ActiveSprite.__init__(self, images.sprget(SpinningBalls.free[-1]), x,y)
+        self.poplist = poplist
+        self.gen.append(self.dropping())
+        imgs = SpinningBalls.free
+        if random.random() < 0.5:
+            imgs = list(imgs)
+            imgs.reverse()
+        self.setimages(self.cyclic(imgs, random.randrange(2,5)))
+        self.touchable = 1
+    def dropping(self):
+        from monsters import Monster
+        for ny in range(self.y, boards.bheight, 5):
+            self.move(self.x, ny)
+            yield None
+            for s in self.touching(0):
+                if isinstance(s, Monster):
+                    s.argh(self.poplist)
+                elif isinstance(s, Bubble):
+                    s.pop(self.poplist)
+        self.kill()
+    def touched(self, dragon):
+        dragon.die()
+
+class StarBubble(BonusBubble):
+    timeout = 250
+    def __init__(self, pn):
+        self.colorname = random.choice(Stars.COLORS)
+        BonusBubble.__init__(self, pn, [('starbub', self.colorname, i)
+                                        for i in range(3)])
+##    def __init__(self, pn):
+##        BonusBubble.__init__(self, pn)
+##        self.colorname = random.choice(Stars.COLORS)
+##        starimg = [('smstar', self.colorname, 0),
+##                   ('smstar', self.colorname, 1)]
+##        smallstar = ActiveSprite(images.sprget(starimg[-1]),
+##                                 self.x+8, self.y+8)
+##        smallstar.setimages(smallstar.cyclic(starimg))
+##        smallstar.gen.append(smallstar.following(self, 8, 8))
+    def popped(self, dragon):
+        if dragon:
+            from bonuses import BonusMaker, AllOutcomes, Parabolic2
+            BonusMaker(self.x, self.y, getattr(Stars, self.colorname),
+                       outcome=random.choice(AllOutcomes))
+            for i in range(2):
+                Parabolic2(self.x, self.y, [('smstar', self.colorname, i)
+                                            for i in range(2)])
+        return 100
+
+class MonsterBubble(BonusBubble):
+    timeout = 100
+    def __init__(self, pn, mcls):
+        import monsters, mnstrmap
+        BonusBubble.__init__(self, pn)
+        mdef = getattr(mnstrmap, mcls.__name__)
+        m = mcls(mdef, self.x, self.y, 1)
+        m.in_bubble(self)
+
+class MoreBubblesBubble(BonusBubble):
+
+    def can_catch_dragons(self, author, catch_myself=0):
+        # at this point, explode the bubble into more bubbles
+        d = author
+        for angle in [math.pi, math.pi/2, -math.pi/2, 0]:
+            for factor in [0.2, 0.55, 0.9, 1.25, 1.6]:
+                DragonBubble(d, self.x, self.y, d.dir,
+                             angle = angle, thrustfactor = factor)
+        self.pop()
+
+
+Classes = ([PlainBubble] * 7 +
+           [FireBubble, WaterBubble, LightningBubble] * 4 +
+           [LetterBubble])
+
+def newbubble(): #force=0):
+    #if force:
+    #cls = PlainBubble
+    #else:
+    cls = random.choice(Classes)
+    if not cls.__dict__['condition']():
+        return
+    if cls.max is not None:
+        others = [s for s in images.ActiveSprites if isinstance(s, cls)]
+        if len(others) >= cls.max:
+            return
+    sendbubble(cls)
+
+def newforcedbubble():
+    choices = [PlainBubble] * 5
+    for cls in [FireBubble, WaterBubble, LightningBubble]:
+        if cls.__dict__['condition']():
+            n = 4
+        else:
+            n = 1
+        choices.extend([cls] * n)
+    cls = random.choice(choices)
+    return sendbubble(cls)
+
+def sendbubble(cls, *args, **kw):
+    from player import BubPlayer
+    players = [p for p in BubPlayer.PlayerList if p.isplaying()]
+    if not players:
+        return None
+    pn = random.choice(players).pn
+    return cls(pn, *args, **kw)
+
+def newbonusbubble():
+    boards.curboard.top = random.choice([0,0,0, 1,1,1, 2,2, 3,3])
+    r = random.random()
+    if r < 0.14:
+        sendbubble(random.choice(Classes))
+    elif r < 0.16:
+        from player import BubPlayer
+        import monsters
+        mcls = random.choice(monsters.MonsterClasses)
+        for d in BubPlayer.DragonList:
+            sendbubble(MonsterBubble, mcls)
+    else:
+        sendbubble(StarBubble)