removed some file that should not be in git

1 files changed, 0 insertions, 1282 deletions

diff --git a/bubbob/levels/rnglevel b/bubbob/levels/rnglevel
deleted file mode 100644
index 7a3186b..0000000
--- a/bubbob/levels/rnglevel
+++ /dev/null
@@ -1,1282 +0,0 @@
-from random import *
-from math import *
-
-import boarddef
-from boarddef import LNasty, LMonky, LGhosty, LFlappy
-from boarddef import LSpringy, LOrcy, LGramy, LBlitzy
-from boarddef import RNasty, RMonky, RGhosty, RFlappy
-from boarddef import RSpringy, ROrcy, RGramy, RBlitzy
-
-def cmp(a, b):
-    return (a > b) - (a < b) 
-
-def flat(mean,var):
-    return randrange(mean-var,mean+var+1)
-
-def dice(n,sides,orig=1):
-    result = 0
-    for i in range(n):
-        result += orig+randrange(sides)
-    return result
-
-def fish(mu):
-    def fact(n):
-        r = 1.
-        for i in range(1,n+1):
-            r *= i
-        return r
-    scale = fact(0)/exp(-mu)
-    dens = []
-    while 1:
-        x = len(dens)
-        dens.append(int(scale*exp(-mu)*pow(mu,x)/fact(x)+0.5))
-        if x > mu and dens[-1] == 0:
-            break
-    table = []
-    x = 0
-    for d in dens:
-        for i in range(d):
-            table.append(x)
-        x += 1
-    return choice(table)
-
-
-class RandomLevel(boarddef.Level):
-    WIDTH  = 32
-    HEIGHT = 28
-    MAXTRY = 1000
-    # parameters of the 'mess generator'
-    # mess_prob : the probability that a cell turn into a wall
-
-    def __init__(self,num):
-        if hasattr(self.__class__, 'walls'):
-            #print 'Reusing previously generated level'
-            #print self.__class__.walls
-            self.walls = self.__class__.walls
-            boarddef.Level.__init__(self,num)
-            return
-
-        #print 'Generating a new level'
-        self.reset(fill=False)
-
-        self.windmap = [ [' ' for x in range(self.WIDTH)] for y in range(self.HEIGHT) ]
-
-        if hasattr(self, 'auto'):
-            self.generate()
-            self.do_bonuses()
-
-        for gw in self.genwalls:
-            gw[0](self,*gw[1:])
-
-        if hasattr(self, 'mlist'):
-            self.do_monsters()
-
-        self.dig_vertical_walls()
-        self.do_walls()
-        self.walls = self.__class__.walls
-        #print self.walls
-
-        self.do_winds()
-        self.winds = self.__class__.winds
-
-        boarddef.Level.__init__(self,num)
-
-    def reset(self, fill=False):
-        if fill:
-            w = '#'
-            f = 0
-        else:
-            w = ' '
-            f = 1
-        # map for the walls
-        self.wmap = [ [w for x in range(self.WIDTH)] for y in range(self.HEIGHT) ]
-        # map of the free cells
-        self.fmap = [ [f for x in range(self.WIDTH)] for y in range(self.HEIGHT) ]
-
-    def setw(self,x,y,c='#'):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return
-        if self.fmap[y][x]:
-            self.wmap[y][x] = c
-            self.fmap[y][x] = 0
-
-    def getw(self,x,y):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return '#'
-        return self.wmap[y][x]
-
-    def clrw(self,x,y):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return
-        self.wmap[y][x] = ' '
-        self.fmap[y][x] = 1
-
-    def lockw(self,x,y,c=0):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return
-        self.fmap[y][x] = c
-
-    def setwind(self,x,y,c=' '):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return
-        self.windmap[y][x] = c
-
-    def getwind(self,x,y):
-        if x > self.WIDTH-1 or x < 0 or y > self.HEIGHT-1 or y < 0:
-            return ' '
-        return self.windmap[y][x]
-
-    def wind_rect(self,x,y,w,h,ccw=0):
-        "Set a wind in a rectangle which will move the bubbles cw or ccw"
-        if w < 1 or h < 1:
-            return
-        if ccw == 1:
-            for dx in range(w):
-               self.setwind(x+dx+1, y, '<')
-               self.setwind(x+dx, y+h, '>')
-            for dy in range(h):
-               self.setwind(x, y+dy, 'v')
-               self.setwind(x+w, y+dy+1, '^')
-        else:
-            for dx in range(w):
-               self.setwind(x+dx, y, '>')
-               self.setwind(x+dx+1, y+h, '<')
-            for dy in range(h):
-               self.setwind(x, y+dy+1, '^')
-               self.setwind(x+w, y+dy, 'v')
-
-    def mirror(self):
-        "Mirror the level vertically."
-        for y in range(self.HEIGHT):
-            for x in range(self.WIDTH//2):
-               self.wmap[y][x] = self.wmap[y][self.WIDTH-x-1]
-
-    def dig_well_until_space(self, x=1, yadj=1):
-        "Digs a well either up or down and stops when it encounters first empty wall space."
-        if yadj == 1:
-            y = 0
-        else:
-            yadj = -1
-            y = self.HEIGHT-1
-        while (y < self.HEIGHT) and (y >= 0):
-            self.clrw(x,y)
-            self.clrw(x+1,y)
-            y += yadj
-            if ((self.getw(x,y) == ' ') and (self.getw(x+1,y) == ' ')):
-                break
-
-    def enlarge_tiny_holes(self):
-        "Makes one-block size holes wider."
-        for x in range(self.WIDTH):
-            for y in range(self.HEIGHT):
-                if self.wmap[y][x] == ' ':
-                    single = 0
-                    for dx in range(x-1,x+2):
-                        for dy in range(y-1,y+2):
-                            if self.getw(dy,dx) == '#':
-                                single = single + 1
-                    if single == 8:
-                        if x > (self.WIDTH // 2):
-                            self.clrw(x-1,y)
-                        else:
-                            self.clrw(x+1,y)
-
-    def make_space(self, gens=-1):
-        "Removes walls from a level, to make it more playable."
-        if gens == -1:
-            gens = randint(0,62)+1
-        if gens & 1: # top
-            for x in range(self.WIDTH):
-                self.clrw(x,1)
-                if random() < 0.5:
-                    self.clrw(x,2)
-        if gens & 2: # bottom
-            for x in range(self.WIDTH):
-                self.clrw(x,self.HEIGHT-1)
-                if random() < 0.5:
-                    self.clrw(x,self.HEIGHT-2)
-        if gens & 4: # middle
-            y = randint(0,self.HEIGHT//10) + (self.HEIGHT//2)
-            for x in range(self.WIDTH):
-                self.clrw(x,y)
-                if random() < 0.5:
-                    self.clrw(x,y-1)
-                if random() < 0.5:
-                    self.clrw(x,y+1)
-        if gens & 8: # left
-            x = randint(0,self.WIDTH//4)
-            self.dig_well_until_space(x,  1)
-            self.dig_well_until_space(x, -1)
-        if gens & 16: # right
-            x = randint(0,self.WIDTH//4)
-            self.dig_well_until_space(self.WIDTH-x-2,  1)
-            self.dig_well_until_space(self.WIDTH-x-2, -1)
-        if gens & 32: # center
-            self.dig_well_until_space(self.WIDTH//2,  1)
-            self.dig_well_until_space(self.WIDTH//2, -1)
-
-    def generate_wind1(self, rndchoice=1, choices=[' ',' ',' ','x','>','<','^','^','v'], xsize=-1,ysize=-1):
-        """Makes a random wind pattern. Parameters:
-        0: if 1=randomly select from choices, else select in order
-        1: a list of the choices that are allowed.
-        2: horizontal size of wind blocks
-        3: vertical size of wind blocks
-        """
-        choicenum = 0
-        if xsize == -1:
-            xsize = randint(1, self.WIDTH)
-        if ysize == -1:
-            ysize = randint(1, self.HEIGHT)
-        if xsize < 1:
-            xsize = 1
-        elif xsize > self.WIDTH:
-            xsize = self.WIDTH
-        if ysize < 1:
-            ysize = 1
-        elif ysize > self.HEIGHT:
-            ysize = self.HEIGHT
-        for x in range((self.WIDTH//xsize)+1):
-            for y in range((self.HEIGHT//ysize)+1):
-                if rndchoice == 1:
-                    wdir = choice(choices)
-                else:
-                    wdir = choices[choicenum]
-                    choicenum = (choicenum + 1) % len(choices)
-                for dx in range(xsize+1):
-                    for dy in range(ysize+1):
-                        self.setwind(x*xsize+dx,y*ysize+dy,wdir)
-        # make sure that the special bubbles can come into screen
-        for x in range(self.WIDTH):
-            self.setwind(x, 0, ' ')
-            self.setwind(x, self.HEIGHT-1, ' ')
-
-    def wind_sidewalls(self):
-        """Make sure the left and side walls have updraft next to them
-        """
-        for y in range(self.HEIGHT):
-            self.setwind(0,y,'^')
-            self.setwind(self.WIDTH-1,y,'^')
-
-    def wind_wallblocking(self, winddirs):
-        """Sets up wind depending on the number of walls around each place.
-        winddirs is an array of 16 wind chars.
-        directions with walls count as: 1=N, 2=E, 4=S, 8=W
-        16th place is used if there is wall at the position.
-        """
-        for x in range(self.WIDTH):
-            for y in range(self.HEIGHT):
-               walld = 0
-               if self.getw(x,y) == '#':
-                   walld = 16
-               else:
-                   if self.getw(x,y-1) == '#':
-                      walld = walld + 1
-                   if self.getw(x+1,y) == '#':
-                      walld = walld + 2
-                   if self.getw(x,y+1) == '#':
-                      walld = walld + 4
-                   if self.getw(x-1,y) == '#':
-                      walld = walld + 8
-               wnd = winddirs[walld]
-               self.setwind(x,y,wnd)
-
-    def wind_wallblocking256(self, winddirs):
-        """Sets up wind depending on the number of walls around each position.
-        winddirs is an array of 257 wind chars (one of ' x<>^v-'), where '-' means
-        to use '>' or '<', pointing towards center of level.
-        directions with walls count as: 1=N, 2=NE, 4=E, 8=SE, 16=S, 32=SW, 64=W, 128=NW
-        257th place is use if there is wall at the position.
-        """
-        mdirs = [(0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1)]
-        for x in range(self.WIDTH):
-            for y in range(self.HEIGHT):
-               windd = 0
-               if self.getw(x,y) == '#':
-                   windd = 256
-               else:
-                   for d in range(8):
-                      dx = x + mdirs[d][0]
-                      dy = y + mdirs[d][1]
-                      if self.getw(dx, dy) == '#':
-                          windd = (1 << d)
-               wd = choice(winddirs[windd])
-               if wd == '-':
-                   if x < self.WIDTH // 2:
-                      wd = '>'
-                   else:
-                      wd = '<'
-               self.setwind(x,y, wd)
-
-    def generate_wind(self, gens = -1):
-        """Chooses one of the wind pattern generators and uses that to generate the winds.
-        0: choose what generator to use.
-        """
-        if gens == -1:
-            gens = choice([1,1,2,3,4,4,4,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19])
-        if gens == 1: # totally random pattern
-            self.generate_wind1()
-        elif gens == 2: # wind "layers"
-            self.generate_wind1(0, ['x','^','^','^'],self.WIDTH,1)
-            self.wind_sidewalls()
-        elif gens == 3: # "wiggly" winds
-            self.generate_wind1(1, ['^','<','^','>'],1,1)
-            self.wind_sidewalls()
-        elif gens == 4: # "normal" wind pattern
-            self.wind_sidewalls()
-            dx = (self.WIDTH//2)
-            if random() < 0.7:
-                dy = 1 # usual height where bubbles collect
-            else:
-                dy = randint(1, self.HEIGHT-1)
-            for x in range(dx-3, dx+3):
-                self.setwind(x,dy,'x')
-            for x in range(dx-2):
-                self.setwind(x,dy,'>')
-                self.setwind(self.WIDTH-x-1,dy,'<')
-        elif gens == 5: # bubbles are stopped by horizontal walls
-            self.wind_sidewalls()
-            for x in range(self.WIDTH):
-                for y in range(self.HEIGHT-2):
-                    if self.getw(x,y) == '#':
-                        if self.getw(x,y+1) == ' ':
-                            self.setwind(x,y+1,'x')
-        elif gens == 6: # bubbles move next the walls, rotating cw or ccw
-            if random() < 0.5: #clockwise
-               winddirs = [' ','>','v','v','<',' ','<','<','^','>',' ','v','^','>','^','x','x']
-            else:
-               winddirs = [' ','<','^','<','>',' ','^','<','v','v',' ','v','>','>','^','x','x']
-            self.wind_wallblocking(winddirs)
-        elif gens == 7: # bubbles move up in column(s) that zig-zag left and right
-            wid = choice([self.WIDTH, randint(2, self.WIDTH), randint(2, self.WIDTH)])
-            xofs = (self.WIDTH % wid) // 2
-            ofs = choice([0,1])
-            for dx in range(0, self.WIDTH-wid+1, wid):
-               for x in range(wid):
-                   for y in range(self.HEIGHT):
-                      if (y+ofs) & 1:
-                          self.setwind(x+dx+xofs,y,'<')
-                          if x == 0:
-                             self.setwind(x+dx+xofs,y,'^')
-                      else:
-                          self.setwind(x+dx+xofs,y,'>')
-                          if x == wid-1:
-                             self.setwind(x+dx+xofs,y,'^')
-        elif gens == 8: # bubbles move towards the map centerline at random height
-            for x in range(self.WIDTH):
-               y = randint(1, self.HEIGHT-1)
-               if x < (self.WIDTH//2):
-                   self.setwind(x,y,'>')
-               else:
-                   self.setwind(x,y,'<')
-               self.setwind(x,0,'v')
-               self.setwind(x,self.HEIGHT-1,'^')
-            for y in range(self.HEIGHT):
-               self.setwind(self.WIDTH//2,y,'x')
-        elif gens == 9: # bubbles move towards the side walls at random height
-            for x in range(self.WIDTH):
-               y = randint(1, self.HEIGHT-1)
-               if y & 1:
-                   self.setwind(x,y,'>')
-               else:
-                   self.setwind(x,y,'<')
-               self.setwind(x,0,'v')
-               self.setwind(x,self.HEIGHT-1,'^')
-            for y in range(self.HEIGHT):
-               self.setwind(0,y,'x')
-               self.setwind(self.WIDTH-1,y,'x')
-        elif gens == 10: # bubbles move up-down
-            ofs = choice([0,1])
-            dir_l = choice(['>', '>', '<'])
-            dir_r = choice(['<', '<', '>'])
-            for x in range(self.WIDTH):
-               if x < (self.WIDTH // 2):
-                   self.setwind(x, 0, dir_r)
-                   self.setwind(x,self.HEIGHT-1,dir_l)
-               else:
-                   self.setwind(x, 0, dir_l)
-                   self.setwind(x,self.HEIGHT-1,dir_r)
-            for x in range(self.WIDTH):
-               for y in range(self.HEIGHT):
-                   if (x+ofs) & 1:
-                      self.setwind(x,y+1,'^')
-                   else:
-                      self.setwind(x,y-1,'v')
-        elif gens == 11: # bubbles rotate
-            self.wind_sidewalls()
-            for z in range(20):
-               wid = randint(2,self.WIDTH//2)
-               hei = randint(2,self.HEIGHT//2)
-               y = randint(1, self.HEIGHT - hei - 1)
-               x = randint(1, self.WIDTH - wid - 1)
-               ok = 1
-               for dx in range(wid):
-                   if self.getwind(x+dx+1, y) != ' ':
-                      ok = 0
-                   if self.getwind(x+dx, y+hei) != ' ':
-                      ok = 0
-               for dy in range(hei):
-                   if self.getwind(x, y+dy) != ' ':
-                      ok = 0
-                   if self.getwind(x+wid, y+dy+1) != ' ':
-                      ok = 0
-               if ok == 1:
-                   self.wind_rect(x,y,wid,hei, random() < 0.5)
-        elif gens == 12: # bubbles gravitate towards a certain spot
-            dx = randint(1,self.WIDTH-1)
-            dy = randint(1,self.HEIGHT-1)
-            for x in range(self.WIDTH):
-               for y in range(self.HEIGHT):
-                   ax = abs(dx - x)
-                   ay = abs(dy - y)
-                   sx = cmp(dx - x, 0)
-                   sy = cmp(dy - y, 0)
-                   winds = [' ',' ',' ']
-                   if ax < 2 and ay < 2:
-                      winds = ['x']
-                   else:
-                      if sx < 0:
-                          winds += ['<']
-                      elif sx > 0:
-                          winds += ['>']
-                      else:
-                          if sy > 0:
-                             winds = ['v']
-                          elif sy < 0:
-                             winds = ['^']
-                          else:
-                             winds = ['x']
-                      if sy < 0:
-                          winds += ['^']
-                      elif sy > 0:
-                          winds += ['v']
-                      else:
-                          if sx > 0:
-                             winds = ['>']
-                          elif sx < 0:
-                             winds = ['<']
-                          else:
-                             winds = ['x']
-                   self.setwind(x,y,choice(winds))
-        elif gens == 13: # bubbles stop at some random positions
-            self.generate_wind1(1, [' ',' ',' ',' ',' ',' ',' ','x'],1,1)
-            self.wind_sidewalls()
-        elif gens == 14: # bubbles move cw and ccw in alternating rectangles
-            m = max(self.WIDTH // 2, self.HEIGHT // 2)
-            cwofs = choice([0,1])
-            thk = choice([1,1,2,2,3,4,randint(1,m//2)])
-            for dx in range(m):
-               cw = ((dx // thk) + cwofs) % 2
-               self.wind_rect(dx,dx, self.WIDTH-(dx*2), self.HEIGHT-(dx*2), cw)
-        elif gens == 15: # bubbles move cw or ccw in rectangles
-            m = max(self.WIDTH // 2, self.HEIGHT // 2)
-            cw = choice([0,1])
-            for dx in range(m):
-               self.wind_rect(dx,dx, self.WIDTH-(dx*2), self.HEIGHT-(dx*2), cw)
-        elif gens == 16:
-            xs = randint(2, (self.WIDTH//2)-1)
-            ys = randint(2, (self.HEIGHT//2)-1)
-            rx = (self.WIDTH  // xs) + 1
-            ry = (self.HEIGHT // ys) + 1
-            cwchanges = choice([0,0,0,0,0,0,0,0,1,1,1,1,2,2,3])
-            if cwchanges == 0:
-               cw = random() < 0.5
-            for x in range(rx):
-               if cwchanges == 1:
-                   cw = random() < 0.5
-               for y in range(ry):
-                   if cwchanges == 2:
-                      cw = random() < 0.5
-                   maxd = max((xs // 2), (ys // 2))
-                   for d in range(maxd):
-                      if cwchanges == 3:
-                          cw = random() < 0.5
-                      self.wind_rect(xs*x+d, ys*y+d, xs-2*d-1, ys-2*d-1, cw)
-        elif gens == 17: # bubbles bounce between walls
-            if random() < 0.5: # horizontal
-               winddirs = [' ',' ','<','<',' ',' ','<','<','>','>',' ',' ','>','>',' ',' ','x']
-            else: # vertical
-               winddirs = [' ','v',' ','v','^',' ','^',' ',' ','v',' ','v','^',' ','^',' ','x']
-            self.wind_wallblocking(winddirs)
-        elif gens == 18: # generate winds based on a random 3x3 matrix ruleset
-            winddirs = []
-            for z in range(257):
-               winddirs.append(choice([' ',' ',' ','x','^','v','-']))
-            winddirs[0] = ' '
-            winddirs[256] = choice(['x',' '])
-            self.wind_wallblocking256(winddirs)
-        elif gens == 19: # bubbles will move downwards in a zig-zag pattern
-            y = 0
-            x1 = randint(0, self.WIDTH-1)
-            while y < self.HEIGHT:
-               x2 = randint(0, self.WIDTH-1)
-               if x1 < x2:
-                   self.setwind(x1,y, '>')
-               else:
-                   self.setwind(x1,y, '<')
-               dy = choice([1,1,1,2])
-               self.setwind(x2,y, 'v')
-               y += dy
-               x1 = x2
-
-    def smooth(self, threshold, rev):
-        """Remove wall blocks that are surrounded by 4 empty places.
-        0: probability which a wall cell is turned into space
-        1: smooth away walls or smooth away empty spaces?
-        """
-        # make a copy of self.wmap and adds '#' at the end of line, for
-        # the overflowing indexing below: [x-1] and [x+1]
-        tmpwmap = [ line + ['#'] for line in self.wmap ]
-        if rev == 0:
-            chr = ' '
-        else:
-            chr = '#'
-        for x in range(self.WIDTH):
-            for y in range(1,self.HEIGHT-1):
-                count = 0
-                if tmpwmap[y+1][x] == chr:
-                    count = count + 1
-                if tmpwmap[y-1][x] == chr:
-                    count = count + 1
-                if tmpwmap[y][x+1] == chr:
-                    count = count + 1
-                if tmpwmap[y][x-1] == chr:
-                    count = count + 1
-                if (count >= 4) and (random() < threshold):
-                    if rev == 0:
-                        self.clrw(x,y)
-                    else:
-                        self.setw(x,y)
-
-    def mess(self, threshold):
-        """Random fill of the board with walls.
-        Only one argument, the probability that
-        a cell turns out to be a wall.
-        """
-        for x in range(self.WIDTH):
-            for y in range(self.HEIGHT):
-                if random() < threshold:
-                    self.setw(x,y)
-
-    def zigzag_lr(self):
-        """Generate the level with random left-right zig-zags.
-        """
-        first = 1
-        self.reset(fill=False)
-        y = choice([0,0,2,3,3,4])
-        while y < (self.HEIGHT-2):
-            if first == 1:
-                first = 0
-                x1 = x2 = randint(2, self.WIDTH-3)
-            else:
-                x2 = randint(2, self.WIDTH-3)
-            while (x2 > (x1-3)) and (x2 < (x1+3)):
-                x2 = randint(2, self.WIDTH-3)
-            for dx in range(min(x1,x2+1), max(x1,x2+1)):
-                self.setw(dx,y)
-            dy = choice([2,2,3,3,3,4])
-            for dy in range(dy+1):
-                self.setw(x2,y+dy)
-            y = y + dy
-            x1 = x2
-
-    def zigzag_ud(self):
-        """Generate the level with random up-down zig-zags.
-        """
-        first = 1
-        self.reset(fill=False)
-        x = -1
-        while x < self.WIDTH:
-            if first == 1:
-                first = 0
-                y1 = y2 = randint(2, self.HEIGHT-1)
-            else:
-                y2 = randint(2, self.HEIGHT-1)
-            while (y2 > (y1-2)) and (y2 < (y1+2)):
-                y2 = randint(2, self.HEIGHT-1)
-            for dy in range(min(y1,y2+1), max(y1,y2+1)):
-                self.setw(x,dy)
-            dx = choice([3,4,4,4,5,6])
-            for dx in range(dx+1):
-                self.setw(x+dx,y2)
-            x = x + dx
-            y1 = y2
-
-    def zigzag(self):
-        """Generate a level with a random zig-zag form.
-        """
-        if random() < 0.5:
-            self.zigzag_lr()
-        else:
-            self.zigzag_ud()
-
-    def platforms(self, xxx_todo_changeme, xxx_todo_changeme1, full=1):
-        """Place random platforms.
-        args is a tuple with the following fields:
-        0: a tuple containing the number of platforms and
-           the minum space between two platforms,
-        1: a tuple indicating in order:
-           - the rng for the number of holes per platform
-           - the rng for the width of the holes,
-        2: a flag indicating whether the platform should cross
-           the whole level or not.
-        """
-        (nplat, space) = xxx_todo_changeme
-        (rng_holes, rng_width) = xxx_todo_changeme1
-        plat = []
-        for i in range(nplat):
-            ntry = 100
-            while ntry:
-                y = randint(0,self.HEIGHT-1)
-                found = 0
-                for old in plat:
-                    if abs(old-y) <= space:
-                        found = 1
-                        break
-                if not found:
-                    plat.append(y)
-                    break
-                ntry -= 1
-            if not ntry:
-                continue  # ignore platform
-            if full:
-                x = 0
-                w = self.WIDTH
-            else:
-                x = randint(0,self.WIDTH-1)
-                w = randint(0,self.WIDTH-1)
-                s = choice([-1,1])
-                if s == -1:
-                    w = min(w,x)
-                    x -= w
-                else:
-                    w = min(w,self.WIDTH-x)
-            for x1 in range(x,x+w):
-                self.setw(x1,y)
-            for i in range(rng_holes()):
-                hx = randint(x,x+w)
-                hw = rng_width()
-                for h in range(hx-hw//2,hx+hw//2):
-                    self.clrw(h,y)
-
-    def remove_joined_blocks(self):
-        """Removes randomly placed, random sized blocks of walls.
-           The blocks are usually joined, or if not, they're offset so that
-           it's possible to move from one block to another by jumping.
-        """
-        self.reset(fill=True)
-        nrooms = randint(1, 4)
-        while nrooms:
-            nrooms -= 1;
-            x = 0
-            while x < self.WIDTH:
-                wid = randint(2,8)
-                hei = randint(2,6)
-                y = randint(2, self.HEIGHT - hei - 1)
-                for dx in range(wid):
-                    for dy in range(hei):
-                        self.clrw(x+dx, y+dy)
-                x += wid + choice([-2,-2,-1,-1,0]);
-
-    def discrete_blocks(self, blocks = -1):
-        """Put certain size blocks randomly, but so that they don't touch each other.
-        """
-        self.reset(fill=False)
-        if blocks == -1:
-            if random() < 0.75:
-               blocks = [(4,2),(2,4)] # CompactLevels, level 16
-               if random() < 0.30:
-                   blocks.append((2,2))
-               if random() < 0.20:
-                   blocks.append((6,2))
-               if random() < 0.10:
-                   blocks.append((8,2))
-            else:
-               blocks = []
-               while len(blocks) == 0:
-                   for bz in range(10):
-                      if random() < 0.3:
-                          blocks.append((bz+1,1))
-        ntry = 300
-        while ntry:
-            ntry -= 1
-            doput = 1
-            block = choice(blocks)
-            wid = block[0]
-            hei = block[1]
-            x = randint(0,self.WIDTH-wid-2)
-            y = randint(1,self.HEIGHT-hei-3)
-            for dx in range(x,x+wid+2):
-               for dy in range(y,y+hei+2):
-                   if self.getw(dx,dy) == '#':
-                      doput = 0
-            if doput:
-               for dx in range(x+1,x+wid+1):
-                   for dy in range(y+1,y+hei+1):
-                      self.setw(dx,dy)
-
-    def lines(self, rng_len, nlines, rng_angle=None):
-        """Generate a set of lines in any direction. It takes three
-        arguments, a rng for the length the lines, the number of lines,
-        and a rng for the angle.
-        """
-        if rng_angle is None:
-            rng_angle = lambda : choice([0]+[pi/i for i in range(3,21)]+[-pi/i for i in range(3,21)])
-        for i in range(nlines):
-            len = rng_len()
-            angle = rng_angle()
-            ntry = self.MAXTRY
-            while ntry:
-                sx = randint(0,self.WIDTH-1)
-                sy = randint(0,self.HEIGHT-1)
-                dx = int(sx + len*cos(angle) + 0.5)
-                dy = int(sy + len*sin(angle) + 0.5)
-                if dx < self.WIDTH and dy < self.HEIGHT and dx >= 0 and dy >= 0:
-                    break
-                ntry -= 1
-            if ntry == 0:
-                break
-            if abs(dx-sx) > abs(dy-sy):
-                for x in range(dx-sx+1):
-                    y = (2*(dy-sy)*x//(dx-sx)+1)//2
-                    self.setw(sx+x,sy+y)
-            else:
-                for y in range(dy-sy+1):
-                    x = (2*(dx-sx)*y//(dy-sy)+1)//2
-                    self.setw(sx+x,sy+y)
-
-    def rooms(self, rng_radius, rng_e, n_rooms):
-        """Generate rooms. It takes the following arguments:
-        0: the rng for the radius of the room
-        1: the rng for the excentricity of the room
-        2: the number of rooms
-        """
-        for i in range(n_rooms):
-            cx = randint(0,self.WIDTH-1)
-            cy = randint(0,self.HEIGHT-1)
-            r = rng_radius()
-            e = rng_e()*1.0
-            left   = cx-int(r*e+0.5)
-            right  = cx+int(r*e+0.5)
-            top    = cy-int(r/e+0.5)
-            bottom = cy+int(r/e+0.5)
-            for x in range(left,right+1):
-                self.setw(x,top)
-                self.setw(x,bottom)
-            for y in range(top,bottom+1):
-                self.setw(left,y)
-                self.setw(right,y)
-            for x in range(left+1,right):
-                for y in range(top+1,bottom):
-                    self.lockw(x,y)
-
-    def holes(self, rng_radius, rng_e, n_holes, rng_rect):
-        """Generate a set of holes in the level. It takes four args:
-        0: the rng for the radius of the holes
-        1: the rng for the excentricity of the holes
-        2: the number of holes
-        3: the rng for the shape of the hole 0 for circular, 1 for rectangular
-        """
-        for i in range(n_holes):
-            cx = randint(0,self.WIDTH-1)
-            cy = randint(0,self.HEIGHT-1)
-            r = rng_radius()
-            e = rng_e()*1.0
-            rect = rng_rect()
-            for x in range(cx-int(r*e+0.5),cx+int(r*e+0.5)+1):
-                for y in range(cy-int(r/e+0.5),cy+int(r/e+0.5)+1):
-                    if not rect and (((x-cx)/e)**2+((y-cy)*e)**2) > r**2:
-                        continue
-                    self.clrw(x,y)
-
-    def grids(self, horizchance, vertchance):
-        """Generate a level with a grid of horizontal and vertical lines
-        0: gaussian chance of each horizontal line part
-        1: gaussian chance of each vertical line part
-        """
-        self.reset(fill=False)
-        xsize = choice([3,3,3,4,4,4,4,5,6])
-        ysize = choice([2,3,3,4,4,4,4,5])
-        xofs = choice([-1,0,1])
-        yofs = choice([-1,0,1])
-        for x in range((self.WIDTH//xsize)+1):
-            for y in range((self.HEIGHT//ysize)+1):
-                dx = x*xsize + xofs
-                dy = y*ysize + yofs
-                if gauss(0,1) > horizchance:
-                    for i in range(0,xsize+1):
-                        self.setw(dx+i,dy)
-                if gauss(0,1) > vertchance:
-                    for i in range(0,ysize+1):
-                        self.setw(dx,dy+i)
-
-    def pegs(self, pegchance, posadj, thick):
-        """Generate a level by putting pegs
-        0: gaussian level of a peg appearance
-        1: gaussian level of peg position adjustment
-        """
-        self.reset(fill=False)
-        xdist = choice([3,3,3,4,4,5]) # distance between pegs
-        ydist = choice([2,3,3,3,4,5]) # distance between pegs
-        if not thick:
-            xdist = xdist - randint(0,1)
-            ydist = ydist - randint(0,1)
-        xadj = randint(0,4) - 2
-        yadj = randint(0,4) - 2
-        for x in range(self.WIDTH // xdist):
-            for y in range(self.HEIGHT // ydist):
-                if gauss(0,1) > pegchance:
-                    dx = x * xdist + xadj
-                    dy = y * ydist + yadj
-                    if gauss(0,1) > posadj:
-                        dx = dx + randint(0,2) - 1
-                        dy = dy + randint(0,2) - 1
-                    self.setw(dx,dy)
-                    if thick:
-                        self.setw(dx+1,dy)
-                        self.setw(dx,dy+1)
-                        self.setw(dx+1,dy+1)
-
-    def mondrian(self, x1=2,y1=2,x2=-1,y2=-1, horiz=-1, mindepth=3):
-        """Generate a level that looks a bit like a Piet Mondrian painting, or
-        different sized rectangles stacked on top of each other.
-        0-3: the size of the area to be split
-        4: whether the first split is horizontal or vertical
-        5: minimum number of splits to do
-        """
-        if horiz == -1:
-            horiz = choice([0,1])
-        if x2 == -1:
-            x2 = self.WIDTH-2
-        if y2 == -1:
-            y2 = self.HEIGHT-2
-        if (abs(x2-x1) < 6) or (abs(y2-y1) < 5):
-            return
-        mindepth = mindepth - 1
-        if horiz == 1:
-            horiz = 0
-            dy = randint(y1+2,y2-2)
-            for dx in range(min(x1,x2),max(x1,x2)):
-                self.setw(dx,dy)
-            if (random() < 0.75) or (mindepth > 0):
-                self.mondrian(x1,y1,x2,dy, horiz, mindepth)
-            if (random() < 0.75) or (mindepth > 0):
-                self.mondrian(x1,dy,x2,y2, horiz, mindepth)
-        else:
-            horiz = 1
-            dx = randint(x1+3,x2-3)
-            for dy in range(min(y1,y2),max(y1,y2)):
-                self.setw(dx,dy)
-            if (random() < 0.75) or (mindepth > 0):
-                self.mondrian(x1,y1,dx,y2, horiz, mindepth)
-            if (random() < 0.75) or (mindepth > 0):
-                self.mondrian(dx,y1,x2,y2, horiz, mindepth)
-
-    def bouncers(self, length, diradj, rev):
-        """Generate a level using a down and left or right moving walker
-        0: how many steps does the walker take
-        1: gaussian level, how often to change moving from left to right
-        2: fill empty level with wall or reverse?
-        """
-        if rev == 0:
-            self.reset(fill=True)
-        else:
-            self.reset(fill=False)
-        x = randint(0,self.WIDTH-2)
-        y = randint(0,self.HEIGHT-2)
-        lorr = choice([1, -1])  # move left or right
-        for i in range(length):
-            if rev == 0:
-                self.clrw(x,y)
-                self.clrw(x+1,y)
-                self.clrw(x,y+1)
-                self.clrw(x+1,y+1)
-            else:
-                self.setw(x,y)
-                self.setw(x+1,y)
-            x = x + lorr
-            y = y + 1
-            if y > self.HEIGHT:
-                y = 0
-            if x > self.WIDTH - 2:
-                x = self.WIDTH - 2
-                lorr = -lorr
-            elif x < 0:
-                x = 0
-                lorr = -lorr
-            if gauss(0,1) > diradj:
-                lorr = -lorr
-
-
-    def walkers(self, length, minturn, maxturn, isbig):
-        """Generate a level with a walker
-        0: length of the walker: how many steps it walks
-        1: minimum length it walks straight, before turning
-        2: maximum length it walks straight, before turning
-        3: is the trail is 1 or 2 blocks high
-        """
-        # We start from a full wall
-        self.reset(fill=True)
-        x = randint(0,self.WIDTH-2)
-        y = randint(0,self.HEIGHT-2)
-        dir = randint(0,4)
-        dlen = 0
-        for i in range(length):
-            self.clrw(x,y)
-            self.clrw(x+1,y)
-            if isbig == 1:
-                self.clrw(x,y+1)
-                self.clrw(x+1,y+1)
-            dlen = dlen + 1
-            if dir == 0:
-                x = x - 2
-                if x < 0:
-                    x = self.WIDTH-2
-            elif dir == 1:
-                y = y - 1
-                if y < 0:
-                    y = self.HEIGHT
-            elif dir == 2:
-                x = x + 2
-                if x > (self.WIDTH - 2):
-                    x = 0
-            else:
-                y = y + 1
-                if y > self.HEIGHT:
-                    y = 0
-            if dlen > randint(minturn, maxturn):
-                # turn 90 degrees
-                dir = (dir + choice([1,3])) % 4
-                dlen = 0
-
-    def rivers(self, n_flow, side_threshold, side_shift):
-        """Generate flow paths by digging a big wall. The arguments are:
-        0: the number of parallel flow to dig in the wall
-        1: side_threshold is a gausian level for doing a step aside
-        2: side_shift is the maximal size of the side step.
-        """
-        # We start from a full wall
-        self.reset(fill=True)
-        for x in [0, self.WIDTH-2]+[randint(3,self.WIDTH-5) for f in range(max(0, n_flow-2))]:
-            for y in range(self.HEIGHT):
-                self.clrw(x,y)
-                self.clrw(x+1,y)
-                g = gauss(0,1)
-                if abs(g) > side_threshold:
-                    # We want to move aside, let's find which side is the best:
-                    if self.WIDTH//4 < x < 3*self.WIDTH//4:
-                        side = random() > 0.5
-                    t = random()
-                    if t > x*4/self.WIDTH:
-                        side = 1
-                    elif t > (self.WIDTH-x)*4/self.WIDTH:
-                        side = -1
-                    side_step = randint(1,side_shift)
-                    if side > 0:
-                        for i in range(x+2, min(x+2+side_step,self.WIDTH-1)):
-                            self.clrw(i,y)
-                        x = max(0,min(x+side_step, self.WIDTH-2))
-                    else:
-                        for i in range(max(x-side_step,0),x):
-                            self.clrw(i,y)
-                        x = max(x-side_step, 0)
-
-    def platforms_reg(self):
-        """Generate random platforms at regular y-intervals.
-        """
-        self.reset(fill=False)
-        yadjs = [-2,-1,0,0,0,0,0,0,0,0,1,2]
-        y = randint(2,4)
-        yinc = randint(2,6)
-        yincadj = choice(yadjs)
-        ymax = self.HEIGHT-choice([1,1,1,1,1,2,2,2,3,3,4])-1
-        while y < ymax:
-            holes = randint(choice([0,1,1,1,1]),7)
-            for x in range(0, self.WIDTH):
-                self.setw(x,y)
-            for i in range(holes):
-                x = randint(0, self.WIDTH-2)
-                self.clrw(x,y)
-                self.clrw(x+1,y)
-            y = y + yinc
-            yinc = yinc + yincadj
-            if yinc < 2:
-                yinc = 2
-                yincadj = choice(yadjs)
-            if yinc > 6:
-                yinc = 6
-                yincadj = choice(yadjs)
-
-    def startplatform(self):
-        "Make sure there's free space with wall underneath for dragon start positions"
-        hei = choice([1,1,1,2,2,3])
-        lft = choice([0,1])
-        wid = choice([3,3,3,4,5])
-        for x in range(lft, wid):
-            self.setw(x,self.HEIGHT-1)
-            self.setw(self.WIDTH-x-1,self.HEIGHT-1)
-            for y in range(hei+1):
-                self.clrw(x,self.HEIGHT-2-y)
-                self.clrw(self.WIDTH-x-1,self.HEIGHT-2-y)
-
-    def openstartway(self):
-        "Make sure there is a way from the starting position to the center of the level. Reduces player frustrations."
-        gen = choice([0,0,0,1])
-        if gen == 0: # horizontal open space to middle of level
-            ypos = choice([1,1,1,1,1,2,2,3,4,randint(1,self.HEIGHT//2)])
-            hei = choice([1,1,1,2])
-            for x in range(self.WIDTH//2):
-               for y in range(hei):
-                   self.clrw(x, self.HEIGHT-1-ypos-y)
-            ypos = choice([1,1,1,1,1,2,2,3,4,randint(1,self.HEIGHT//2)])
-            hei = choice([1,1,1,2])
-            for x in range(self.WIDTH//2):
-               for y in range(hei):
-                   self.clrw(self.WIDTH-x-1, self.HEIGHT-1-ypos-y)
-        elif gen == 1: # open way diagonally to NW or NS, third of a way to the level width
-            ypos = choice([1,1,1,1,1,2,2,3,4])
-            wid = choice([2,2,2,2,2,3,3,4])
-            for x in range(self.WIDTH//3):
-               for z in range(wid):
-                   self.clrw(x+z, self.HEIGHT-1-x-ypos)
-            ypos = choice([1,1,1,1,1,2,2,3,4])
-            wid = choice([2,2,2,2,2,3,3,4])
-            for x in range(self.WIDTH//2):
-               for z in range(wid):
-                   self.clrw(self.WIDTH-x-1-z, self.HEIGHT-1-x-ypos)
-
-    def close(self):
-        "Just close the level with floor and roof"
-        for x in range(self.WIDTH):
-            self.setw(x,0) 
-            self.setw(x,self.HEIGHT)
-
-    def largest_vertical_hole(self, x):
-        "Returns the (start, stop) of the largest range of holes in column x."
-        if not (0 <= x < self.WIDTH):
-            return (0, 0)
-        ranges = []
-        best = 0
-        length = 0
-        for y in range(self.HEIGHT+1):
-            if y < self.HEIGHT and self.getw(x,y) == ' ':
-                length += 1
-            elif length > 0:
-                if length > best:
-                    del ranges[:]
-                    best = length
-                if length == best:
-                    ranges.append((y-length, y))
-                length = 0
-        return choice(ranges or [(0, 0)])
-
-    def dig_vertical_walls(self):
-        "Check that no vertical wall spans the whole height of the level"
-        vwall = []
-        for x in range(self.WIDTH):
-            spaces = 0
-            for y in range(self.HEIGHT-1):   # ignore bottom line spaces
-                spaces += self.getw(x,y) == ' '
-            if spaces == 0 or (random() < 0.4**spaces):
-                vwall.append(x)
-        shuffle(vwall)
-        for x in vwall:
-            # look for the longest continuous space in each of the two
-            # adjacent columns, and extend these to the current column
-            def dig(y1, y2):
-                for y in range(y1, y2):
-                    self.clrw(x, y)
-                return y1 < y2 and y1 < self.HEIGHT-1
-            progress = False
-            for col in [x-1, x+1]:
-                y1, y2 = self.largest_vertical_hole(col)
-                progress |= dig(y1, y2)
-            while not progress:
-                progress |= dig(randint(0, self.HEIGHT-1),
-                                randint(0, self.HEIGHT-1))
-
-    def prevent_straight_fall(self):
-        """Make platforms that prevent falling straight from top to bottom, but
-        still leave space for moving.
-        """
-        falls = []
-        for x in range(self.WIDTH):
-            for y in range(self.HEIGHT):
-                if self.getw(x,y) == '#':
-                    break
-            else:
-                falls = falls + [x]
-        y = oldy = -10
-        for x in falls:
-            while (y < oldy+2) and (y > oldy-2):
-                y = randint(2, self.HEIGHT-2)
-            for dy in range(y-1,y+2):
-                for dx in range(x-3, x+4):
-                    self.clrw(dx,dy)
-            self.setw(x-1,y)
-            self.setw(x+1,y)
-            self.setw(x,y)
-            oldy = y
-
-    def do_monsters(self):
-        """Create monsters based on the requested settings.
-        mlist is a list of monster setting. Each item is a tuple with:
-        0: the list of monster to uses (each item might be a tuple)
-        1: the rng for the number of monsters to pick in the list.
-        """
-        current = 'a'
-        for ms in self.mlist:
-            n_monsters = ms[1]()
-            for idx in range(n_monsters):
-                setattr(self,current,choice(ms[0]))
-                # self.__class__.__dict__[current] = choice(ms[0])
-                ntry = self.MAXTRY
-                while ntry:
-                    x = randint(0,self.WIDTH-2)
-                    y = randint(0,self.HEIGHT-1)
-
-                    if self.getw(x,y) == self.getw(x+1,y) == ' ':
-                        self.wmap[y][x] = current
-                        break
-                    ntry -= 1
-                current = chr(ord(current)+1)
-
-    def do_walls(self):
-        "Build the actual walls map for the game."
-        self.__class__.walls = ''
-        for y in range(self.HEIGHT-1):
-            self.__class__.walls += '##'
-            for x in range(self.WIDTH):
-                self.__class__.walls += self.wmap[y][x]
-            self.__class__.walls += '##\n'
-        self.__class__.walls += '##'
-        for x in range(self.WIDTH):
-            if self.getw(x,0) == '#' or self.getw(x,self.HEIGHT-1) == '#':
-                self.__class__.walls += '#'
-            else:
-                self.__class__.walls += ' '
-        self.__class__.walls += '##\n'
-
-    def do_winds(self):
-        "Build the actual wind map for the game."
-        self.__class__.winds = ''
-        for y in range(self.HEIGHT):
-            self.__class__.winds += '>>'
-            for x in range(self.WIDTH):
-                self.__class__.winds += self.windmap[y][x]
-            self.__class__.winds += '<<' + '\n'
-
-    def do_bonuses(self):
-        self.__class__.letter    = choice([0,1])
-        self.__class__.fire      = choice([0,1])
-        self.__class__.lightning = choice([0,1])
-        self.__class__.water     = choice([0,1])
-        self.__class__.top       = choice([0,1])
-
-    def generate(self):
-        "Generate random level settings."
-        assert 0, "--- THIS IS NO LONGER REALLY USED ---"
-        self.mlist = [([
-            LNasty, LMonky, LGhosty, LFlappy, LSpringy, LOrcy, LGramy, LBlitzy,
-            RNasty, RMonky, RGhosty, RFlappy, RSpringy, ROrcy, RGramy, RBlitzy,
-            ],lambda : flat(12,4))]
-        gens = choice([512,512,256,256,128,128,64,64,32,32,16,16,16,16,16,16,20,20,8,8,8,8,4,4,4,4,2,2,2,2,1,1,3,5,6,7])
-        self.genwalls = []
-        if gens & 512:
-            print('Using grids generator')
-            self.genwalls.append((RandomLevel.grids,
-                                  uniform(0.0, 0.1),
-                                  uniform(0.0, 0.1)))
-        if gens & 256:
-            # generate using pegs
-            print('Using the pegs generator')
-            self.genwalls.append((RandomLevel.pegs,
-                                  uniform(0.1,0.2),
-                                  uniform(0.45,0.7),
-                                  choice([0,1,1,1])))
-        if gens & 128:
-            # generate using a bouncer
-            nr = choice([0,0,1])
-            print('Using the bouncer generator')
-            self.genwalls.append((RandomLevel.bouncers,
-                                 dice(1, 100) + 250 - nr*200, # length
-                                 uniform(0.7, 1.7),
-                                 nr))
-        if gens & 64:
-            # generate using a walker
-            print('Using the walker generator')
-            nr = dice(1, 3) + 2
-            self.genwalls.append((RandomLevel.walkers,
-                                 dice(2, 100) + 100, # length
-                                 nr, nr + dice(2, 3), # straight walk min, max len
-                                 choice([0,1])))
-        if gens & 32:
-            # generate rivers
-            print('Using the rivers generator')
-            self.genwalls.append((RandomLevel.rivers,
-                                  randrange(2,(self.WIDTH-4)/5),    # the number of rivers
-                                  uniform(0.7, 1.7), # the side stepping threshold
-                                  6))                # the max side stepping size
-        if gens & 16:
-            # generate rooms
-            print('Using the romms generator')
-            nr = choice([1,2,2,2,3,3,4,5])
-            self.genwalls.append((RandomLevel.rooms,
-                                  lambda : flat(9-nr,2),    # the half size of the room
-                                  lambda : uniform(0.8,1.2), # the excentricity of the room
-                                  nr))                       # the number of rooms
-        if gens & 8:
-            # generate a holes generator
-            # as this is interesting only if the level is filled somehow
-            print('Using the holes generator')
-            self.genwalls.append((RandomLevel.mess,1-uniform(0.2,0.5)))
-            nh = choice([1,1,2,2,2,3,3,3,4,5])
-            self.genwalls.append((RandomLevel.holes,
-                                  lambda : flat(9-nh,2),       # radius of the holes
-                                  lambda : uniform(0.9,1.1),   # excentricity
-                                  nh,                          # number of holes
-                                  lambda : choice([0,0,0,1]))) # circle or rectangle
-        if gens & 4:
-            # generate a lines generator
-            print('Using the lines generator')
-            self.genwalls.append((RandomLevel.lines,
-                                  lambda : dice(7,3), # line length
-                                  dice(2,3)))         # number of lines
-        if gens & 2:
-            # generate a platforms generator
-            print('Using the platforms generator')
-            nplat  = dice(2,4,0)
-            if nplat: space  = flat((self.HEIGHT-1)/nplat/2,(self.HEIGHT-1)/nplat/2-1)
-            else:     space = 1
-            nholes = lambda : dice(1,3,0)          
-            wholes = lambda : dice(2,3)
-            full = randrange(2)
-            self.genwalls.append((RandomLevel.platforms,
-                                  (nplat,space),   # number of platform and spacing
-                                  (nholes,wholes), # number of holes and width
-                                  full))           # full width platform
-        if gens & 1:
-            # generate a mess generator
-            print('Using the mess generator')
-            if gens & ~2:
-                offset = 0
-                scale = 0.05
-            else:
-                offset = 0.05
-                scale = 0.10
-            self.genwalls.append((RandomLevel.mess,offset+random()*scale))
-        if random() < 0.2:
-            self.genwalls.append((RandomLevel.close,))
-        if random() < 0.90:
-            self.genwalls.append((RandomLevel.startplatform,))
-        self.genwalls.append((RandomLevel.generate_wind, ))
-
-
-Levels = []
-for i in range(25):
-    class level(RandomLevel):
-        auto = 1
-    Levels.append(level)
-
-class levelfinal(RandomLevel):
-    genwalls = [(RandomLevel.platforms,(4,3),(lambda:flat(1,1),lambda:flat(4,2)),1)]
-Levels.append(levelfinal)