initial commit from cvs 1.6.2

5 files changed, 369 insertions, 0 deletions

diff --git a/bubbob/ext3/.cvsignore b/bubbob/ext3/.cvsignore
new file mode 100644
index 0000000..553d0ec
--- /dev/null
+++ b/bubbob/ext3/.cvsignore
@@ -0,0 +1,2 @@
+*.py[co]
+image1-[2-9].ppm
diff --git a/bubbob/ext3/__init__.py b/bubbob/ext3/__init__.py
new file mode 100644
index 0000000..f5408c1
--- /dev/null
+++ b/bubbob/ext3/__init__.py
@@ -0,0 +1,367 @@
+from __future__ import generators
+import os, math, random
+import images, gamesrv
+from images import ActiveSprite
+import boards
+from boards import CELL, HALFCELL, bget
+from mnstrmap import GreenAndBlue, Fire
+from bonuses import Bonus
+from player import Dragon, BubPlayer
+import monsters
+from bubbles import Bubble
+
+LocalDir = os.path.basename(os.path.dirname(__file__))
+
+localmap = {
+    'gala': ('image1-%d.ppm', (0, 0, 32, 32)),
+    }
+
+music = gamesrv.getmusic(os.path.join(LocalDir, 'music.wav'))
+snd_shoot = gamesrv.getsample(os.path.join(LocalDir, 'shoot.wav'))
+
+
+class Ship(ActiveSprite):
+
+    def __init__(self, galaga, bubber, x, y):
+        ico = images.sprget(('gala', bubber.pn))
+        ActiveSprite.__init__(self, ico, x, y)
+        self.galaga = galaga
+        self.bubber = bubber
+        self.gen.append(self.movedown())
+        self.gen.append(self.playing_ship())
+        self.gen.append(self.doomed())
+        self.galaga.ships.append(self)
+
+    def movedown(self):
+        import boards
+        target_y = boards.bheight - self.ico.h
+        while self.y < target_y:
+            yield None
+            self.move(self.x, self.y + 3)
+        self.move(self.x, target_y)
+
+    def playing_ship(self):
+        import boards
+        bubber = self.bubber
+        xmin = HALFCELL
+        xmax = boards.bwidth - HALFCELL - self.ico.w
+        fire = 0
+        while 1:
+            wannago = bubber.wannago(self.dcap)
+            nx = self.x + 2*wannago
+            if nx < xmin:
+                nx = xmin
+            elif nx > xmax:
+                nx = xmax
+            self.move(nx, self.y)
+            if fire:
+                fire -= 1
+            elif bubber.key_fire:
+                self.firenow()
+                fire = 28
+            yield None
+
+    def firenow(self):
+        ico = images.sprget(GreenAndBlue.new_bubbles[self.bubber.pn][0])
+        s = Shot(ico, self.x, self.y)
+        s.d = self
+        s.gen = [s.straightup(self)]
+        self.play(snd_shoot)
+
+    def doomed(self):
+        dangerous = Alien, monsters.MonsterShot
+        while 1:
+            touching = images.touching(self.x+3, self.y+3, 26, 26)
+            for s in touching:
+                if isinstance(s, dangerous):
+                    self.kill()
+                    return
+            yield None
+            yield None
+
+    def kill(self):
+        try:
+            self.bubber.dragons.remove(self)
+        except ValueError:
+            pass
+        images.Snd.Pop.play(1.0, pad=0.0)
+        images.Snd.Pop.play(1.0, pad=1.0)
+        ico = images.sprget(Bubble.exploding_bubbles[0])
+        for i in range(11):
+            s = ActiveSprite(ico,
+                             self.x + random.randrange(self.ico.w) - CELL,
+                             self.y + random.randrange(self.ico.h) - CELL)
+            s.gen.append(s.die(Bubble.exploding_bubbles))
+        try:
+            self.galaga.ships.remove(self)
+        except ValueError:
+            pass
+        ActiveSprite.kill(self)
+
+
+class Shot(Bubble):
+    touchable = 0
+    
+    def straightup(self, ship):
+        ymin = -self.ico.h
+        while self.y > ymin:
+            self.step(0, -10)
+            touching = images.touching(self.x+CELL-1, self.y+CELL-1, 2, 2)
+            touching = [s for s in touching if isinstance(s, Alien)]
+            if touching:
+                alien = random.choice(touching)
+                self.gen = []
+                self.touchable = 1
+                self.move(alien.x, alien.y)
+                self.pop([ship])
+                alien.kill()
+                scores = ship.galaga.scores
+                scores[ship.bubber] = scores.get(ship.bubber, 0) + 1
+                ship.bubber.givepoints(100)
+                return
+            yield None
+
+    def popped(self, dragon):
+        return 200
+
+
+class Alien(monsters.Monster):
+    ANGLES = 32
+    SPEED = 5
+    ANGLE_TABLE = [(SPEED * math.cos(a*2.0*math.pi/ANGLES),
+                    -SPEED * math.sin(a*2.0*math.pi/ANGLES))
+                   for a in range(ANGLES)]
+    touchable = 0
+    
+    def __init__(self, galaga, squadron, rank, relativey):
+        centerx = boards.bwidth // 2
+        go_left = squadron % 2
+        dx = (1,-1)[go_left]
+        halfspan = centerx*7//12
+        relativex = - halfspan + 4*CELL*rank
+        if relativex > halfspan:
+            raise StopIteration
+        
+        if squadron % 3 == 2:
+            from mnstrmap import Ghosty as mcls
+        else:
+            from mnstrmap import Flappy as mcls
+        mdef = mcls(centerx // CELL - 1, -7, go_left)
+        mdef.left_weapon = mdef.right_weapon = [Fire.drop]
+        monsters.Monster.__init__(self, mdef)
+
+        self.path = [(None, centerx + (dx*centerx)*2//3, boards.bheight//3),
+                     (None, centerx - (dx*centerx)*4//5, boards.bheight//6),
+                     (galaga, -dx*relativex, -relativey)]
+        self.gen = [self.waiting(rank * 20)]
+        self.in_place = 0
+        galaga.nbmonsters += 1
+
+    def default_mode(self, angle=ANGLES//4):
+        self.touchable = 1
+        speed = self.SPEED
+        relative, tx, ty = self.path[0]
+        fx = self.x
+        fy = self.y
+        ymax = boards.bheight - self.ico.h
+        cont = 1
+        if relative:
+            shoot_prob = 0.0085
+        else:
+            shoot_prob = 0.021
+        while cont:
+            if self.angry:
+                self.kill()   # never getting out of a bubble
+                return
+            if relative:
+                dx = relative.globalx + tx
+                dy = relative.globaly + ty
+            else:
+                dx = tx
+                dy = ty
+            dx -= self.x
+            dy -= self.y
+            
+            tests = []
+            for a1 in (-1, 0, 1):
+                a1 = (angle+a1) % self.ANGLES
+                testx, testy = self.ANGLE_TABLE[a1]
+                testx -= dx
+                testy -= dy
+                tests.append((testx*testx+testy*testy, a1))
+            ignored, angle = min(tests)
+            if dx*dx+dy*dy > speed*speed:
+                dx, dy = self.ANGLE_TABLE[angle]
+            elif relative:
+                self.in_place = 1
+                if self.y > ymax and relative.ships:
+                    for ship in relative.ships[:]:
+                        ship.kill()
+                        relative.builddelay[ship.bubber] = 9999
+                    relative.gameover = 1
+                    #x0 = self.x//CELL + 1
+                    #if x0 < 2: x0 = 0
+                    #if x0 >= boards.width-2: x0 = boards.width-3
+                    #bubbles.FireFlame(x0, boards.height-2, None, [-1, 1],
+                    #                  boards.width)
+            else:
+                self.path.pop(0)
+                self.gen.append(self.default_mode(angle))
+                cont = 0
+            fx += dx
+            fy += dy
+            self.move(int(fx), int(fy))
+            if dx and (self.dir > 0) != (dx > 0):
+                self.dir = -self.dir
+                self.resetimages()
+            if random.random() < shoot_prob and self.y >= 0:
+                monsters.DownShot(self)
+            yield None
+
+
+class Galaga:
+    gameover = 0
+    
+    def bgen(self):
+        self.scores = {}
+        for t in boards.initsubgame(music, self.displaypoints):
+            yield t
+
+        self.ships = []
+        self.builddelay = {}
+        self.nbmonsters = 0
+        #finish = 0
+        for t in self.frame():
+            t = boards.normal_frame()
+            self.build_ships()
+            yield t
+            #if len(self.ships) == 0:
+            #    finish += 1
+            #    if finish == 50:
+            #        break
+            #else:
+            #    finish = 0
+            if (BubPlayer.FrameCounter & 15) == 7:
+                for s in images.ActiveSprites:
+                    if isinstance(s, Bubble) and not isinstance(s, Shot):
+                        s.pop()
+
+        for t in boards.result_ranking(self.scores, self.nbmonsters):
+            self.build_ships()
+            yield t
+        for s in images.ActiveSprites[:]:
+            if isinstance(s, (Alien, Ship)):
+                s.kill()
+
+    def displaypoints(self, bubber):
+        return self.scores.get(bubber, 0)
+
+    def frame(self):
+        curboard.walls_by_pos.clear()
+        curboard.winds = ['v' * curboard.width] * curboard.height
+        for y in range(len(curboard.walls)):
+            curboard.walls[y] = ' ' * len(curboard.walls[y])
+        l1 = curboard.sprites['walls']
+        l2 = curboard.sprites['borderwalls']
+        while l1 or l2:
+            for l in [l1, l2]:
+                for w in l[:]:
+                    w.step(0, 5)
+                    if w.y >= boards.bheight:
+                        l.remove(w)
+                        w.kill()
+            yield None
+
+        self.globalx = boards.bwidth // 2
+        self.globaly = 0
+        shifter = self.shifter()
+        squadrons = len([p for p in BubPlayer.PlayerList if p.isplaying()])
+        squadrons = 3 + (squadrons+1)//3
+        nextsquad = 0
+        relativey = 0
+        squadtime = 0
+        while not self.gameover:
+            yield None
+            #if random.random() < 0.015:
+            #    bubbles.sendbubble(bubbles.PlainBubble, top=0)
+            in_place = {0: [], 1: [], 2: []}
+            for s in BubPlayer.MonsterList:
+                if isinstance(s, Alien):
+                    in_place[s.in_place].append(s)
+            toohigh = self.globaly - relativey < -3*CELL
+            if in_place[1]:
+                xbounds = [s.x for s in in_place[1]]
+                self.alien_bounds = min(xbounds), max(xbounds)
+                shifter.next()
+            elif toohigh:
+                self.globaly += 1
+            squadtime -= 1
+            if nextsquad >= squadrons:
+                if not (in_place[0] or in_place[1]):
+                    break
+            elif squadtime < 0 and not toohigh:
+                squadtime = 200
+                try:
+                    rank = 0
+                    while 1:
+                        Alien(self, nextsquad, rank, relativey)
+                        rank += 1
+                except StopIteration:
+                    pass
+                nextsquad += 1
+                relativey += 4*CELL
+        for t in range(20):
+            yield None
+
+    def shifter(self):
+        while 1:
+            # go right
+            while self.alien_bounds[1] < boards.bwidth-5*CELL:
+                self.globalx += 2
+                yield None
+            # go down
+            for i in range(3*CELL):
+                self.globaly += 1
+                yield None
+            # go left
+            while self.alien_bounds[0] > 3*CELL:
+                self.globalx -= 2
+                yield None
+            # go down
+            for i in range(3*CELL):
+                self.globaly += 1
+                yield None
+
+    def build_ships(self):
+        for p in BubPlayer.PlayerList:
+            dragons = [d for d in p.dragons if not isinstance(d, Ship)]
+            if dragons and len(p.dragons) == len(dragons):
+                if self.builddelay.get(p):
+                    self.builddelay[p] -= 1
+                else:
+                    self.builddelay[p] = 75
+                    dragon = random.choice(dragons)
+                    ship = Ship(self, p, dragon.x, dragon.y)
+                    ship.dcap = dragon.dcap
+                    p.dragons.append(ship)
+                    p.emotic(dragon, 4)
+            for d in dragons:
+                d.kill()
+
+# This game is suitable for at least min_players players
+min_players = 1
+
+def run():
+    global curboard
+    from boards import curboard
+    boards.replace_boardgen(Galaga().bgen())
+
+def setup():
+    for key, (filename, rect) in localmap.items():
+        filename = os.path.join(LocalDir, filename)
+        if filename.find('%d') >= 0:
+            for p in BubPlayer.PlayerList:
+                images.sprmap[key, p.pn] = (filename % p.pn, rect)
+        else:
+            images.sprmap[key] = (filename, rect)
+setup()
diff --git a/bubbob/ext3/image1-0.ppm b/bubbob/ext3/image1-0.ppm
new file mode 100644
index 0000000..89e9178
--- /dev/null
+++ b/bubbob/ext3/image1-0.ppm
diff --git a/bubbob/ext3/music.wav b/bubbob/ext3/music.wav
new file mode 100644
index 0000000..4684177
--- /dev/null
+++ b/bubbob/ext3/music.wav
diff --git a/bubbob/ext3/shoot.wav b/bubbob/ext3/shoot.wav
new file mode 100644
index 0000000..fb2b099
--- /dev/null
+++ b/bubbob/ext3/shoot.wav