initial commit from cvs 1.6.2

6 files changed, 401 insertions, 0 deletions

diff --git a/bubbob/ext7/.cvsignore b/bubbob/ext7/.cvsignore
new file mode 100644
index 0000000..553d0ec
--- /dev/null
+++ b/bubbob/ext7/.cvsignore
@@ -0,0 +1,2 @@
+*.py[co]
+image1-[2-9].ppm
diff --git a/bubbob/ext7/__init__.py b/bubbob/ext7/__init__.py
new file mode 100644
index 0000000..2d157ab
--- /dev/null
+++ b/bubbob/ext7/__init__.py
@@ -0,0 +1,399 @@
+from __future__ import generators
+import os, random, math
+import images, gamesrv
+from images import ActiveSprite
+import boards
+from boards import CELL
+from player import Dragon, BubPlayer, scoreboard
+from bubbles import Bubble
+from bonuses import Bonus
+from mnstrmap import PlayerBubbles
+from mnstrmap import Monky
+import bonuses
+from ext6 import snd_crash
+
+LocalDir = os.path.basename(os.path.dirname(__file__))
+
+ANGLE_COUNT = 24
+ANGLE_STEP  = 360 / ANGLE_COUNT
+ANGLE_TABLE = {}
+for i in range(ANGLE_COUNT):
+    a = i*ANGLE_STEP*math.pi/180.0
+    ANGLE_TABLE[i*ANGLE_STEP] = (math.cos(a), math.sin(a))
+
+
+localmap = {}
+for i in range(ANGLE_COUNT):
+    localmap['camel', i] = ('image1-%d.ppm', (0, i*36, 36, 36))
+
+music = gamesrv.getmusic(os.path.join(LocalDir, 'music.wav'))
+snd_fire = gamesrv.getsample(os.path.join(LocalDir, 'fire.wav'))
+snd_hit  = gamesrv.getsample(os.path.join(LocalDir, 'hit.wav'))
+
+
+class Plane(ActiveSprite):
+    lock = None
+
+    def __init__(self, camel, bubber, dcap, x, y, dirhint=None):
+        self.bubber = bubber
+        self.dcap = dcap
+        self.camel = camel
+        self.shotlist = camel.score.setdefault(bubber, {})
+
+        if x < x_min:
+            x = x_min
+        elif x > x_max:
+            x = x_max
+
+        if y < 4*CELL:
+            y = 4*CELL
+        elif y > (curboard.height-4)*CELL - 36:
+            y = (curboard.height-4)*CELL - 36
+
+        if dirhint not in (1, -1):
+            controldelay = 5
+            if x < boards.bwidth//2:
+                dir = 1
+            else:
+                dir = -1
+        else:
+            controldelay = 20
+            if x < boards.bwidth//3:
+                dir = 1
+            elif x >= boards.bwidth*2//3:
+                dir = -1
+            else:
+                dir = dirhint
+        if dir > 0:
+            self.angle = 0
+            self.flipped = False
+        else:
+            self.angle = 180
+            self.flipped = True
+
+        ActiveSprite.__init__(self, self.getico(), x, y)
+        self.fx = self.x
+        self.fy = self.y
+        self.controlgen = self.control(delay=controldelay)
+        self.gen.append(self.fly())
+        self.gen.append(self.controlgen)
+        self.gen.append(self.blink())
+        self.gen.append(self.bob())
+
+    def controlled(self):
+        return self.controlgen in self.gen
+
+    def getico(self):
+        a = self.angle // ANGLE_STEP
+        if self.flipped:
+            if a:
+                a = ANGLE_COUNT-a
+            key = 'vflip', ('camel', a, self.bubber.pn)
+        else:
+            key = 'camel', a, self.bubber.pn
+        return images.sprget(key)
+
+    def blink(self):
+        for i in range(10):
+            yield None
+            yield None
+            self.setdisplaypos(-256, -256)
+            yield None
+            self.setdisplaypos(-256, -256)
+            yield None
+        self.touchable = 1
+
+    def bob(self):
+        f = 3.0
+        for i in range(0, 1080, ANGLE_STEP):
+            self.fy += f * ANGLE_TABLE[i % 360][1]
+            f *= 0.98
+            yield None
+
+##    def loosealtitude(self, y0, angle0):
+##        if 90 <= angle0 < 270 or (angle0 == 270 and not self.flipped):
+##            angledir = -1
+##        else:
+##            angledir = 1
+##        for i in range(0, 180, ANGLE_STEP):
+##            if i % (4*ANGLE_STEP) == 0 and not (45 <= angle0 <= 135):
+##                angle0 += ANGLE_STEP * angledir
+##                angle0 = (angle0 + 360) % 360
+##            y0 += 4.0 * ANGLE_TABLE[i][1]
+##            if y0 > self.fy:
+##                self.fy = y0
+##            self.angle = angle0
+##            yield None
+
+    def turn(self, dir):
+        self.angle += ANGLE_STEP * dir
+        self.angle = (self.angle + 360) % 360
+
+    def control(self, delay=0):
+        bubber = self.bubber
+        prev_key_jump = 0
+        for i in range(delay):
+            yield None
+        shootdelay = 0
+        while True:
+            wannago = bubber.wannago(self.dcap)
+            self.turn(wannago)
+            if shootdelay:
+                shootdelay -= 1
+            elif bubber.key_fire:
+                x = self.x + self.ico.w//2
+                y = self.y + self.ico.h//2
+                acos, asin = ANGLE_TABLE[self.angle]
+                x += acos * 20
+                y += asin * 20
+                if self.flipped:
+                    acos = -acos
+                    asin = -asin
+                x -= asin * 5
+                y += acos * 5
+                self.play(snd_fire)
+                Shot(self, int(x), int(y), self.angle, 2)
+                Shot(self, int(x), int(y), self.angle)
+                shootdelay = 7
+            for i in range(2):
+                if bubber.key_jump > prev_key_jump:
+                    self.flipped = not self.flipped
+                prev_key_jump = bubber.key_jump
+                yield None
+            for s in self.touching(12):
+                if isinstance(s, Plane) and s is not self:
+                    ico = images.sprget(Monky.decay_weapon[1])
+                    s1 = ActiveSprite(ico,
+                                      (self.x+s.x)//2 + self.ico.w//2 - CELL,
+                                      (self.y+s.y)//2 + self.ico.h//2 - CELL)
+                    s1.gen.append(s1.die(Monky.decay_weapon[1:], 4))
+                    s1.play(snd_crash)
+                    self.gen = [self.godowninflames(s)]
+                    s.gen = [s.godowninflames(self)]
+
+    def fly(self, speed=3.3):
+        while True:
+            if (self.y < 0 and not (0 < self.angle < 180) and
+                ((abs(270 - self.angle) < -4*self.y) or random.random() < 0.2)):
+                if (90 <= self.angle < 270 or
+                    (self.angle == 270 and not self.flipped)):
+                    self.turn(-1)
+                else:
+                    self.turn(1)
+            ico = self.getico()
+            acos, asin = ANGLE_TABLE[self.angle]
+            self.fx += acos * speed
+            self.fy += asin * speed
+            self.move(int(self.fx), int(self.fy), ico)
+            if self.x < x_min:
+                self.angle = 2 * ANGLE_STEP
+                self.flipped = not self.flipped
+                self.gen = [self.godowninflames()]
+                self.play(images.Snd.Pop)
+            elif self.x > x_max:
+                self.angle = 180 - 2 * ANGLE_STEP
+                self.flipped = not self.flipped
+                self.gen = [self.godowninflames()]
+                self.play(images.Snd.Pop)
+            elif self.y > y_max:
+                self.gen = [self.crashed()]
+            yield None
+
+    def godowninflames(self, hit_by_plane=None):
+        if hit_by_plane and hit_by_plane in self.shotlist:
+            hittime = self.shotlist[hit_by_plane]
+            if BubPlayer.FrameCounter < hittime + 60:
+                del self.shotlist[hit_by_plane]
+                scoreboard()
+        self.seticon(self.getico())
+        self.gen.append(self.fly())
+        trail = [(self.x, self.y)] * 7
+        ico = images.sprget(PlayerBubbles.explosion[0])
+        s = ActiveSprite(ico, self.x + self.ico.w//2 - CELL,
+                              self.y + self.ico.h//2 - CELL)
+        s.gen.append(s.die(PlayerBubbles.explosion))
+        self.bubber.emotic(self, 4)
+        while True:
+            yield None
+            if random.random() < 0.37:
+                ico = images.sprget(Bubble.exploding_bubbles[0])
+                x, y = random.choice(trail)
+                x += random.randint(-10, 10)
+                y += random.randint(-10, 10)
+                s = ActiveSprite(ico, x+2, y+2)
+                s.gen.append(s.die(Bubble.exploding_bubbles))
+            if random.random() < 0.5:
+                yield None
+                if 90 <= self.angle < 270:
+                    lst = [0, 0, 0, 0, -1, -1, -1, 1, 1]
+                else:
+                    lst = [0, 0, 0, 0, -1, -1, 1, 1, 1]
+                self.turn(random.choice(lst))
+            trail.pop(0)
+            trail.append((self.x, self.y))
+
+    def crashed(self):
+        self.untouchable()
+        self.play(snd_crash)
+        ico = images.sprget(Monky.decay_weapon[1])
+        self.seticon(ico)
+        self.step(self.ico.w//2 - CELL,
+                  self.ico.h//2 - CELL)
+        self.gen.append(self.die(Monky.decay_weapon[1:], 4))
+        yield None
+
+    def kill(self):
+        try:
+            self.bubber.dragons.remove(self)
+        except ValueError:
+            pass
+        ActiveSprite.kill(self)
+
+
+class Shot(ActiveSprite):
+
+    def __init__(self, plane, x, y, angle, steps=0):
+        ico = images.sprcharacterget('.')
+        ActiveSprite.__init__(self, ico, x-4, y-12)
+        self.plane = plane
+        self.angle = angle
+        self.gen.append(self.moving(steps))
+
+    def moving(self, steps=0):
+        minx = 2*CELL - 4
+        maxx = (curboard.width-2)*CELL  - 4
+        maxy = (curboard.height-1)*CELL - 12
+        fx = self.x
+        fy = self.y
+        dx, dy = ANGLE_TABLE[self.angle]
+        dx *= 7.6
+        dy *= 7.6
+        fx += dx * steps
+        fy += dy * steps
+        for i in range(22-steps):
+            for s in images.touching(self.x+3, self.y+11, 2, 2):
+                if isinstance(s, Plane) and s is not self.plane:
+                    self.play(snd_hit)
+                    self.kill()
+                    if s.controlled():
+                        s.gen = [s.godowninflames(self.plane)]
+                        self.plane.shotlist[s] = BubPlayer.FrameCounter
+                    bonuses.points(self.x + 4 - CELL, self.y + 12 - CELL,
+                                   self.plane, 100)
+                    return
+            fx += dx
+            fy += dy
+            self.move(int(fx), int(fy))
+            if self.x < minx or self.x > maxx or self.y > maxy:
+                break
+            yield None
+        self.kill()
+
+
+class Camel:
+    
+    def bgen(self, limittime = 90.1): # 1:30
+        self.score = {}
+        for t in boards.initsubgame(music, self.displaypoints):
+            yield t
+
+        tc = boards.TimeCounter(limittime)
+        for t in self.frame(tc):
+            t = boards.normal_frame()
+            self.build_planes()
+            yield t
+            tc.update(t)
+            if (BubPlayer.FrameCounter & 15) == 7:
+                for s in images.ActiveSprites:
+                    if isinstance(s, Bubble):
+                        s.pop()
+                    elif isinstance(s, Bonus):
+                        s.kill()
+
+        tc.restore()
+        score = {}
+        for player, shotlist in self.score.items():
+            score[player] = len(shotlist)
+        for t in boards.result_ranking(score):
+            for p in BubPlayer.PlayerList:
+                for d in p.dragons[:]:
+                    d.kill()
+            yield t
+        self.remove_planes()
+
+    def displaypoints(self, bubber):
+        return len(self.score.get(bubber, ()))
+
+    def build_planes(self):
+        for p in BubPlayer.PlayerList:
+            dragons = [d for d in p.dragons if not isinstance(d, Plane)]
+            if dragons and len(p.dragons) == len(dragons):
+                dragon = random.choice(dragons)
+                if dragon.dcap['infinite_shield']:
+                    start_position = self.select_start_position()
+                    dirhint = None
+                else:
+                    start_position = dragon.x-2, dragon.y-2
+                    dirhint = getattr(dragon, 'dir', None)
+                plane = Plane(self, p, dragon.dcap,
+                              start_position[0], start_position[1], dirhint)
+                p.dragons.append(plane)
+                p.emotic(plane, 4)
+            for d in dragons:
+                d.kill()
+
+    def remove_planes(self):
+        for p in BubPlayer.PlayerList:
+            for d in p.dragons[:]:
+                d.kill()
+
+    def select_start_position(self):
+        planes = [d for p in BubPlayer.PlayerList
+                    for d in p.dragons
+                    if isinstance(d, Plane)]
+        distmin = 180
+        while True:
+            x = random.choice([x_min, x_max])
+            y = random.randint(2*CELL, (curboard.height-4)*CELL - 36)
+            for d in planes:
+                dist = (x-d.x)*(x-d.x) + (y-d.y)*(y-d.y)
+                if dist < distmin*distmin:
+                    break
+            else:
+                return x, y
+            distmin = int(distmin * 0.94)
+
+    def frame(self, tc):
+        y = curboard.height-1
+        for x in range(2, curboard.width-2):
+            if (y, x) not in curboard.walls_by_pos:
+                curboard.putwall(x, y)
+        curboard.reorder_walls()
+        for y in range(0, curboard.height-1):
+            yield None
+            for x in range(2, curboard.width-2):
+                if (y, x) in curboard.walls_by_pos:
+                    curboard.killwall(x, y)
+        while tc.time != 0.0:
+            yield None
+
+# This game is suitable for at least min_players players
+min_players = 2
+
+def run():
+    global curboard, x_min, x_max, y_max
+    from boards import curboard
+    x_min = 2*CELL - 3
+    x_max = (curboard.width-2)*CELL - 36 + 3
+    y_max = (curboard.height-1)*CELL - 36 + 7
+    boards.replace_boardgen(Camel().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/ext7/fire.wav b/bubbob/ext7/fire.wav
new file mode 100644
index 0000000..c8531a3
--- /dev/null
+++ b/bubbob/ext7/fire.wav
diff --git a/bubbob/ext7/hit.wav b/bubbob/ext7/hit.wav
new file mode 100644
index 0000000..36d497a
--- /dev/null
+++ b/bubbob/ext7/hit.wav
diff --git a/bubbob/ext7/image1-0.ppm b/bubbob/ext7/image1-0.ppm
new file mode 100644
index 0000000..2df7b9b
--- /dev/null
+++ b/bubbob/ext7/image1-0.ppm
diff --git a/bubbob/ext7/music.wav b/bubbob/ext7/music.wav
new file mode 100644
index 0000000..b45f018
--- /dev/null
+++ b/bubbob/ext7/music.wav