Fish Fillets - Next Generation Code-ff2lua

import Room
import Item

class FFParser:
    MAXPARAMETER = 10
    def __init__(self, fp):
        self.fp = fp

    #-----------------------------------------------------------------
    def storeLine(self, dic, name):
        """ Store line without \r\n
        """
        param = self.fp.readline()[:-1]
        if param[-1] == chr(0x0d):
            param = param[:-1]
        dic[name] = param
        #print name, '=', param
    #-----------------------------------------------------------------
    def storeParam(self, dic, name):
        param = self.fp.readline().split()[0]
        dic[name] = param
        #print name, '=', param
    #-----------------------------------------------------------------
    def storeList(self, dic, name, max):
        params = self.fp.readline().split()[:max]
        dic[name] = params
        #print name, '=', params

    #-----------------------------------------------------------------
    def storeXYArray(self, dic, name, size):
        """ Store array of [x,y] records
        """
        params = []
        while len(params) < size:
            for word in self.fp.readline().split():
                x = int(word) & 0x00ff
                y = (int(word) & 0xff00) // 0xff
                params.append([x, y])

        dic[name] = params

        if size != len(params):
            print "WARNING: len", size, '!=', len(params)
        #print name, '=', len(params), 'XY elements'
        #print createShape(params)

    #-----------------------------------------------------------------
    def storeLines(self, dic, name, size):
        lines = "" 
        for unused in xrange(size):
            lines += self.fp.readline()

        dic[name] = lines
        #print name, '=', lines.count('\n'), 'lines,', len(lines), 'chars'

    #-----------------------------------------------------------------
    def readItem(self):
        item = {}
        self.storeList(item, 'x_y_w_h', 4)
        self.storeLine(item, 'filename')
        self.storeParam(item, 'maskcolor')
        self.storeParam(item, 'kind')
        self.storeParam(item, 'extsize')
        self.storeParam(item, 'init_len')
        self.storeLines(item, 'init_prog', int(item['init_len']))
        self.storeParam(item, 'update_len')
        self.storeLines(item, 'update_prog', int(item['update_len']))
        self.storeParam(item, 'listlen')
        self.storeXYArray(item, 'list', int(item['listlen']))
        return item
    #-----------------------------------------------------------------
    def storeItems(self, room_dic, name, size,
            small_look_dir, big_look_dir):
        items = []
        for unused in xrange(size):
            #print "---------------------------------- item ", i , "---"
            item_dic = self.readItem()

            x = item_dic['x_y_w_h'][0]
            y = item_dic['x_y_w_h'][1]
            varname = None
            look_dir = Item.LOOK_LEFT
            if Item.KIND_SMALL == int(item_dic['kind']):
                varname = "small"
                look_dir = int(small_look_dir)
            elif Item.KIND_BIG == int(item_dic['kind']):
                varname = "big"
                look_dir = int(big_look_dir)

            item = Item.Item(int(item_dic['kind']), x, y,
                item_dic['filename'], item_dic['extsize'],
                createShape(item_dic['list']),
                item_dic['init_prog'], item_dic['update_prog'],
                varname, look_dir)
            items.append(item)
        #print "-------------------------------------------------"

        room_dic[name] = items
        #print name, '=', len(items), 'items'

    #-----------------------------------------------------------------
    def parseLevel(self):
        """ Return decoded room.
        """
        room = {}

        # REDIT FILE from `date`
        self.fp.readline()

        self.storeLine(room, 'name')
        self.storeLine(room, 'description')
        self.storeList(room, 'params', self.MAXPARAMETER)
        self.storeParam(room, 'gridcolor')
        self.storeList(room, 'w_h', 2)

        self.storeLine(room, 'bg_filename')
        # 0 obsolete
        self.fp.readline()
        self.storeParam(room, 'bg_extsize')

        self.storeLine(room, 'wall_filename')
        self.storeParam(room, 'wall_maskcolor')
        self.storeParam(room, 'wall_extsize')
        self.storeParam(room, 'wall_listlen')
        self.storeXYArray(room, 'wall_list', int(room['wall_listlen']))
        self.storeParam(room, 'wall_init_len')
        self.storeLines(room, 'wall_init_prog', int(room['wall_init_len']))
        self.storeParam(room, 'wall_update_len')
        self.storeLines(room, 'wall_update_prog', int(room['wall_update_len']))

        self.storeParam(room, 'items_len')

        small_look_dir = room['params'][0]
        big_look_dir = room['params'][1]
        self.storeItems(room, 'items_array', int(room['items_len']),
                small_look_dir, big_look_dir)

        # EOF
        self.fp.readline()

        w = room['w_h'][0]
        h = room['w_h'][1]
        level = Room.Room(w, h, room['bg_filename'])

        wamp = room['params'][2]
        wper = room['params'][3]
        wspd = room['params'][4]
        level.setWaves(wamp, wper, wspd)

        wall = Item.Item(0, 0, 0,
            room['wall_filename'], room['wall_extsize'],
            createShape(room['wall_list']),
            room['wall_init_prog'],
            room['wall_update_prog'], "room")
        level.addItem(wall)

        for item in room['items_array']:
            level.addItem(item)

        return level


#-----------------------------------------------------------------
def createShape(xy_array):
    """ Create shape, e.g. [[0,0], [1,0], [2,0]] -> 'XXX\n'
    """
    width = max(xy_array)[0] + 1
    shape = []
    line_counter = 0
    for x, y in xy_array:
        while line_counter <= y:
            line_counter += 1
            shape += list('.' * width + '\n')
        shape[x + y * (width + 1)] = 'X'
    #NOTE: convert from list to string
    return "".join(shape)