/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

}