View difference between Paste ID: DXPFRELn and VUDp1Ni6

 local storyboard = require( "storyboard" )
 local scene = storyboard.newScene()
 
 ----------------------------------------------------------------------------------
 --
 -- NOTE:
 --
 -- Code outside of listener functions (below) will only be executed once,
 -- unless storyboard.removeScene() is called.
 --
 ---------------------------------------------------------------------------------
 
 ---------------------------------------------------------------------------------
 -- BEGINNING OF YOUR IMPLEMENTATION
 ---------------------------------------------------------------------------------
 
 local _W = display.contentWidth
 local _H = display.contentHeight
 local mRandom = math.random
 
 local score
 local scoreText
 
 local gameTimer
 local gameTimerText
 local gameTimerBar
 local gameTimerBar_bg
 
 
 local gemsTable = {}
 local numberOfMarkedToDestroy = 0
 local gemToBeDestroyed -- used as a placeholder
 local isGemTouchEnabled = true -- blocker for double touching gems
 
 local gameOverLayout
 local gameOverText1
 local gameOverText2
 
 local timers = {}
 
 -- pre-declaration of function
 local onGemTouch
 
 local kinds = {"fish", "star", "turtle", "shell", }
 
 local function newGem (i,j)
 
 	local newGem
 		local img = img
-	local R = mRandom(1,4)
+
 	local R = kinds[mRandom(1,4)]
-	if 		(R == 1 ) then
+
-		img = "fish.png"
+	newGem = display.newImageRect(R..".png", 40, 40)
-		newGem.gemType = "fish"
+
-	elseif 	(R == 2 ) then
+
-		img = "star.png"
+
-		newGem.gemType = "star"
+
 	newGem.isMarkedToDestroy = false
-	elseif 	(R == 3 ) then
+	newGem.gemType = R
-		img = "turtle.png"
+
-		newGem.gemType = "turtle"
+
 
-	elseif 	(R == 4 ) then
+
-		img = "shell.png"
+
-		newGem.gemType = "shell"
+
 
 	groupGameLayer:insert( newGem )
 
-	newGem = display.newImageRect(img, 40, 40)
+
 	newGem.touch = onGemTouch
 	newGem:addEventListener( "touch", newGem )
 
 return newGem
 end
 
 
 
 local function shiftGems () -- not working yet <-- you stupid.. oh u <_< of coz it's working! :P
 
 print ("Shifting Gems")
 
 -- first roww
 for i = 1, 8, 1 do
 if gemsTable[i][1].isMarkedToDestroy then
 
 -- current gem must go to a 'gemToBeDestroyed' variable holder to prevent memory leaks
 -- cannot destroy it now as gemsTable will be sorted and elements moved down
 gemToBeDestroyed = gemsTable[i][1]
 
 -- create a new one
 gemsTable[i][1] = newGem(i,1)
 
 -- destroy old gem
 gemToBeDestroyed:removeSelf()
 gemToBeDestroyed = nil
 end
 end
 
 -- rest of the rows
 for j = 2, 8, 1 do -- j = row number - need to do like this it needs to be checked row by row
 for i = 1, 8, 1 do
 
 if gemsTable[i][j].isMarkedToDestroy then --if you find and empty hole then shift down all gems in column
 
 gemToBeDestroyed = gemsTable[i][j]
 
 -- shiftin whole column down, element by element in one column
 for k = j, 2, -1 do -- starting from bottom - finishing at the second row
 
 -- curent markedToDestroy Gem is replaced by the one above in the gemsTable
 gemsTable[i][k] = gemsTable[i][k-1]
 gemsTable[i][k].destination_y = gemsTable[i][k].destination_y +40
 transition.to( gemsTable[i][k], { time=100, y= gemsTable[i][k].destination_y} )
 
 -- we change its j value as it has been 'moved down' in the gemsTable
 gemsTable[i][k].j = gemsTable[i][k].j + 1
 
 end
 
 -- create a new gem at the first row as there is en ampty space due to gems
 -- that have been moved in the column
 gemsTable[i][1] = newGem(i,1)
 
 -- destroy the old gem (the one that was invisible and placed in gemToBeDestroyed holder)
 gemToBeDestroyed:removeSelf()
 gemToBeDestroyed = nil
 end
 end
 end
 end --shiftGems()
 
 
 
 local function markToDestroy( self )
 
 self.isMarkedToDestroy = true
 numberOfMarkedToDestroy = numberOfMarkedToDestroy + 1
 
 -- check on the left
 if self.i>1 then
 if (gemsTable[self.i-1][self.j]).isMarkedToDestroy == false then
 
 if (gemsTable[self.i-1][self.j]).gemType == self.gemType then
 
 markToDestroy( gemsTable[self.i-1][self.j] )
 end
 end
 end
 
 -- check on the right
 if self.i<8 then
 if (gemsTable[self.i+1][self.j]).isMarkedToDestroy == false then
 
 if (gemsTable[self.i+1][self.j]).gemType == self.gemType then
 
 markToDestroy( gemsTable[self.i+1][self.j] )
 end
 end
 end
 
 -- check above
 if self.j>1 then
 if (gemsTable[self.i][self.j-1]).isMarkedToDestroy == false then
 
 if (gemsTable[self.i][self.j-1]).gemType == self.gemType then
 
 markToDestroy( gemsTable[self.i][self.j-1] )
 end
 end
 end
 
 -- check below
 if self.j<8 then
 if (gemsTable[self.i][self.j+1]).isMarkedToDestroy== false then
 
 if (gemsTable[self.i][self.j+1]).gemType == self.gemType then
 
 markToDestroy( gemsTable[self.i][self.j+1] )
 end
 end
 end
 end
 
 
 
 local function enableGemTouch()
 
 isGemTouchEnabled = true
 end
 
 
 
 local function destroyGems()
 print ("Destroying Gems. Marked to Destroy = "..numberOfMarkedToDestroy)
 
 
 for i = 1, 8, 1 do
 for j = 1, 8, 1 do
 
 if gemsTable[i][j].isMarkedToDestroy then
 
 isGemTouchEnabled = false
 transition.to( gemsTable[i][j], { time=300, alpha=0.2, xScale=2, yScale = 2, onComplete=enableGemTouch } )
 
 -- update score
 score = score + 10
 scoreText.text = string.format( "SCORE: %6.0f", score )
 scoreText:setReferencePoint(display.TopLeftReferencePoint)
 scoreText.x = 60
 
 end
 end
 end
 
 numberOfMarkedToDestroy = 0
 timer.performWithDelay( 320, shiftGems )
 
 end
 
 
 
 local function cleanUpGems()
 print("Cleaning Up Gems")
 
 numberOfMarkedToDestroy = 0
 
 for i = 1, 8, 1 do
 for j = 1, 8, 1 do
 
 -- show that there is not enough
 if gemsTable[i][j].isMarkedToDestroy then
 transition.to( gemsTable[i][j], { time=100, xScale=1.2, yScale = 1.2 } )
 transition.to( gemsTable[i][j], { time=100, delay=100, xScale=1.0, yScale = 1.0} )
 end
 
 gemsTable[i][j].isMarkedToDestroy = false
 
 
 end
 end
 end
 
 
 
 function onGemTouch( self, event )	-- was pre-declared
 
 if event.phase == "began" and isGemTouchEnabled then
 
 print("Gem touched i= "..self.i.." j= "..self.j)
 
 markToDestroy(self)
 
 if numberOfMarkedToDestroy >= 3 then
 
 destroyGems()
 else
 cleanUpGems()
 end
 end
 
 return true
 
 end
 
 
 
 function onTouchGameOverScreen ( self, event )
 
 	if event.phase == "began" then
 
 		storyboard.gotoScene( "menu-scene", "fade", 400  )
 
 		return true
 	end
 end
 
 
 local function showGameOver ()
 
 	gameOverLayout.alpha = 0.8
 	gameOverText1.alpha = 1
 	gameOverText2.alpha = 1
 
 
 end
 
 local function gameTimerUpdate ()
 
 	gameTimer = gameTimer - 1
 
 	if gameTimer >= 0 then gameTimerText.text = gameTimer
 
 	else
 		gameOverText2.text = string.format( "SCORE: %6.0f", score )
 		showGameOver()
 
 	end
 end
 
 
 -- Called when the scene's view does not exist:
 function scene:createScene( event )
         local screenGroup = self.view
 
 		print( "\n1: createScene event")
 
         -----------------------------------------------------------------------------
 
         --      CREATE display objects and add them to 'group' here.
         --      Example use-case: Restore 'group' from previously saved state.
 
         -----------------------------------------------------------------------------
 
     -- reseting values
     score		= 0
     gameTimer 	= 30
 
 
    	groupGameLayer = display.newGroup()
    	groupEndGameLayer = display.newGroup()
 
 	local bgGameImage = display.newImageRect( "bg.png", 320, 480, true )
 	bgGameImage.x = _W * 0.5
 	bgGameImage.y = _H * 0.5
 	groupGameLayer:insert(bgGameImage)
     --score text
 
     scoreText = display.newText( "SCORE:" , 40, 20, native.systemFontBold, 32 )
 	scoreText.text = string.format( "SCORE: %6.0f", score )
 	scoreText:setReferencePoint(display.TopLeftReferencePoint)
 	scoreText.x = 60
 	scoreText:setTextColor(0, 0, 255)
 
 
 	gameTimerBar_bg = display.newRoundedRect( 20, 430, 280, 20, 4)
 	gameTimerBar_bg:setFillColor( 60, 60, 60 )
  	gameTimerBar = display.newRoundedRect( 20, 430, 280, 20, 4)
  	gameTimerBar:setFillColor( 0, 150, 0 )
  	gameTimerBar:setReferencePoint(display.TopLeftReferencePoint)
 
 
  	gameTimerText = display.newText( gameTimer , 0, 0, native.systemFontBold, 18 )
  	gameTimerText:setTextColor( 255, 255, 255 )
 	gameTimerText:setReferencePoint(display.TopLeftReferencePoint)
     gameTimerText.x = _W * 0.5 - 12
     gameTimerText.y = 426
 
 	groupGameLayer:insert ( scoreText )
 	groupGameLayer:insert ( gameTimerBar_bg )
  	groupGameLayer:insert ( gameTimerBar )
  	groupGameLayer:insert ( gameTimerText )
 
     --gemsTable
     for i = 1, 8, 1 do
 
     	gemsTable[i] = {}
 
 		for j = 1, 8, 1 do
 
 			gemsTable[i][j] = newGem(i,j)
 
  		end
  	end
 
 
  	gameOverLayout = display.newRect( 0, 0, 320, 480)
  	gameOverLayout:setFillColor( 0, 0, 0 )
  	gameOverLayout.alpha = 0
 
  	gameOverText1 = display.newText( "GAME OVER", 0, 0, native.systemFontBold, 24 )
 	gameOverText1:setTextColor( 255 )
 	gameOverText1:setReferencePoint( display.CenterReferencePoint )
 	gameOverText1.x, gameOverText1.y = _W * 0.5, _H * 0.5 -150
 	gameOverText1.alpha = 0
 
 	gameOverText2 = display.newText( "SCORE: ", 0, 0, native.systemFontBold, 24 )
 	gameOverText2.text = string.format( "SCORE: %6.0f", score )
 	gameOverText2:setTextColor( 255 )
 	gameOverText2:setReferencePoint( display.CenterReferencePoint )
 	gameOverText2.x, gameOverText2.y = _W * 0.5, _H * 0.5 - 50
 	gameOverText2.alpha = 0
 
 
 	gameOverLayout.touch = onTouchGameOverScreen
 	gameOverLayout:addEventListener( "touch", gameOverLayout )
 
 
 	groupEndGameLayer:insert ( gameOverLayout )
 	groupEndGameLayer:insert ( gameOverText1 )
 	groupEndGameLayer:insert ( gameOverText2 )
 
 
 	-- insterting display groups to the screen group (storyboard group)
 	screenGroup:insert ( groupGameLayer )
 	screenGroup:insert ( groupEndGameLayer )
 end
 
 -- Called BEFORE scene has moved onscreen:
 function scene:willEnterScene( event )
         local screenGroup = self.view
 
         -----------------------------------------------------------------------------
 
         --      This event requires build 2012.782 or later.
 
         -----------------------------------------------------------------------------
 
 end
 
 -- Called immediately after scene has moved onscreen:
 function scene:enterScene( event )
         local screenGroup = self.view
 
         -----------------------------------------------------------------------------
 
         --      INSERT code here (e.g. start timers, load audio, start listeners, etc.)
 
         -----------------------------------------------------------------------------
 
 	-- remove previous scene's view
 
     storyboard.purgeScene( "menu-scene" )
 
 	print( "1: enterScene event" )
 
 	-- storyboard.purgeScene( "scene4" )
 
 	-- reseting values
 	score = 0
 
 
 	transition.to( gameTimerBar, { time = gameTimer * 1000, width=0 } )
 	timers.gameTimerUpdate = timer.performWithDelay(1000, gameTimerUpdate, 0)
 
 
 
 end
 
 
 -- Called when scene is about to move offscreen:
 function scene:exitScene( event )
         local screenGroup = self.view
 
         -----------------------------------------------------------------------------
 
         --      INSERT code here (e.g. stop timers, remove listeners, unload sounds, etc.)
 
         -----------------------------------------------------------------------------
 
 	if timers.gameTimerUpdate then
 		timer.cancel(timers.gameTimerUpdate)
 		timers.gameTimerUpdate = nil
 	 end
 
 end
 
 -- Called AFTER scene has finished moving offscreen:
 function scene:didExitScene( event )
         local screenGroup = self.view
 
         -----------------------------------------------------------------------------
 
         --      This event requires build 2012.782 or later.
 
         -----------------------------------------------------------------------------
 
 end
 
 
 -- Called prior to the removal of scene's "view" (display group)
 function scene:destroyScene( event )
         local screenGroup = self.view
 
         -----------------------------------------------------------------------------
 
         --      INSERT code here (e.g. remove listeners, widgets, save state, etc.)
 
         -----------------------------------------------------------------------------
 
 end
 
 -- Called if/when overlay scene is displayed via storyboard.showOverlay()
 function scene:overlayBegan( event )
         local screenGroup = self.view
         local overlay_scene = event.sceneName  -- overlay scene name
 
         -----------------------------------------------------------------------------
 
         --      This event requires build 2012.797 or later.
 
         -----------------------------------------------------------------------------
 
 end
 
 -- Called if/when overlay scene is hidden/removed via storyboard.hideOverlay()
 function scene:overlayEnded( event )
         local screenGroup = self.view
         local overlay_scene = event.sceneName  -- overlay scene name
 
         -----------------------------------------------------------------------------
 
         --      This event requires build 2012.797 or later.
 
         -----------------------------------------------------------------------------
 
 end
 
 
 
 ---------------------------------------------------------------------------------
 -- END OF YOUR IMPLEMENTATION
 ---------------------------------------------------------------------------------
 
 -- "createScene" event is dispatched if scene's view does not exist
 scene:addEventListener( "createScene", scene )
 
 -- "willEnterScene" event is dispatched before scene transition begins
 scene:addEventListener( "willEnterScene", scene )
 
 -- "enterScene" event is dispatched whenever scene transition has finished
 scene:addEventListener( "enterScene", scene )
 
 -- "exitScene" event is dispatched before next scene's transition begins
 scene:addEventListener( "exitScene", scene )
 
 -- "didExitScene" event is dispatched after scene has finished transitioning out
 scene:addEventListener( "didExitScene", scene )
 
 -- "destroyScene" event is dispatched before view is unloaded, which can be
 -- automatically unloaded in low memory situations, or explicitly via a call to
 -- storyboard.purgeScene() or storyboard.removeScene().
 scene:addEventListener( "destroyScene", scene )
 
 -- "overlayBegan" event is dispatched when an overlay scene is shown
 scene:addEventListener( "overlayBegan", scene )
 
 -- "overlayEnded" event is dispatched when an overlay scene is hidden/removed
 scene:addEventListener( "overlayEnded", scene )
 
 ---------------------------------------------------------------------------------
 
 return scene