main.lua

-----------------------------------------------------------------------
-- main.lua
-----------------------------------------------------------------------

--[[

	 Mark H Carolan 2010
	
	 Demo of rudimentary cart object with powered wheels
	   responding to physics-based terrain.
	
	 Intended for Corona beginners. Demonstrates a few
	 basic ways of handling sidescrolling with physics.
	
	 Illustrates:
	
	   Tracking moving object with "camera".
	   Re-using side-scrolling surfaces.
	   Using piston and motorised pivot joints.
	   Creating physics objects using shape tables.
	   Using Corona's vector lines to illustrate shapes.
	   Creating modular game components in functions.
	   Using timer to call function at a later date.
	   Using Lua closures to pass parameter data to a listener.
	   Handling collisions with specific objects.
	  
	  Also serves as a general introduction to using Lua 
	  	tables and Corona group display objects.
	  
	  NOTE: This doesn't represent best-practice in Lua
	    programming or using the Corona SDK. Hopefully it
	    simply offers some insights into getting started
	    with Corona from my perspective as a relative
	    newcomer to both Lua and Corona. If any of my comments
	    etc. are incorrect, please let me know.
	
--]]

require "physics"
physics.start()

-----------------------------------------------------------------------
-- There appears to be an odd side effect with
-- the (debug) drawing of joints. You can't add
-- joints to a display group, so they appear to break away
-- from the visual object that contains
-- the physics bodies they're attached to.
-- Not a big deal, as it only affects the debug and hybrid
-- drawing of the joints, but a little disconcerting at first.

-- physics.setDrawMode("hybrid")
-----------------------------------------------------------------------

local JUMP_POWER = 7
local CAMERA_OFFSET = 100

local function offset(x, y)
	return x, y - display.contentHeight
end

-----------------------------------------------------------------------
-- Utility function:
-- Create ground shapes and display as lines
-----------------------------------------------------------------------

local function newContour(params)
	local physicsShape = {}
	
	local coords = params.coords
	local bodyType = params.bodyType
	
	local contour = display.newLine(coords[1], coords[2], coords[3], coords[4])
	
	physicsShape[1], physicsShape[2] = offset(coords[1], coords[2])
	physicsShape[3], physicsShape[4] = offset(coords[3], coords[4])
	
	if params.color then
		contour:setColor(params.color[1], params.color[2], params.color[3])
	else
		contour:setColor(255, 0, 0, 255)
	end
	contour.width = 8
	
	for i = 5, #coords, 2 do
		contour:append(coords[i], coords[i+1])
		physicsShape[i], physicsShape[i+1] = offset(coords[i], coords[i+1])
	end

	-----------------------------------------------------
	-- Visuals must be closed by repeating startpoint
	-- but not physics shapes, which will crash simulator.
	-----------------------------------------------------
	
	contour:append(coords[1], coords[2])
	
	physics.addBody(contour, bodyType or "static", 
		{ friction = 1, bounce = 0.0, shape=physicsShape}	)
	
	return contour
end

----------------------------------------------------------------------- 
-- Simple slider for speed control
-----------------------------------------------------------------------

local function newSlider(params)
	local p = params or {}
	local g = display.newGroup()
	
	local back = display.newRect(0, 0, p.width or 120, p.height or 32)
	g:insert(back)
	
	back:setFillColor(0, 0, 200)
	back.strokeWidth = 3
	back:setStrokeColor(128, 128, 128)
	
	local button = display.newRect(0, 0, p.buttonWidth or 32, p.buttonHeight or 34)	
	g:insert(button)
	
	button:setFillColor(0, 200, 0)
	button.strokeWidth = 3	
	button:setStrokeColor(200, 200, 200)
	
	local leftLimit = back.x-back.width/2
	local rightLimit = back.x+back.width/2
	
	button.x = leftLimit
	
	g.x = params.x or 160
	g.y = p.y or 280
	
	button.y = button.y-1
	local currentXReading = leftLimit
	
	local callbackFunc = p.callbackFunc
	local callbackObject = p.callbackObject
	
	button:addEventListener("touch", g)
	
	------------------------------------------------
	-- Nothing much to see here. Just a slider made
	-- with a backing strip and a square button.
	-- the slider is passed an object and a function
	-- to call on that object when the button is moved.
	-- for simplicity, output values are 0.0 to 1.0
	------------------------------------------------
	
	function g:touch(event)
		if event.phase == "began" then
			display.getCurrentStage():setFocus(button)
		elseif event.phase == "moved" then
			local movementX = event.x - event.xStart
			local posX = currentXReading + movementX
			event.target.x = posX 
			if event.target.x < leftLimit then
				event.target.x = leftLimit
			elseif event.target.x > rightLimit then
				event.target.x = rightLimit
			end
			
			local val = event.target.x
		
			-----------------------------
			-- Output value 0.0 .. 1.0
			-----------------------------
			
			callbackFunc(callbackObject, val / back.width) 
		elseif event.phase == "ended" then
			currentXReading = button.x
			display.getCurrentStage():setFocus(nil)
		end
		return true
	end
	
	function g:set(f) -- 0.0 .. 1.0
		button.x = f * button.width
		currentXReading = leftLimit + f * back.width
	end
	
	return g
end

-----------------------------------------------------------------------
-- Utility function:
-- Create a circular polygon
-----------------------------------------------------------------------

local function createNGon(radius, sides)
	local points = {}
	local rad = math.rad(360/sides)
	
	------------------------------------------------
	-- Create anything up to an octagon (the max sides
	-- allowed by Corona in a vector line) based on
	-- radius of an enclosing circle.
	------------------------------------------------
	
	for i = 1, sides do
		local radAngle = rad*(i-1)
		
		local rSin = math.sin(radAngle)
		local rCos = math.cos(radAngle)
				
		points[#points+1] = rSin * radius
		points[#points+1] = rCos * radius
		
	end
	
	------------------------------------------------
	-- For poly lines, define the first and second xy
	-- coords, creating a single line, then add points
	-- from there to create poly line. For closed polygon
	-- simply repeat the first xy coord at the end.
	------------------------------------------------
	
	local poly = display.newLine(points[1], points[2], points[3], points[4])
	for i = 5, #points, 2 do
		poly:append(points[i], points[i+1])
	end 
	
	poly:append(points[1], points[2])
	
	poly:setColor(255, 255, 255)
	poly.width = 2
	
	local g = display.newGroup()
	g:insert(poly)
	display.setDefault("fillColor", 0, 255, 0, 200)
	g:insert(display.newCircle(0, 0, radius+2))
	
	--------------------------------------------
	-- It's necessary to put this into a group.
	-- It seems that the registration point, when
	-- a physics object is attached, is at the start
	-- point of the multi-segment line. Setting
	-- registration point doesn't fix this. Putting
	-- the line into a group does. Also, the wheel is 
	-- just for looks. The wheel could just as easily 
	-- be square, as it's only the physics body that
	-- determines the behaviour.
	----------------------------------------------
	
	return g
end

-----------------------------------------------------------------------
-- Utility function:
-- Create the Billy Cart with a box and 2 circles
-----------------------------------------------------------------------

local function newBillyCart(params)
	local cart = display.newGroup()

	local originX = params.originX or 0
	local originY = params.originY or 0
	
	local body = params.body or display.newRect(0, 0, 102, 20)	
	body:setFillColor(0, 0, 255)		

	-----------------------------------------
	-- Shaped vector wheel (to show rotation)
	-----------------------------------------
	
	display.setDefault("fillColor", 0, 255, 0, 200)
	
	local wheelLowerLeft = createNGon(16, 5)
	local wheelLowerRight = createNGon(16, 5)		
	
	-----------------------------------------
	-- Anchor for shock absorber
	-----------------------------------------
	
	display.setDefault("fillColor", 255, 0, 0, 200)
		
	local shockBaseLeft = display.newRect(0, 0, 14, 14)
	local shockBaseRight = display.newRect(0, 0, 14, 14)	
	
	-----------------------------------------
	-- Shock absorber bar
	-----------------------------------------
	
	display.setDefault("fillColor", 255, 255, 0, 200)
	
	local lowerShockLeft = display.newRect(0, 0, 8, 28)		
	local lowerShockRight = display.newRect(0, 0, 8, 28)	
	
	-----------------------------------------
	-- Get everything in the right place
	-----------------------------------------
	
	function cart:setOrigin(originX, originY)
		body.x = originX
		body.y = originY+10	
		wheelLowerLeft.x = originX-40
		wheelLowerLeft.y = originY+20	
		wheelLowerRight.x = originX+40
		wheelLowerRight.y = originY+20
		shockBaseLeft.x = originX-40
		shockBaseLeft.y = originY+16
		shockBaseRight.x = originX+40
		shockBaseRight.y = originY+16
		lowerShockLeft.x = originX-40
		lowerShockLeft.y = originY+24
		lowerShockRight.x = originX+40		
		lowerShockRight.y = originY+24	
	end
	
	cart:setOrigin(originX, originY)
	
	-----------------------------------------
	-- put all components into single group
	-----------------------------------------
	
	cart:insert(body)
	cart:insert(wheelLowerLeft)
	cart:insert(wheelLowerRight)
	cart:insert(shockBaseLeft)
	cart:insert(shockBaseRight)
	cart:insert(lowerShockLeft)
	cart:insert(lowerShockRight)
	
	-----------------------------------------
	-- Make into physics objects
	-----------------------------------------
	
	physics.addBody(body, {density=0.5, bounce = 0, friction = 0})
	physics.addBody(wheelLowerLeft, {density=0.9, bounce = 0.0, friction = 4.0, radius=16})
	physics.addBody(wheelLowerRight, {density=0.9, bounce = 0.0, friction = 4.0, radius=16})
	physics.addBody(shockBaseLeft, {density=0.05, bounce = 0, friction = 0})
	physics.addBody(shockBaseRight, {density=0.05, bounce = 0, friction = 0})
	physics.addBody(lowerShockLeft, {density=0.02, bounce = 0, friction = 0})
	physics.addBody(lowerShockRight, {density=0.02, bounce = 0, friction = 0})
	
	-----------------------------------------
	-- Create joints to define behaviour
	-----------------------------------------
	
	local shockBaseLeftJoint = physics.newJoint ("weld", body, 
		shockBaseLeft, shockBaseLeft.x, shockBaseLeft.y)
	
	local shockBaseRightJoint = physics.newJoint ("weld", body, 
		shockBaseRight, shockBaseRight.x, shockBaseRight.y)

	local lowerShockLeftJoint = physics.newJoint ("piston", 
		shockBaseLeft, lowerShockLeft, shockBaseLeft.x, shockBaseLeft.y, 0, 10)
		
	local lowerShockRightJoint = physics.newJoint ("piston", 
		shockBaseRight, lowerShockRight, shockBaseRight.x, shockBaseRight.y, 0, 10)
	
	local lowerConnectorLeftJoint = physics.newJoint ("weld", 
		shockBaseLeft, lowerShockLeft, shockBaseLeft.x, shockBaseLeft.y)
		
	local lowerConnectorRightJoint = physics.newJoint ("weld", 
		shockBaseRight, lowerShockRight, shockBaseRight.x, shockBaseRight.y)
				
	local wheelLowerLeftJoint = physics.newJoint ("pivot", 
		lowerShockLeft, wheelLowerLeft, wheelLowerLeft.x, wheelLowerLeft.y)
	
	local wheelLowerRightJoint = physics.newJoint ("pivot", 
		lowerShockRight, wheelLowerRight, wheelLowerRight.x, wheelLowerRight.y)
		
	local wheelConnectorJoint = physics.newJoint("distance", 
		wheelLowerLeft, wheelLowerRight, wheelLowerLeft.x, wheelLowerLeft.y, 
		wheelLowerRight.x, wheelLowerRight.y)
	
	------------------------------------------------
	-- Turn the pivot joints into motors.
	------------------------------------------------
	
	wheelLowerLeftJoint.isMotorEnabled = true
	wheelLowerLeftJoint.motorSpeed = 0
	wheelLowerLeftJoint.maxMotorTorque = 100000

	wheelLowerRightJoint.isMotorEnabled = true
	wheelLowerRightJoint.motorSpeed = 0
	wheelLowerRightJoint.maxMotorTorque = 100000

	------------------------------------------------
	-- Try to stop wild movements. These figures
	-- probably need a lot of tweaking.
	------------------------------------------------
	
	body.angularDamping = 50

	shockBaseLeft.linearDamping = 10
	shockBaseRight.linearDamping = 10
	
	lowerShockLeft.angularDamping = 50
	lowerShockRight.angularDamping = 50

	lowerShockLeft.linearDamping = 50
	lowerShockRight.linearDamping = 50
	
	-----------------------------------------
	-- Set spin of pivot joints to power cart
	-----------------------------------------
	
	function cart:setSpeed(s)
		wheelLowerLeftJoint.motorSpeed = s
		wheelLowerRightJoint.motorSpeed = s
	end

	-----------------------------------------
	-- Jump by puttin upward impulse on wheels
	-----------------------------------------
	
	function cart:lift()
		wheelLowerLeft:applyLinearImpulse(0, -JUMP_POWER, 
		wheelLowerLeft.x, wheelLowerLeft.y)
		wheelLowerRight:applyLinearImpulse(0, -JUMP_POWER, 
		wheelLowerRight.x, wheelLowerRight.y)
	end
	
	-----------------------------------------
	-- Reset after a prang, maintaining x position
	-----------------------------------------
	
	function cart:reset()
		body.rotation = 0
		self:setOrigin(body.x, body.y - 20)
		self:setSpeed(0)
	end

	-----------------------------------------
	-- Change back to normal color after
	-- embarrassed blush from hitting something.
	-- NOTE: 'self' is handled manually because this
	-- is a listener function (no implicit self, as
	-- it's not called by the timer routine with 
	-- the ':' syntax)
	-----------------------------------------
	
	function cart.revert(self)
		body:setFillColor(0, 0, 255)
	end
	
	-----------------------------------------
	-- Handle collision with other objects.
	-- If object is a known type 
	-- (like "b" for boulder) respond accordingly.
	-----------------------------------------
	
	function cart:collision(event)
		if event.phase == "ended" then
			if event.other.id and event.other.id == "b" then
				body:setFillColor(255, 0, 0)
	
				-----------------------------------------
				-- Use Lua closure to pass 'self' to listener.
				-----------------------------------------
				
				local doRevert = function() return self.revert(self) end
				
				-----------------------------------------
				-- Switch off hit status after 2 seconds
				-----------------------------------------
				
				timer.performWithDelay(2000, doRevert)
			end
		end
	end
	
	wheelLowerLeft:addEventListener("collision", cart)
	wheelLowerRight:addEventListener("collision", cart)
	
	-----------------------------------------
	-- Body needs to be accessible from outside
	-----------------------------------------
	
	cart.body = body
	
	return cart
end

-----------------------------------------------------------------------
-- Main game object
-----------------------------------------------------------------------

function newBillyCartGame(params)
	local camera = display.newGroup()
	
	local p = params or {}

	-----------------------------------------
	-- Our home-made, slightly ricketty 
	-- Billy Cart.
	-----------------------------------------
	
	local cart = newBillyCart
	{
		originX = 100,
		originY = 160,

	}		
	
	camera:insert(cart)
	
	-----------------------------------------
	-- Obstacle
	-----------------------------------------
	
	local boulder = display.newCircle(0, 0, 12)
	boulder:setFillColor(255, 255, 0)
	physics.addBody(boulder, {density=0.5, bounce = 0.1, friction = 1.0})
	camera:insert(boulder)
	boulder.x = -display.contentWidth -- drop behind
	boulder.y = 0
	boulder.id = "b" -- for collision detection
	
	-----------------------------------------
	-- Specify function for slider to call
	-----------------------------------------
	
	local function setSpeed(self, amt)
		local speed = amt * 2000
		cart:setSpeed(speed)	
	end

	-----------------------------------------
	-- Create slider control
	-----------------------------------------
	
	local slider = newSlider
	{
		callbackFunc = setSpeed,
		callbackObject = camera,
	}
	
	-----------------------------------------
	-- Slope definition with variable peak
	-----------------------------------------
	
	local function newSlope(peakY)
		local slope = 
		{
			0, 320,
			0, 260,
			200, peakY,
			280, peakY,
			480, 260, 
			480, 320
		}
		return slope
	end
	
	-----------------------------------------
	-- Generate landscape shapes
	-----------------------------------------
	
	local peaks = { 259, 150, 100, 50, 249, 239, 10, 219, 70, 239, 150, 50 }
		
	local lastXPos = 0
	local shapeStartIndex = camera.numChildren+1
	local lastIndex = shapeStartIndex
	local shapeEndIndex = shapeStartIndex + #peaks-1
	
	local panels = {}
	
	local colors = 
	{
		{ 255, 0, 0 },
		{ 0, 0, 255 },
		{ 0, 255, 255 },
		{ 255, 255, 0 },
		{ 0, 255, 0 }
	}
	
	for i = 1, #peaks do
		local ground = newContour
		{
			coords = newSlope(peaks[i]),
			color = colors[i % #colors]
		}
		ground.x = ground.x + (i-1) * 480
		ground.index = i
		lastXPos = ground.x
		camera:insert(ground)
		panels[#panels+1] = ground
	end
	
	-----------------------------------------
	-- Camera tracking.
	-- Offscreen landscape creation.
	-----------------------------------------
	
	function camera:enterFrame(event)	

		-----------------------------------------
		-- Reposition "camera"
		-----------------------------------------
		
		self.x = -cart.body.x + CAMERA_OFFSET
		self.y = -cart.body.y + CAMERA_OFFSET
		
		-----------------------------------------
		-- Reuse physics ground shapes
		-----------------------------------------
		
		if cart.body.x > lastXPos then		
			lastXPos = lastXPos + display.contentWidth
			
			local slope = self[lastIndex]
			slope.x = lastXPos
			lastIndex = lastIndex + 1
			if lastIndex > shapeEndIndex then
				lastIndex = shapeStartIndex
			end
			
		end
		
		-----------------------------------------
		-- Reset if tipped over
		-----------------------------------------
		
		if cart.body.rotation < -135 
			or cart.body.rotation > 135 then
			cart:reset()
			slider:set(0)
		end

		-----------------------------------------
		-- Drop boulder ahead of cart if it's 
		-- offscreen left
		-----------------------------------------
		
		if boulder.x < cart.body.x - display.contentWidth then	
			boulder.x = cart.body.x + display.contentWidth
			boulder.y = 0
		end
		
	end
	
	--------------------------------
	-- Jump
	--------------------------------
	function camera:touch(event)
		if event.phase == "began" then
			cart:lift()
		end
	end
	
	function camera:start()
		Runtime:addEventListener("enterFrame", self)
		Runtime:addEventListener("touch", self)
	end
	
	return camera
end

-----------------------------------------------------------------------
-- Here's where it starts:
-----------------------------------------------------------------------

local game = newBillyCartGame()

game:start()