/zoeplat

View = Group:extend{

        -- Method: loadLayers

        -- Loads layers from a Lua source file (as generated by Tiled -- http://mapeditor.org).

        -- Each layer is created as a <Group> and added to preserve its ordering. Tile layers

        -- are created as <Map> instances; object layers will try to create instances of a class

        -- named by the object's name property. If no class exists by this name, or the object

        -- has no name property, a gray fill will be created instead, as a placeholder. If the

        -- object has a property named _the, then this will set the.[whatever] to it.

        --

        -- Arguments:

        --              file - filename to load

        --

        -- Returns:

        --              nothing

 

        loadLayers = function (self, file)

                local ok, data = pcall(loadstring(Cached:text(file)))

                local _, _, directory = string.find(file, '^(.*[/\\])')

                directory = directory or ''

 

                if ok then

                        -- store tile properties by gid

                        

                        local tileProtos = {}

 

                        for _, tileset in pairs(data.tilesets) do

                                for _, tile in pairs(tileset.tiles) do

                                        local id = tileset.firstgid + tile.id

                                        

                                        for key, value in pairs(tile.properties) do

                                                tile.properties[key] = tovalue(value)

                                        end

 

                                        tileProtos[id] = tile

                                        tileProtos[id].width = tileset.tilewidth

                                        tileProtos[id].height = tileset.tileheight

                                end

                        end

 

                        for _, layer in pairs(data.layers) do

                                if View[layer.name] then

                                        error('the View class reserves the ' .. layer.name .. ' property for its own use; you cannot load a layer with that name')

                                end

 

                                if STRICT and self[layer.name] then

                                        local info = debug.getinfo(2, 'Sl')

                                        print('Warning: a property named ' .. layer.name .. ' already exists in the current view (' ..

                                                  info.short_src .. ', line ' .. info.currentline .. ')')

                                end

 

                                if layer.type == 'tilelayer' then

                                        local map = Map:new{ spriteWidth = data.tilewidth, spriteHeight = data.tileheight }

                                        map:empty(layer.width, layer.height)

 

                                        -- load tiles

 

                                        for _, tiles in pairs(data.tilesets) do

                                                map:loadTiles(directory .. tiles.image, Tile, tiles.firstgid)

 

                                                -- and mix in properties where applicable

 

                                                for id, tile in pairs(tileProtos) do

                                                        if map.sprites[id] then

                                                                map.sprites[id]:mixin(tile.properties)

                                                        end

                                                end

                                        end

 

                                        -- load tile data

 

                                        local x = 1

                                        local y = 1

 

                                        for _, val in ipairs(layer.data) do

                                                map.map[x][y] = val

                                                x = x + 1

 

                                                if x > layer.width then

                                                        x = 1

                                                        y = y + 1

                                                end

                                        end

 

                                        self[layer.name] = map

                                        self:add(map)

                                elseif layer.type == 'objectgroup' then

                                        local group = Group:new()

 

                                        for _, obj in pairs(layer.objects) do

                                                -- roll in tile properties if based on a tile

 

                                                if obj.gid and tileProtos[obj.gid] then

                                                        local tile = tileProtos[obj.gid]

 

                                                        obj.name = tile.properties.name

                                                        obj.width = tile.width

                                                        obj.height = tile.height

 

                                                        for key, value in pairs(tile.properties) do

                                                                obj.properties[key] = tovalue(value)

                                                        end

 

                                                        -- Tiled tile-based objects measure their y

                                                        -- position at their lower-left corner, instead

                                                        -- of their upper-left corner as usual

 

                                                        obj.y = obj.y - obj.height

                                                end

 

                                                -- create a new object if the class does exist

 

                                                local spr

 

                                                if _G[obj.name] then

                                                        obj.properties.x = obj.x

                                                        obj.properties.y = obj.y

                                                        obj.properties.width = obj.width

                                                        obj.properties.height = obj.height

 

                                                        spr = _G[obj.name]:new(obj.properties)

                                                else

                                                        spr = Fill:new{ x = obj.x, y = obj.y, width = obj.width, height = obj.height, fill = { 128, 128, 128 } }

                                                end

 

                                                if obj.properties._the then

                                                        the[obj.properties._the] = spr

                                                end

 

                                                group:add(spr)

                                        end

 

                                        self[layer.name] = group

                                        self:add(group)

                                else

                                        error("don't know how to create a " .. layer.type .. " layer from file data")

                                end

                        end

                else

                        error('could not load view data from file: ' .. data)

                end

        end,

 

 

                -- let sprites update their physics before adjusting focus

                Group.update(self, elapsed)

 

                -- follow the focused sprite

 

                --Group.update(self, elapsed)