/ld26

-- Class: Group

-- A group is a set of sprites. Groups can be used to

-- implement layers or keep categories of sprites together.

--

-- Extends:

--              <Class>

--

-- Event: onUpdate

-- Called once each frame, with the elapsed time since the last frame in seconds.

--

-- Event: onBeginFrame

-- Called once each frame like onUpdate, but guaranteed to fire before any others' onUpdate handlers.

--

-- Event: onEndFrame

-- Called once each frame like onUpdate, but guaranteed to fire after all others' onUpdate handlers.

 

Group = Class:extend

{

        -- Property: active

        -- If false, none of its member sprites will receive update-related events.

        active = true,

 

        -- Property: visible

        -- If false, none of its member sprites will be drawn.

        visible = true,

 

        -- Property: solid

        -- If false, nothing will collide against this group, nor will this group

        -- displace any other sprite. This does not prevent collision checking

        -- against individual sprites in this group, however.

        solid = true,

 

        -- Property: sprites

        -- A table of member sprites, in drawing order.

        sprites = {},

 

        -- Property: timeScale

        -- Multiplier for elapsed time; 1.0 is normal, 0 is completely frozen.

        timeScale = 1,

 

        -- Property: translate

        -- This table's x and y properties shift member sprites' positions when drawn.

        -- To draw sprites at their normal position, set both x and y to 0.

        translate = { x = 0, y = 0 },

        

        -- Property: translateScale

        -- This table's x and y properties multiply member sprites'

        -- positions, which you can use to simulate parallax scrolling. To draw

        -- sprites at their normal position, set both x and y to 1.

        translateScale = { x = 1, y = 1 },

 

        -- Method: add

        -- Adds a sprite to the group.

        --

        -- Arguments:

        --              sprite - <Sprite> to add

        --

        -- Returns:

        --              nothing

 

        add = function (self, sprite)

                assert(sprite, 'asked to add nil to a group')

                assert(sprite ~= self, "can't add a group to itself")

        

                if STRICT and self:contains(sprite) then

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

                        print('Warning: adding a sprite to a group it already belongs to (' ..

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

                end

 

                table.insert(self.sprites, sprite)

        end,

 

        -- Method: remove

        -- Removes a sprite from the group. If the sprite is

        -- not in the group, this does nothing.

        -- 

        -- Arguments:

        --              sprite - <Sprite> to remove

        -- 

        -- Returns:

        --              nothing

 

        remove = function (self, sprite)

                for i, spr in ipairs(self.sprites) do

                        if spr == sprite then

                                table.remove(self.sprites, i)

                                return

                        end

                end

                

                if STRICT then

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

                        print('Warning: asked to remove a sprite from a group it was not a member of (' ..

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

                end

        end,

 

        -- Method: moveToFront

        -- Moves a sprite in the group so that it is drawn on top

        -- of all other sprites in the group.

        --

        -- Arguments:

        --              sprite - <Sprite> to move, should already be a member of the group

        --

        -- Returns:

        --              nothing

 

        moveToFront = function (self, sprite)

                for i, spr in ipairs(self.sprites) do

                        if spr == sprite then

                                table.remove(self.sprites, i)

                                table.insert(self.sprites, sprite)

                                return

                        end

                end

 

                if STRICT then

                        print('Warning: asked to move sprite to front of group, but is not a member: ' .. sprite)

                end

        end,

 

        -- Method: moveToBack

        -- Moves a sprite in the group so that it is drawn below

        -- all other sprites in the group.

        --

        -- Arguments:

        --              sprite - <Sprite> to move, should already be a member of the group

        --

        -- Returns:

        --              nothing

        

        moveToBack = function (self, sprite)

                for i, spr in ipairs(self.sprites) do

                        if spr == sprite then

                                table.remove(self.sprites, i)

                                table.insert(self.sprites, 1, sprite)

                                return

                        end

                end

 

                if STRICT then

                        print('Asked to move sprite to back of group, but is not a member: ' .. sprite)

                end

        end,

 

        -- Method: sort

        -- Sorts members into a new draw sequence.

        --

        -- Arguments:

        --              func - function to perform the sort. This will receive two <Sprite>s as arguments;

        --                         the function must return whether the first should be drawn below the second.

        --

        -- Returns:

        --              nothing

 

        sort = function (self, func)

                table.sort(self.sprites, func)

        end,

 

        -- Method: collide

        -- Collides all solid sprites in the group with another sprite or group.

        -- This calls the <Sprite.onCollide> event handlers on all sprites that

        -- collide with the same arguments <Sprite.collide> does.

        --

        -- It's often useful to collide a group with itself, e.g. myGroup:collide().

        -- This checks for collisions between the sprites that make up the group.

        --

        -- Arguments:

        --              ... - any number of <Sprite>s or <Group>s to collide with. If none

        --                        are specified, the group collides with itself.

        -- 

        -- Returns:

        --              nothing

        --

        -- See Also:

        --              <Sprite.collide>

 

        collide = function (self, ...)

                local list = {...}

 

                if #list > 0 then

                        if STRICT then

                                for _, other in pairs(list) do

                                        assert(other:instanceOf(Group) or other:instanceOf(Sprite), 'asked to collide non-group/sprite ' ..

                                                   type(other))

                                end

                        end

 

                        Collision:check(self, ...)

                else

                        Collision:check(self, self)

                end

        end,

 

        -- Method: setEffect

        -- Sets a pixel effect to use while drawing sprites in this group.

        -- See https://love2d.org/wiki/PixelEffect for details on how pixel

        -- effects work. After this call, the group's effect property will be

        -- set up so you can send variables to it. Only one pixel effect can

        -- be active on a group at a time.

        --

        -- Arguments:

        --              filename - filename of effect source code; if nil, this

        --                                 clears any existing pixel effect.

        --              effectType - either 'screen' (applies the effect to the entire

        --                                       group once, via an offscreen canvas), or 'sprite'

        --                                       (applies to the effect to each individual draw operation).

        --                                       Screen effects use more resources, but certain effects

        --                                       need to work on the entire screen to be effective.

        --

        -- Returns:

        --              whether the effect was successfully created

 

        setEffect = function (self, filename, effectType)

                effectType = effectType or 'screen'

 

                if love.graphics.isSupported('pixeleffect') and

                   (effectType == 'sprite' or love.graphics.isSupported('canvas'))then

                        if filename then

                                self.effect = love.graphics.newPixelEffect(Cached:text(filename))

                                self.effectType = effectType

                        else

                                self.effect = nil

                        end

 

                        return true

                else

                        return false

                end

        end,

 

        -- Method: count

        -- Counts how many sprites are in this group.

        -- 

        -- Arguments:

        --              subgroups - include subgroups?

        -- 

        -- Returns:

        --              integer count

 

        count = function (self, subgroups)

                if subgroups then

                        local count = 0

 

                        for _, spr in pairs(self.sprites) do

                                if spr:instanceOf(Group) then

                                        count = count + spr:count(true)

                                else

                                        count = count + 1

                                end

                        end

 

                        return count

                else

                        return #self.sprites

                end

        end,

 

        -- Method: die

        -- Makes the group totally inert. It will not receive

        -- update events, draw anything, or be collided.

        --

        -- Arguments:

        --              none

        --

        -- Returns:

        --              nothing

 

        die = function (self)

                self.active = false

                self.visible = false

                self.solid = false

        end,

 

        -- Method: revive

        -- Makes this group completely active. It will receive

        -- update events, draw itself, and be collided.

        --

        -- Arguments:

        --              none

        --

        -- Returns:

        --              nothing

 

        revive = function (self)

                self.active = true

                self.visible = true

                self.solid = true

        end,

 

        -- Method: contains

        -- Returns whether this group contains a sprite.

        --

        -- Arguments:

        --              sprite - sprite to look for

        --              recurse - check subgroups? defaults to true

        --

        -- Returns:

        --              boolean

 

        contains = function (self, sprite, recurse)

                if recurse ~= false then recurse = true end

 

                for _, spr in pairs(self.sprites) do

                        if spr == sprite then return true end

 

                        if recurse and spr:instanceOf(Group) and spr:contains(sprite) then

                                return true

                        end

                end

 

                return false

        end,

 

        -- Method: loadLayers

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

        -- Each layer is created as a <Group> belonging to this one 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

        --              tileClass - class to create tiles in tile layers with; constructor

        --                                  will be called with properties: image, width,

        --                                  height, imageOffset (with x and y sub-properties)

        --

        -- Returns:

        --              nothing

 

        loadLayers = function (self, file, tileClass)

                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 self.prototype[layer.name] then

                                        error('The class you are loading layers into 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 this group (' ..

                                                  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, tileClass or 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 layers from file: ' .. data)

                end

        end,

 

        -- passes startFrame events to member sprites

 

        startFrame = function (self, elapsed)

                if not self.active then return end

                elapsed = elapsed * self.timeScale

                

                for _, spr in pairs(self.sprites) do

                        if spr.active then spr:startFrame(elapsed) end

                end

 

                if self.onStartFrame then self:onStartFrame(elapsed) end

        end,

 

        -- passes update events to member sprites

 

        update = function (self, elapsed)

                if not self.active then return end

                elapsed = elapsed * self.timeScale

 

                for _, spr in pairs(self.sprites) do

                        if spr.active then spr:update(elapsed) end

                end

 

                if self.onUpdate then self:onUpdate(elapsed) end

        end,

 

        -- passes endFrame events to member sprites

 

        endFrame = function (self, elapsed)

                if not self.active then return end

                elapsed = elapsed * self.timeScale

 

                for _, spr in pairs(self.sprites) do

                        if spr.active then spr:endFrame(elapsed) end

                end

 

                if self.onEndFrame then self:onEndFrame(elapsed) end

        end,

 

        -- Method: draw

        -- Draws all visible member sprites onscreen.

        --

        -- Arguments:

        --              x - x offset in pixels

        --              y - y offset in pixels

 

        draw = function (self, x, y)

                if not self.visible then return end

                x = x or self.translate.x

                y = y or self.translate.y

                

                local scrollX = x * self.translateScale.x

                local scrollY = y * self.translateScale.y

                local appWidth = the.app.width

                local appHeight = the.app.height

 

                if self.effect then

                        if self.effectType == 'screen' then

                                if not self._canvas then self._canvas = love.graphics.newCanvas() end

                                self._canvas:clear()

                                love.graphics.setCanvas(self._canvas)

                        elseif self.effectType == 'sprite' then

                                love.graphics.setPixelEffect(self.effect)

                        end

                end

                

                for _, spr in pairs(self.sprites) do    

                        if spr.visible then

                                if spr.translate then

                                        spr:draw(spr.translate.x + scrollX, spr.translate.y + scrollY)

                                elseif spr.x and spr.y and spr.width and spr.height then

                                        local sprX = spr.x + scrollX

                                        local sprY = spr.y + scrollY

 

                                        if sprX < appWidth and sprX + spr.width > 0 and

                                           sprY < appHeight and sprY + spr.height > 0 then

                                                spr:draw(sprX, sprY)

                                        end

                                else

                                        spr:draw(scrollX, scrollY)

                                end

                        end

                end

                        

                if self.effect then

                        if self.effectType == 'screen' then

                                love.graphics.setPixelEffect(self.effect)

                                love.graphics.setCanvas()

                                love.graphics.draw(self._canvas)

                        end

 

                        love.graphics.setPixelEffect()

                end

        end,

 

        __tostring = function (self)

                local result = 'Group ('

 

                if self.active then

                        result = result .. 'active'

                else

                        result = result .. 'inactive'

                end

 

                if self.visible then

                        result = result .. ', visible'

                else

                        result = result .. ', invisible'

                end

 

                if self.solid then

                        result = result .. ', solid'

                else

                        result = result .. ', not solid'

                end

 

                return result .. ', ' .. self:count(true) .. ' sprites)'

        end

}