/zoeplat

-- Class: Map

-- A map saves memory and CPU time by acting as if it were a grid of sprites.

-- Each different type of sprite in the grid is represented via a single

-- object. Each sprite must have the same size, however.

-- 

-- This works very similarly to a tilemap, but there is additional flexibility

-- in using a sprite, e.g. animation and other display effects. (If you want it

-- to act like a tilemap, use its loadTiles method.) However, changing a sprite's

-- x or y position has no effect. Changing the scale will have weird effects as

-- a map expects every sprite to be the same size.

--

-- Extends:

--		<Sprite>

Map = Sprite:extend

{

	-- Constant: NO_SPRITE

	-- Represents a map entry with no sprite.

	NO_SPRITE = -1,

	-- Property: sprites

	-- An ordered table of <Sprite> objects to be used in conjunction with the map property.

	sprites = {},

	-- Property: map

	-- A two-dimensional table of values, each corresponding to an entry in the sprites property.

	-- nb. The tile at (0, 0) visually is stored in [1, 1].

	map = {},

	-- Method: empty

	-- Creates an empty map.

	--

	-- Arguments:

	--		width - width of the map in sprites

	--		height - height of the map in sprites

	-- 

	-- Returns:

	--		self, for chaining

	empty = function (self, width, height)

		local x, y

		-- empty the map

		for x = 1, width do

			self.map[x] = {}

			for y = 1, height do

				self.map[x][y] = Map.NO_SPRITE

			end

		end

		-- set bounds

		self.width = width * self.spriteWidth

		self.height = height * self.spriteHeight

		return self

	end,

	-- Method: loadMap

	-- Loads map data from a file, typically comma-separated values.

	-- Each entry corresponds to an index in self.sprites, and all rows

	-- must have the same number of columns.

	--

	-- Arguments:

	--		file - filename of source text to use

	--		colSeparator - character to use as separator of columns, default ','

	--		rowSeparator - character to use as separator of rows, default newline

	--

	-- Returns:

	--		self, for chaining

	loadMap = function (self, file, colSeparator, rowSeparator)

		colSeparator = colSeparator or ','

		rowSeparator = rowSeparator or '\n'

		-- load data

		local x, y

		local source = Cached:text(file)

		local rows = split(source, rowSeparator)

		for y = 1, #rows do

			local cols = split(rows[y], colSeparator)

			for x = 1, #cols do

				if not self.map[x] then self.map[x] = {} end

				self.map[x][y] = tonumber(cols[x])

			end

		end

		-- set bounds

		self.width = #self.map[1] * self.spriteWidth

		self.height = #self.map * self.spriteHeight

		return self

	end,

	-- Method: loadTiles

	--- Loads the sprites group with slices of a source image.

	--  By default, this uses the Tile class for sprites, but you

	--  may pass as replacement class.

	--

	--  Arguments:

	--		image - source image to use for tiles

	--		class - class to create objects with; constructor

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

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

	--		startIndex - starting index of tiles in self.sprites, default 0

	--

	--  Returns:

	--		self, for chaining

	loadTiles = function (self, image, class, startIndex)

		assert(self.spriteWidth and self.spriteHeight, 'sprite size must be set before loading tiles')

		if type(startIndex) ~= 'number' then startIndex = 0 end

		class = class or Tile

		self.sprites = self.sprites or {}

		local imageObj = Cached:image(image)

		local imageWidth = imageObj:getWidth()

		local imageHeight = imageObj:getHeight()

		local i = startIndex

		for y = 0, imageHeight - self.spriteHeight, self.spriteHeight do

			for x = 0, imageWidth - self.spriteWidth, self.spriteWidth do

				self.sprites[i] = class:new{ image = image, width = self.spriteWidth,

											  height = self.spriteHeight,

											  imageOffset = { x = x, y = y }}

				i = i + 1

			end

		end

		return self

	end,

	-- Method: subcollide

	-- This acts as a wrapper to multiple collide() calls, as if

	-- there really were all the sprites in their particular positions.

	-- This is much more useful than Map:collide(), which simply checks

	-- if a sprite or group is touching the map at all. 

	--

	-- Arguments:

	--		other - other <Sprite> or <Group>

	--

	-- Returns:

	--		boolean, whether any collision was detected

	subcollide = function (self, other)

		local hit = false

		local others

		if other.sprites then

			others = other.sprites

		else

			others = { other }

		end

		for _, othSpr in pairs(others) do

			if othSpr.solid then

				if othSpr.sprites then

					-- recurse into subgroups

					-- order is important here to avoid short-circuiting inappopriately

					hit = self:subcollide(othSpr.sprites) or hit

				else

					local startX, startY = self:pixelToMap(othSpr.x - self.x, othSpr.y - self.y)

					local endX, endY = self:pixelToMap(othSpr.x + othSpr.width - self.x,

													   othSpr.y + othSpr.height - self.y)

					local x, y

					for x = startX, endX do

						for y = startY, endY do

							local spr = self.sprites[self.map[x][y]]

							if spr and spr.solid then

								-- position our map sprite as if it were onscreen

								spr.x = self.x + (x - 1) * self.spriteWidth

								spr.y = self.y + (y - 1) * self.spriteHeight

								hit = spr:collide(othSpr) or hit

							end

						end

					end

				end

			end

		end

		return hit

	end,

	-- Method: subdisplace

	-- This acts as a wrapper to multiple displace() calls, as if

	-- there really were all the sprites in their particular positions.

	-- This is much more useful than Map:displace(), which pushes a sprite or group

	-- so that it does not touch the map in its entirety. 

	--

	-- Arguments:

	--		other - other <Sprite> or <Group> to displace

	--		xHint - force horizontal displacement in one direction, uses direction constants

	--		yHint - force vertical displacement in one direction, uses direction constants

	--

	-- Returns:

	--		nothing

	subdisplace = function (self, other, xHint, yHint)	

		local others

		if other.sprites then

			others = other.sprites

		else

			others = { other }

		end

		for _, othSpr in pairs(others) do

			if othSpr.solid then

				if othSpr.sprites then

					-- recurse into subgroups

					-- order is important here to avoid short-circuiting inappopriately

					self:subdisplace(othSpr.sprites)

				else

					-- determine sprites we might intersect with

					local startX, startY = self:pixelToMap(othSpr.x - self.x, othSpr.y - self.y)

					local endX, endY = self:pixelToMap(othSpr.x + othSpr.width - self.x,

													   othSpr.y + othSpr.height - self.y)

					local hit = true

					local loops = 0

					-- We displace the target sprite along the axis that would satisfy the

					-- most map sprites, but at the minimum distance for all of them.

					-- xVotes and yVotes track which axis should be used; this is a

					-- proportional vote, with sprites that have large amounts of overlap

					-- getting more of a chance to overrule the others. We run this loop

					-- repeatedly to make sure we end up with the target sprite not overlapping

					-- anything in the map.

					--

					-- This is based on the technique described at:

					-- http://go.colorize.net/xna/2d_collision_response_xna/

					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 x = startX, endX do

							for y = startY, endY do

								local spr = self.sprites[self.map[x][y]]

								if spr and spr.solid then

									-- position our map sprite as if it were onscreen

									spr.x = self.x + (x - 1) * self.spriteWidth

									spr.y = self.y + (y - 1) * self.spriteHeight

									-- displace and check to see if this displacement

									-- would result in a smaller shift than any so far

									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

							end

						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

		end

	end,

	-- Method: getMapSize

	-- Returns the size of the map in sprites.

	--

	-- Arguments:

	--		none

	--

	-- Returns:

	--		width and height in integers

	getMapSize = function (self)

		if #self.map == 0 then

			return 0, 0

		else

			return #self.map, #self.map[1]

		end

	end,

	draw = function (self, x, y)

		-- lock our x/y coordinates to integers

		-- to avoid gaps in the tiles

		x = math.floor(x or self.x)

		y = math.floor(y or self.y)

		if not self.visible or self.alpha <= 0 then return end

		if not self.spriteWidth or not self.spriteHeight then return end

		-- determine drawing bounds

		-- we draw to fill the entire app windoow

		local startX, startY = self:pixelToMap(-x, -y)

		local endX, endY = self:pixelToMap(the.app.width - x, the.app.height - y)

		-- queue each sprite drawing operation

		local toDraw = {}

		for drawY = startY, endY do

			for drawX = startX, endX do

				local sprite = self.sprites[self.map[drawX][drawY]]

				if sprite and sprite.visible then

					if not toDraw[sprite] then

						toDraw[sprite] = {}

					end

					table.insert(toDraw[sprite], { x + (drawX - 1) * self.spriteWidth,

												   y + (drawY - 1) * self.spriteHeight })

				end

			end

		end

		-- draw each sprite in turn

		for sprite, list in pairs(toDraw) do

			for _, coords in pairs(list) do

				sprite:draw(coords[1], coords[2])

			end

		end

		Sprite.draw(self)

	end,

	-- Method: pixelToMap

	-- Converts pixels to map coordinates.

	--

	-- Arguments:

	--		x - x coordinate in pixels

	--		y - y coordinate in pixels

	--		clamp - clamp to map bounds? defaults to true

	--

	-- Returns:

	--		x, y map coordinates

	pixelToMap = function (self, x, y, clamp)

		if type(clamp) == 'nil' then clamp = true end

		-- remember, Lua tables start at index 1

		local mapX = math.floor(x / self.spriteWidth) + 1

		local mapY = math.floor(y / self.spriteHeight) + 1

		-- clamp to map bounds

		if clamp then

			if mapX < 1 then mapX = 1 end

			if mapY < 1 then mapY = 1 end

			if mapX > #self.map then mapX = #self.map end

			if mapY > #self.map[1] then mapY = #self.map[1] end

		end

		return mapX, mapY

	end,

	-- makes sure all sprites receive startFrame messages

	startFrame = function (self, elapsed)

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

			spr:startFrame(elapsed)

		end

		Sprite.startFrame(self, elapsed)

	end,

	-- makes sure all sprites receive update messages

	update = function (self, elapsed)

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

			spr:update(elapsed)

		end

		Sprite.update(self, elapsed)

	end,

	-- makes sure all sprites receive endFrame messages

	endFrame = function (self, elapsed)

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

			spr:endFrame(elapsed)

		end

		Sprite.endFrame(self, elapsed)

	end,

	__tostring = function (self)

		local result = 'Map (x: ' .. self.x .. ', y: ' .. self.y ..

					   ', w: ' .. self.width .. ', h: ' .. self.height .. ', '

		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 .. ')'

	end

}