/zoeplat

-- 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: onDraw
-- Called after all member sprites are drawn onscreen.
--
-- 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 },

	-- Property: gridSize
	-- The size, in pixels, of the grid used for collision detection.
	-- This partitions off space so that collision checks only need to do real
	-- checks against a few sprites at a time. If you notice collision detection
	-- taking a long time, changing this number may help.
	gridSize = 50,

	-- 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: 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:
	-- 		other - <Sprite> or <Group> to collide with, default self
	-- 
	-- Returns:
	--		boolean, whether any collision was detected
	--
	-- See Also:
	--		<Sprite.collide>

	collide = function (self, other)
		other = other or self

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

		if not self.solid or not other.solid then return false end
		local hit = false

		if other.sprites then
			local grid = self:grid()
			local gridSize = self.gridSize

			for _, othSpr in pairs(other.sprites) do
				local startX = math.floor(othSpr.x / gridSize)
				local endX = math.floor((othSpr.x + othSpr.width) / gridSize)
				local startY = math.floor(othSpr.y / gridSize)
				local endY = math.floor((othSpr.y + othSpr.height) / gridSize)

				for x = startX, endX do
					if grid[x] then
						for y = startY, endY do
							if grid[x][y] then
								for _, spr in pairs(grid[x][y]) do
									hit = spr:collide(othSpr) or hit
								end
							end
						end
					end
				end
			end
		else
			for _, spr in pairs(self.sprites) do
				hit = spr:collide(other) or hit
			end
		end

		return hit
	end,

	-- Method: displace
	-- Displaces a sprite or group by all solid sprites in this group. This will *not* cause
	-- any onCollide event handlers to be called.
	--
	-- Arguments:
	-- 		other - <Sprite> or <Group> to collide with, default self
	-- 		xHint - force horizontal displacement in one direction, uses direction constants, optional
	--		yHint - force vertical displacement in one direction, uses direction constants, optional
	-- 
	-- Returns:
	--		nothing
	--
	-- See Also:
	--		<Sprite.displace>

	displace = function (self, other, xHint, yHint)
		other = other or self

		if STRICT then
			assert(other:instanceOf(Group) or other:instanceOf(Sprite), 'asked to displace non-group/sprite ' ..
				   type(other))
		end

		if not self.solid or not other.solid then return false end

		if other.sprites then
			-- group displacing group

			local grid = self:grid()
			local gridSize = self.gridSize

			for _, othSpr in pairs(other.sprites) do
				local startX = math.floor(othSpr.x / gridSize)
				local endX = math.floor((othSpr.x + othSpr.width) / gridSize)
				local startY = math.floor(othSpr.y / gridSize)
				local endY = math.floor((othSpr.y + othSpr.height) / gridSize)
				local displacers = {}

				for x = startX, endX do
					if grid[x] then
						for y = startY, endY do
							if grid[x][y] then
								for _, spr in pairs(grid[x][y]) do
									if spr ~= othSpr and spr.solid and spr:intersects(othSpr.x, othSpr.y, othSpr.width, othSpr.height) then
										table.insert(displacers, spr)
									end
								end
							end
						end
					end
				end

				-- see Map:subdisplace() for how this is done

				if #displacers > 0 then
					local hit = true
					local loops = 0

					while hit and loops < 3 do
						hit = false
						loops = loops + 1

						local xVotes, yVotes = 0, 0
						local minChangeX, minChangeY, absMinChangeX, absMinChangeY
						local origX, origY = othSpr.x, othSpr.y

						for _, spr in pairs(displacers) do
							spr:displace(othSpr)
							local xChange = othSpr.x - origX
							local yChange = othSpr.y - origY

							if xChange ~= 0 then
								xVotes = xVotes + math.abs(xChange)
								hit = true

								if not minChangeX or math.abs(xChange) < absMinChangeX then
									minChangeX = xChange
									absMinChangeX = math.abs(xChange)
								end
							end

							if yChange ~= 0 then
								yVotes = yVotes + math.abs(yChange)
								hit = true

								if not minChangeY or math.abs(yChange) < absMinChangeY then
									minChangeY = yChange
									absMinChangeY = math.abs(yChange)
								end
							end

							-- restore sprite to original position

							othSpr.x = origX
							othSpr.y = origY
						end

						if hit then
							if xVotes > 0 and xVotes > yVotes then
								othSpr.x = othSpr.x + minChangeX
							elseif yVotes > 0 then
								othSpr.y = othSpr.y + minChangeY
							end
						end
					end
				end
			end
		else
			-- group displacing sprite

			local displacers = {}

			for _, spr in pairs(self.sprites) do
				if spr ~= other and spr:intersects(other.x, other.y, other.width, other.height) then
					table.insert(displacers, spr)
				end
			end

			-- see Map:subdisplace() for how this is done

			if #displacers > 0 then
				local hit = true
				local loops = 0

				while hit and loops < 3 do
					hit = false
					loops = loops + 1

					local xVotes, yVotes = 0, 0
					local minChangeX, minChangeY, absMinChangeX, absMinChangeY
					local origX, origY = other.x, other.y

					for _, spr in pairs(displacers) do
						spr:displace(other)
						local xChange = other.x - origX
						local yChange = other.y - origY

						if xChange ~= 0 then
							xVotes = xVotes + math.abs(xChange)
							hit = true

							if not minChangeX or math.abs(xChange) < absMinChangeX then
								minChangeX = xChange
								absMinChangeX = math.abs(xChange)
							end
						end

						if yChange ~= 0 then
							yVotes = yVotes + math.abs(yChange)
							hit = true

							if not minChangeY or math.abs(yChange) < absMinChangeY then
								minChangeY = yChange
								absMinChangeY = math.abs(yChange)
							end
						end

						-- restore sprite to original position

						other.x = origX
						other.y = origY
					end

					if hit then
						if xVotes > 0 and xVotes > yVotes then
							other.x = other.x + minChangeX
						elseif yVotes > 0 then
							other.y = other.y + minChangeY
						end
					end
				end
			end
		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: grid
	-- Creates a table indexed by x and y dimensions, with each
	-- cell a table of sprites that touch this grid element. For
	-- example, with a grid size of 50, a sprite at (10, 10) that 
	-- is 50 pixels square would be in the grid at [0][0], [1][0],
	-- [0][1], and [1][1].
	--
	-- This can be used to speed up work that involves checking
	-- for sprites near each other, e.g. collision detection.
	--
	-- Arguments:
	--		existing - existing grid table to add sprites into,
	--				   optional. Anything you pass must have
	--				   used the same size as the current call.
	--
	-- Returns:
	--		table

	grid = function (self, existing)
		local result = existing or {}
		local size = self.gridSize

		for _, spr in pairs(self.sprites) do
			if spr.sprites then
				local oldSize = spr.gridSize
				spr.gridSize = self.gridSize
				result = spr:grid(result)
				spr.gridSize = oldSize
			else
				local startX = math.floor(spr.x / size)
				local endX = math.floor((spr.x + spr.width) / size)
				local startY = math.floor(spr.y / size)
				local endY = math.floor((spr.y + spr.height) / size)

				for x = startX, endX do
					if not result[x] then result[x] = {} end

					for y = startY, endY do
						if not result[x][y] then result[x][y] = {} end
						table.insert(result[x][y], spr)
					end
				end
			end
		end

		return result
	end,

	-- passes startFrame events to member sprites

	startFrame = function (self, elapsed)
		if not self.active then return end
		elapsed = elapsed * self.timeScale
		if self.onStartFrame then self:onStartFrame(elapsed) end
		
		for _, spr in pairs(self.sprites) do
			if spr.active then spr:startFrame(elapsed) end
		end
	end,

	-- passes update events to member sprites

	update = function (self, elapsed)
		if not self.active then return end
		elapsed = elapsed * self.timeScale
		if self.onUpdate then self:onUpdate(elapsed) end

		for _, spr in pairs(self.sprites) do
			if spr.active then spr:update(elapsed) end
		end
	end,

	-- passes endFrame events to member sprites

	endFrame = function (self, elapsed)
		if not self.active then return end
		elapsed = elapsed * self.timeScale
		if self.onEndFrame then self:onEndFrame(elapsed) end

		for _, spr in pairs(self.sprites) do
			if spr.active then spr:endFrame(elapsed) end
		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.onDraw then self:onDraw() 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
}