initial commit from cvs 1.6.2

1 files changed, 937 insertions, 0 deletions

diff --git a/bubbob/monsters.py b/bubbob/monsters.py
new file mode 100644
index 0000000..88983d0
--- /dev/null
+++ b/bubbob/monsters.py
@@ -0,0 +1,937 @@
+from __future__ import generators
+import random
+import gamesrv
+import images
+import boards
+from boards import *
+from images import ActiveSprite
+from mnstrmap import GreenAndBlue, Bonuses, Ghost
+from player import BubPlayer
+import bonuses
+
+
+class Monster(ActiveSprite):
+    touchable = 1
+    special_prob = 0.2
+    shootcls = None
+    vx = 2
+    vy = 0
+    vdir = -1
+    is_ghost = 0
+    MonsterBonus = bonuses.MonsterBonus
+
+    def __init__(self, mnstrdef, x=None, y=None, dir=None, in_list=None):
+        self.mdef = mnstrdef
+        self.ptag = None
+        if dir is None: dir = mnstrdef.dir
+        if x is None: x = mnstrdef.x*CELL
+        if y is None: y = mnstrdef.y*CELL
+        self.dir = dir
+        ActiveSprite.__init__(self, images.sprget(self.imgrange()[0]), x, y)
+        self.gen.append(self.waiting())
+        if in_list is None:
+            in_list = BubPlayer.MonsterList
+        self.in_list = in_list
+        self.in_list.append(self)
+        self.no_shoot_before = 0
+        #images.ActiveSprites.remove(self)
+
+    def unlist(self):
+        try:
+            self.in_list.remove(self)
+            return 1
+        except ValueError:
+            return 0
+
+    def kill(self):
+        self.unlist()
+        ActiveSprite.kill(self)
+
+    def tagdragon(self):
+        lst = bonuses.getvisibledragonlist()
+        if lst:
+            return random.choice(lst)
+        else:
+            return None
+
+    def imgrange(self):
+        if self.is_ghost:
+            if self.dir > 0:
+                return Ghost.right
+            else:
+                return Ghost.left
+        elif self.angry:
+            if self.dir > 0:
+                return self.mdef.right_angry
+            else:
+                return self.mdef.left_angry
+        else:
+            if self.dir > 0:
+                return self.mdef.right
+            else:
+                return self.mdef.left
+
+    def imgrange1(self):
+        # normally this is self.imgrange()[1]
+        lst = self.imgrange()
+        return lst[len(lst) > 1]
+
+    def resetimages(self, is_ghost=0):
+        self.is_ghost = is_ghost
+        if self.gen:
+            self.setimages(self.cyclic(self.imgrange(), 3))
+        else:  # frozen monster
+            self.seticon(images.sprget(self.imgrange()[0]))
+
+    def blocked(self):
+        if self.dir < 0:
+            x0 = (self.x-1)//16
+        else:
+            x0 = (self.x+33)//16
+        y0 = self.y // 16 + 1
+        y1 = (self.y + 31) // 16
+        return bget(x0,y0) == '#' or bget(x0,y1) == '#'
+
+    def tryhstep(self):
+        if self.blocked():
+            self.dir = -self.dir
+            self.resetimages()
+            return 0
+        else:
+            self.step(self.vx*self.dir, 0)
+            return 1
+
+    def vblocked(self):
+        if self.vdir < 0:
+            y0 = self.y//16
+        else:
+            y0 = (self.y+1)//16 + 2
+        x0 = self.x // 16
+        x1 = self.x // 16 + 1
+        x2 = (self.x+31) // 16
+        return bget(x0,y0) == '#' or bget(x1,y0) == '#' or bget(x2,y0) == '#'
+
+    def tryvstep(self):
+        if self.vblocked():
+            self.vdir = -self.vdir
+            return 0
+        else:
+            self.step(0, self.vy*self.vdir)
+            self.vertical_warp()
+            return 1
+
+    def waiting(self, delay=20):
+        for i in range(delay):
+            yield None
+        self.resetimages()
+        self.gen.append(self.default_mode())
+
+    def overlapping(self):
+        if self.in_list is BubPlayer.MonsterList:
+            for s in self.in_list:
+                if (-6 <= s.x-self.x <= 6 and -6 <= s.y-self.y < 6 and
+                    #s.dir == self.dir and s.vdir == self.vdir and
+                    s.vx == self.vx and s.vy == self.vy and
+                    (not s.angry) == (not self.angry)):
+                    return s is not self
+        return 0
+
+    def walking(self):
+        while onground(self.x, self.y):
+            yield None
+            if random.random() < 0.2 and self.overlapping():
+                yield None
+            x1 = self.x
+            if self.dir > 0:
+                x1 += self.vx
+            if (x1 & 15) < self.vx and random.random() < self.special_prob:
+                self.move(x1 & -16, self.y)
+                if self.special():
+                    return
+            self.tryhstep()
+        if self.seedragon():
+            self.gen.append(self.hjumping())
+        else:
+            self.gen.append(self.falling())
+
+    def seedragon(self, dragon=None):
+        dragon = dragon or self.tagdragon()
+        if dragon is None:
+            return False
+        return abs(dragon.y - self.y) < 16 and self.dir*(dragon.x-self.x) > 0
+
+    def special(self):
+        dragon = self.tagdragon()
+        if dragon is None:
+            return 0
+        if self.seedragon(dragon) and self.shoot():
+            return 1
+        if dragon.y < self.y-CELL:
+           #and abs(dragon.x-self.x) < 2*(self.y-dragon.y):
+            for testy in range(self.y-2*CELL, self.y-6*CELL, -CELL):
+                if onground(self.x, testy):
+                    if random.random() < 0.5:
+                        ndir = self.dir
+                    elif dragon.x < self.x:
+                        ndir = -1
+                    else:
+                        ndir = 1
+                    self.gen.append(self.vjumping(testy, ndir))
+                    return 1
+        return 0
+
+    def shooting(self, pause):
+        for i in range(pause):
+            yield None
+        self.shootcls(self)
+        yield None
+        self.gen.append(self.default_mode())
+
+    def shoot(self, pause=10):
+        if (self.shootcls is None or
+            self.no_shoot_before > BubPlayer.FrameCounter):
+            return 0
+        else:
+            self.gen.append(self.shooting(pause))
+            self.no_shoot_before = BubPlayer.FrameCounter + 29
+            return 1
+
+    def falling(self):
+        bubber = getattr(self, 'bubber', None)
+        while not onground(self.x, self.y):
+            yield None
+            ny = self.y + 3
+            if (ny & 15) > 14:
+                ny = (ny//16+1)*16
+            elif (ny & 15) < 3:
+                ny = (ny//16)*16
+            nx = self.x
+            if nx < 32:
+                nx += 1 + (self.vx-1) * (bubber is not None)
+            elif nx > boards.bwidth - 64:
+                nx -= 1 + (self.vx-1) * (bubber is not None)
+            elif bubber:
+                dx = bubber.wannago(self.dcap)
+                if dx and dx != self.dir:
+                    self.dir = dx
+                    self.resetimages()
+                    self.setimages(None)
+                if dx and not self.blocked():
+                    nx += self.vx*dx
+                    self.seticon(images.sprget(self.imgrange1()))
+            self.move(nx, ny)
+            if self.y >= boards.bheight:
+                self.vertical_warp()
+        if bubber:
+            nextgen = self.playing_monster
+        else:
+            nextgen = self.walking
+        self.gen.append(nextgen())
+
+##    def moebius(self):
+##        self.dir = -self.dir
+##        self.resetimages()
+##        if hasattr(self, 'dcap'):
+##            self.dcap['left2right'] *= -1
+
+    def hjumping(self):
+        y0 = self.y
+        vspeed = -2.2
+        ny = y0-1
+        while ny <= y0 and not self.blocked():
+            self.move(self.x+2*self.dir, int(ny))
+            yield None
+            vspeed += 0.19
+            ny = self.y + vspeed
+        self.gen.append(self.default_mode())
+
+    def vjumping(self, limity, ndir):
+        self.setimages(None)
+        yield None
+        self.dir = -self.dir
+        self.seticon(images.sprget(self.imgrange()[0]))
+        for i in range(9):
+            yield None
+        self.dir = -self.dir
+        self.seticon(images.sprget(self.imgrange()[0]))
+        for i in range(4):
+            yield None
+        self.dir = ndir
+        self.seticon(images.sprget(self.imgrange1()))
+        for ny in range(self.y-4, limity-4, -4):
+            self.move(self.x, ny)
+            if ny < -32:
+                self.vertical_warp()
+            yield None
+        self.resetimages()
+        self.gen.append(self.default_mode())
+
+    def regular(self):
+        return self.still_playing() and self.touchable and not self.is_ghost
+
+    def still_playing(self):
+        return (self.in_list is BubPlayer.MonsterList and
+                self in self.in_list)
+
+    def touched(self, dragon):
+        if self.gen:
+            self.killdragon(dragon)
+            if self.is_ghost and not hasattr(self, 'bubber'):
+                self.gen = [self.default_mode()]
+                self.resetimages()
+        else:
+            self.argh(getattr(self, 'poplist', None))  # frozen monster
+
+    def killdragon(self, dragon):
+        dragon.die()
+
+    def in_bubble(self, bubble):
+        if not hasattr(self.mdef, 'jailed'):
+            return
+        self.untouchable()
+        self.angry = []
+        bubble.move(self.x, self.y)
+        if not hasattr(bubble, 'withmonster'):
+            bubble.to_front()
+        self.to_front()
+        img = self.mdef.jailed
+        self.gen = [self.bubbling(bubble)]
+        self.setimages(self.cyclic([img[1], img[2], img[1], img[0]], 4))
+
+    def bubbling(self, bubble):
+        counter = 0
+        while not hasattr(bubble, 'poplist'):
+            self.move(bubble.x, bubble.y)
+            yield None
+            counter += 1
+            if counter == 50 and hasattr(self, 'bubber'):
+                bubble.setimages(bubble.bubble_red())
+        if bubble.poplist is None:
+            self.touchable = 1
+            self.angry = [self.genangry()]
+            self.resetimages()
+            self.gen.append(self.default_mode())
+        else:
+            previous_len = len(BubPlayer.MonsterList)
+            self.argh(bubble.poplist)
+            dragon = bubble.poplist[0]
+            if dragon is not None:
+                if previous_len and not BubPlayer.MonsterList:
+                    points = 990
+                else:
+                    points = 90
+                dragon.bubber.givepoints(points)
+
+    def argh(self, poplist=None, onplace=0):
+        if self not in self.in_list:
+            return
+        if not poplist:
+            poplist = [None]
+        poplist.append(self)
+        level = len(poplist) - 2
+        bonuses.BonusMaker(self.x, self.y, self.mdef.dead, onplace=onplace,
+                           outcome=(self.MonsterBonus, level))
+        self.kill()
+
+    def freeze(self, poplist):
+        # don't freeze monsters largely out of screen, or they'll never come in
+        if self.regular() and -self.ico.h < self.y < boards.bheight:
+            self.gen = []
+            self.poplist = poplist
+
+    def flying(self):
+        blocked = 0
+        while 1:
+            if random.random() < 0.2 and self.overlapping():
+                yield None
+            hstep = self.tryhstep()
+            vstep = self.tryvstep()
+            if hstep or vstep:
+                blocked = 0
+            elif blocked:
+                # blocked! go up or back to the play area
+                if self.x < 32:
+                    self.step(self.vy, 0)
+                elif self.x > boards.bwidth - 64:
+                    self.step(-self.vy, 0)
+                else:
+                    self.step(0, -self.vy)
+                    self.vertical_warp()
+            else:
+                blocked = 1
+            yield None
+
+    def becoming_monster(self, big=0, immed=0):
+        if big:
+            self.is_ghost = 1
+            self.seticon(images.sprget(self.imgrange()[0]))
+            images.Snd.Hell.play()
+        for i in range(5):
+            ico = self.ico
+            self.seticon(self.bubber.icons[11 + immed, self.dir])
+            yield None
+            yield None
+            self.seticon(ico)
+            yield None
+            yield None
+        self.resetimages(is_ghost=big)
+        self.gen.append(self.playing_monster())
+
+    def become_monster(self, bubber, saved_caps, big=0, immed=0):
+        self.timeoutgen = self.back_to_dragon()
+        self.default_mode = self.playing_monster
+        self.bubber = bubber
+        self.dcap = saved_caps
+        self.gen = [self.becoming_monster(big, immed)]
+
+    def back_to_dragon(self):
+        for t in range(259):
+            yield None
+            if bonuses.getdragonlist():
+                yield None
+                yield None
+                yield None
+        from player import Dragon
+        d = Dragon(self.bubber, self.x, self.y, self.dir, self.dcap)
+        d.dcap['shield'] = 50
+        self.bubber.dragons.append(d)
+        self.kill()
+
+    def playing_monster(self):
+        if self.timeoutgen not in self.gen:
+            self.gen.append(self.timeoutgen)
+        bubber = self.bubber
+        while self.is_ghost:
+            # ghost
+            self.angry = []
+            key, dx, dy = max([(bubber.key_left, -1, 0),
+                               (bubber.key_right, 1, 0),
+                               (bubber.key_jump, 0, -1),
+                               (bubber.key_fire, 0, 1)])
+            if key:
+                if dx and self.dir != dx:
+                    self.dir = dx
+                    self.resetimages(is_ghost=1)
+                nx = self.x + 10*dx
+                ny = self.y + 9*dy
+                if nx < 0: nx = 0
+                if nx > boards.bwidth-2*CELL: nx = boards.bwidth-2*CELL
+                if ny < -CELL: ny = -CELL
+                if ny > boards.bheight-CELL: ny = boards.bheight-CELL
+                self.move(nx, ny)
+            yield None
+        if self.vy:
+            # flying monster
+            while 1:
+                dx = bubber.wannago(self.dcap)
+                if dx and dx != self.dir:
+                    self.dir = dx
+                    self.resetimages()
+                if bubber.key_jump and bubber.key_jump > bubber.key_fire:
+                    dy = self.vdir = -1
+                elif bubber.key_fire:
+                    dy = self.vdir = 1
+                else:
+                    dy = 0
+                hstep = dx and self.tryhstep()
+                vstep = dy and self.tryvstep()
+                if dx and dy and not (hstep or vstep):
+                    # blocked?
+                    self.dir = -self.dir
+                    self.vdir = -self.vdir
+                    blocked = self.blocked() and self.vblocked()
+                    self.dir = -self.dir
+                    self.vdir = -self.vdir
+                    if blocked:
+                        # completely blocked! accept move or force back to
+                        # play area
+                        if self.x < 32:
+                            self.step(self.vy, 0)
+                        elif self.x > boards.bwidth - 64:
+                            self.step(-self.vy, 0)
+                        else:
+                            self.step(self.vx*dx, self.vy*dy)
+                            self.vertical_warp()
+                yield None
+        elif not isinstance(self, Springy):
+            # walking monster
+            jumping_y = 0
+            imgsetter = self.imgsetter
+            while onground(self.x, self.y) or jumping_y:
+                dx = bubber.wannago(self.dcap)
+                if dx and dx != self.dir:
+                    self.dir = dx
+                    self.resetimages()
+                    imgsetter = self.imgsetter
+                if dx and not self.blocked():
+                    self.step(self.vx*dx, 0)
+                    if not jumping_y:
+                        self.setimages(imgsetter)
+                    else:
+                        self.seticon(images.sprget(self.imgrange1()))
+                        self.setimages(None)
+                else:
+                    self.setimages(None)
+                    dx = 0
+                yield None
+                if not jumping_y:
+                    wannafire = bubber.key_fire
+                    wannajump = bubber.key_jump
+                    if wannafire and self.shoot(1):
+                        return
+                    if wannajump:
+                        jumping_y = CELL
+                if jumping_y:
+                    self.step(0, -4)
+                    if self.y < -32:
+                        self.vertical_warp()
+                    if onground(self.x, self.y):
+                        jumping_y = 0
+                    else:
+                        jumping_y -= 1
+            self.gen.append(self.falling())
+        else:
+            # springy
+            if not onground(self.x, self.y):
+                self.gen.append(self.falling())
+                return
+            prevx = self.x
+            for t in self.walking():
+                dx = bubber.wannago(self.dcap)
+                if dx:
+                    if dx != self.dir:
+                        self.dir = dx
+                        self.resetimages()
+                    if self.blocked() and (self.x-prevx)*dx <= 0:
+                        dx = 0
+                    self.move(prevx + self.vx*dx, self.y)
+                yield None
+                prevx = self.x
+
+    def become_ghost(self):
+        self.gen = [self.ghosting()]
+        self.resetimages(is_ghost=1)
+
+    def ghosting(self):
+        counter = 0
+        while counter < 5:
+            for i in range(50):
+                yield None
+            dragon = self.tagdragon()
+            if dragon is None:
+                counter += 1
+            else:
+                counter = 0
+                px, py = dragon.x, dragon.y
+                if abs(px-self.x) < abs(py-self.y):
+                    dx = 0
+                    if py > self.y:
+                        dy = 1
+                    else:
+                        dy = -1
+                else:
+                    dy = 0
+                    if px > self.x:
+                        dx = 1
+                    else:
+                        dx = -1
+                    self.dir = dx
+                    self.resetimages(is_ghost=1)
+                dx *= 10
+                dy *= 9
+                distance = 1E10
+                while 1:
+                    self.angry = []
+                    self.step(dx, dy)
+                    yield None
+                    dist1 = (px-self.x)*(px-self.x)+(py-self.y)*(py-self.y)
+                    if dist1 > distance:
+                        break
+                    distance = dist1
+        self.angry = []
+        self.gen = [self.default_mode()]
+        self.resetimages()
+
+    default_mode = falling
+
+
+def argh_em_all():
+    poplist = [None]
+    for s in images.ActiveSprites[:]:
+        if isinstance(s, Monster):
+            s.argh(poplist)
+
+def freeze_em_all():
+    poplist = [None]
+    for s in images.ActiveSprites:
+        if isinstance(s, Monster):
+            s.freeze(poplist)
+
+
+class MonsterShot(ActiveSprite):
+    speed = 6
+    touchable = 1
+    
+    def __init__(self, owner, dx=CELL, dy=0):
+        self.owner = owner
+        self.speed = owner.dir * self.speed
+        if owner.dir < 0:
+            nimages = owner.mdef.left_weapon
+        else:
+            nimages = owner.mdef.right_weapon
+        ActiveSprite.__init__(self, images.sprget(nimages[0]),
+                              owner.x, owner.y + dy)
+        self.step((owner.ico.w - self.ico.w) // 2,
+                  (owner.ico.h - self.ico.h) // 2)
+        if not self.blocked():
+            self.step(dx*owner.dir, 0)
+        if len(nimages) > 1:
+            self.setimages(self.cyclic(nimages, 3))
+        self.gen.append(self.moving())
+
+    def blocked(self):
+        if self.speed < 0:
+            x0 = (self.x-self.speed-8)//16
+        else:
+            x0 = (self.x+self.ico.w+self.speed-8)//16
+        y0 = (self.y+8) // 16 + 1
+        return not (' ' == bget(x0,y0) == bget(x0+1,y0))
+
+    def moving(self):
+        while not self.blocked():
+            yield None
+            self.step(self.speed, 0)
+        self.hitwall()
+
+    def hitwall(self):
+        self.untouchable()
+        self.gen.append(self.die(self.owner.mdef.decay_weapon, 2))
+
+    def touched(self, dragon):
+        dragon.die()
+
+
+class BoomerangShot(MonsterShot):
+    speed = 8
+    
+    def hitwall(self):
+        self.gen.append(self.moveback())
+
+    def moveback(self):
+        owner = self.owner
+        if self.speed > 0:
+            nimages = owner.mdef.left_weapon
+        else:
+            nimages = owner.mdef.right_weapon
+        self.setimages(self.cyclic(nimages, 3))
+        while (owner.x-self.x) * self.speed < 0:
+            yield None
+            self.step(-self.speed, 0)
+            if self.blocked():
+                break
+        self.kill()
+
+class FastShot(MonsterShot):
+    speed = 15
+
+
+class DownShot(MonsterShot):
+
+    def __init__(self, owner):
+        MonsterShot.__init__(self, owner, 0, CELL)
+
+    def moving(self):
+        while self.y < boards.bheight:
+            yield None
+            self.step(0, 7)
+        self.kill()
+
+
+##class DragonShot(MonsterShot):
+##    speed = 8
+
+##    def __init__(self, owner):
+##        MonsterShot.__init__(self, owner)
+##        self.untouchable()
+##        self.gen.append(self.touchdelay(4))
+
+##    def touched(self, dragon):
+##        if dragon is not self.owner:
+##            if dragon.bubber.bonbons == 0:
+##                dragon.die()
+##            else:
+##                from player import scoreboard
+##                from bonuses import Sugar1, Sugar2
+##                from bonuses import BonusMaker
+##                if random.random() < 0.2345:
+##                    start = 1
+##                else:
+##                    start = 0
+##                loose = min(2, dragon.bubber.bonbons)
+##                for i in range(start, loose):
+##                    cls = random.choice([Sugar1, Sugar2])
+##                    BonusMaker(self.x, self.y, [cls.nimage],
+##                               outcome=(cls,))
+##                dragon.bubber.bonbons -= loose
+##                scoreboard()
+##                dragon.dcap['shield'] = 25
+##                self.owner.play(images.Snd.Yippee)
+##                self.kill()
+
+##    def blocked(self):
+##        return self.x < -self.ico.w or self.x >= gamesrv.game.width
+##        #return self.x < CELL or self.x >= boards.bwidth - 3*CELL
+
+
+class Nasty(Monster):
+    pass
+
+class Monky(Monster):
+    shootcls = MonsterShot
+
+class Ghosty(Monster):
+    default_mode = Monster.flying
+    vy = 2
+
+class Flappy(Monster):
+    default_mode = Monster.flying
+    vy = 1
+
+class Springy(Monster):
+    spring_down = 0
+    def imgrange(self):
+        if self.spring_down and not self.is_ghost:
+            if self.angry:
+                if self.dir > 0:
+                    r = self.mdef.right_jump_angry
+                else:
+                    r = self.mdef.left_jump_angry
+            else:
+                if self.dir > 0:
+                    r = self.mdef.right_jump
+                else:
+                    r = self.mdef.left_jump
+            return [r[self.spring_down-1]]
+        else:
+            return Monster.imgrange(self)
+    def walking(self):
+        self.spring_down = 1
+        self.resetimages()
+        for t in range(2+self.overlapping()):
+            yield None
+        self.spring_down = 2
+        self.resetimages()
+        for t in range(4+2*self.overlapping()):
+            yield None
+        self.spring_down = 1
+        self.resetimages()
+        for t in range(2+self.overlapping()):
+            yield None
+        self.spring_down = 0
+        self.resetimages()
+        g = 10.0/43
+        vy = -20*g
+        yf = self.y
+        for t in range(40):
+            yf += vy
+            vy += g
+            if self.blocked():
+                self.dir = -self.dir
+                self.resetimages()
+            nx = self.x + self.dir*self.vx
+            if self.y//16 < int(yf)//16:
+                if onground(self.x, (self.y//16+1)*16):
+                    break
+                if onground(nx, (self.y//16+1)*16):
+                    self.move(nx, self.y)
+                    break
+            nx, yf = vertical_warp(nx, yf)
+            self.move(nx, int(yf))
+##            if moebius:
+##                self.moebius()
+            yield None
+        self.gen.append(self.falling())
+
+class Orcy(Monster):
+    shootcls = FastShot
+
+class Gramy(Monster):
+    shootcls = BoomerangShot
+    vx = 3
+
+class Blitzy(Monster):
+    shootcls = DownShot
+    vx = 3
+
+    def seedragon(self, dragon=None):
+        return 0
+
+    def special(self):
+        if random.random() < 0.3:
+            self.shootcls(self)
+        return 0
+
+    def shoot(self, pause=0):
+        # no pause (only used when controlled by the player)
+        if self.no_shoot_before > BubPlayer.FrameCounter:
+            pass
+        else:
+            self.shootcls(self)
+            self.no_shoot_before = BubPlayer.FrameCounter + 29
+        return 0
+
+MonsterClasses = [c for c in globals().values()
+                  if type(c)==type(Monster) and issubclass(c, Monster)]
+MonsterClasses.remove(Monster)
+
+
+class Butterfly(Monster):
+    MonsterBonus = bonuses.IceMonsterBonus
+    fly_away = False
+
+    def waiting(self, delay=0):
+        return Monster.waiting(self, delay)
+
+    def imgrange(self):
+        self.angry = []
+        return Monster.imgrange(self)
+
+    def killdragon(self, dragon):
+        if self.is_ghost:
+            Monster.killdragon(self, dragon)
+        else:
+            self.fly_away = True, dragon.x
+
+    def flying(self):
+        repeat = 0
+        while 1:
+            r = random.random()
+            if self.x < 64:
+                bump = self.dir < 0
+            elif self.x > boards.bwidth - 64:
+                bump = self.dir > 0
+            elif self.fly_away:
+                wannago = self.x - self.fly_away[1]
+                if self.x < 100:
+                    wannago = 1
+                elif self.x > boards.bwidth - 100:
+                    wannago = -1
+                bump = self.dir * wannago < 0
+                if repeat:
+                    self.fly_away = False
+                    repeat = 0
+                else:
+                    repeat = 1
+            else:
+                bump = r < 0.07
+            if bump:
+                self.dir = -self.dir
+                self.resetimages()
+            elif r > 0.92:
+                self.vdir = -self.vdir
+            self.step(self.dir * (2 + (r < 0.5)), self.vdir * 2)
+            self.vertical_warp()
+            if not repeat:
+                yield None
+
+    default_mode = flying
+
+
+class Sheep(Monster):
+
+    def playing_monster(self):
+        from bonuses import Bonus
+        bubber = self.bubber
+        vy = None
+        imgsetter = self.imgsetter
+        poplist = [None]
+        while 1:
+            dx = bubber.wannago(self.dcap)
+            if dx and dx != self.dir:
+                self.dir = dx
+                self.resetimages()
+                imgsetter = self.imgsetter
+            if dx and vy is None:
+                self.setimages(imgsetter)
+            else:
+                self.setimages(None)
+                if vy is not None:
+                    if vy < 0:
+                        n = 1
+                    else:
+                        n = 3
+                    self.seticon(images.sprget(self.imgrange()[n]))
+            if dx and not self.blocked():
+                self.step(self.vx*dx, 0)
+            yield None
+            impulse = 0.0
+            wannajump = bubber.key_jump
+            if vy is not None:
+                vy += 0.33
+                if vy > 12.0:
+                    vy = 12.0
+                yf = self.y + yfp + vy
+                yfp = yf - int(yf)
+                delta = int(yf) - self.y
+                if delta > 0:
+                    by_y = {}
+                    for s in images.ActiveSprites:
+                        if isinstance(s, Bonus) and s.touchable:
+                            if abs(s.x - self.x) <= 22:
+                                by_y[s.y] = s
+                    for monster in BubPlayer.MonsterList:
+                        if abs(monster.x - self.x) <= 22:
+                            if monster.regular():
+                                by_y[monster.y] = monster
+                    for ny in range(self.y - 1, self.y + delta + 1):
+                        self.move(self.x, ny)
+                        self.vertical_warp()
+                        if onground(self.x, self.y):
+                            poplist = [None]
+                            impulse = vy
+                            vy = None
+                            break
+                        key = self.y + 29
+                        if key in by_y:
+                            s = by_y[key]
+                            if isinstance(s, Monster):
+                                self.play(images.Snd.Extra)
+                                s.argh(poplist)
+                            elif isinstance(s, Bonus):
+                                s.reallytouched(self)
+                            yfp = 0.0
+                            vy = -3.3
+                            break
+                else:
+                    self.step(0, delta)
+                    self.vertical_warp()
+            if vy is None:
+                if onground(self.x, self.y):
+                    if wannajump:
+                        yfp = 0.0
+                        vy = - max(1.0, impulse) - 2.02
+                        impulse = 0.0
+                        self.play(images.Snd.Jump)
+                else:
+                    yfp = vy = 0.0
+            if impulse > 8.1:
+                break
+        self.play(images.Snd.Pop)
+        for n in range(2):
+            for letter in 'abcdefg':
+                ico = images.sprget(('sheep', letter))
+                nx = self.x + random.randrange(-1, self.ico.w - ico.w + 2)
+                ny = self.y + random.randrange(0, self.ico.h - ico.h + 2)
+                dxy = [random.random() * 5.3 - 2.65, random.random() * 4 - 4.4]
+                s = images.ActiveSprite(ico, nx, ny)
+                s.gen.append(s.parabolic(dxy))
+                s.gen.append(s.die([None], random.randrange(35, 54)))
+        self.move(-99, 0)
+        for t in range(68):
+            yield None
+        self.kill()
+
+    default_mode = falling = playing_monster
+
+    def argh(self, *args, **kwds):
+        pass