/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

}