View difference between Paste ID: hFubxDgx and EVXXNadV

 SCORE_Y = 1			--Y value to draw the score text; it'll be centered on the X axis
 CONTROLS_Y = 18		--Y value to draw RESET button; it'll be centered on the X axis
 ANIMATION_TIME = 0.1--Animation sleep time, lower is faster
 
 m = nil --Monitor peripheral, if connected
 
 function getMonitor()
 	--Sets m to equal an attached monitor if available and large enough.
 	--Returns true if a monitor is found
 	local i = 1
 	local sides = rs.getSides() --Returns a list of sides (e.g. "left", "back", etc)
 	while i <= #sides and m == nil do --Loop every side or until a monitor is found
 		if peripheral.getType(sides[i]) == "monitor" then
 			local w, h = peripheral.call(sides[i], "getSize")
 			if w >= 18 and h >= 19 then --Attached monitor must be at least 18x19
 				print("Monitor detected.  Outputting game to "..sides[i].." monitor.")
 				m = peripheral.wrap(sides[i])
 				return true
 			else
 				print("Monitor size "..w.."x"..h.." detected but at least 18x19 is required.")
 				print("Press any key to continue...")
-				os.pullEvent("key") --Wait for a keypress
+				sapphUtils.pullEvent("key") --Wait for a keypress
 				term.clear()
 			end
 		end
 		i = i + 1
 	end
 
 	return false
 end
 
 function drawScreen()
 	--Draws all screen elements.  Use drawScore() and drawGrid() to refresh just those
 	m.setBackgroundColor(colors.black)
 	m.clear()
 
 	--Draw the border
 	m.setBackgroundColor(colors.white)
 	for x = tlGridX - 1, tlGridX + 16 do --Top & bottom borders
 		m.setCursorPos(x, tlGridY - 1)
 		m.write(" ")
 		m.setCursorPos(x, tlGridY - 1 + 13)
 		m.write(" ")
 	end
 	for y = tlGridY - 1, tlGridY + 12 do --Left & right borders
 		m.setCursorPos(tlGridX - 1, y)
 		m.write(" ")
 		m.setCursorPos(tlGridX - 1 +  17, y)
 		m.write(" ")
 	end
 
 	if isValidMonitorConnected then
 		--Draw reset button
 		m.setBackgroundColor(colors.orange)
 		m.setTextColor(colors.white)
 		m.setCursorPos(termWidth / 2 - string.len("RESET") / 2 + 1, CONTROLS_Y)
 		m.write("RESET")
 
 		--Draw quit "X" at top right
 		m.setBackgroundColor(colors.red)
 		m.setCursorPos(termWidth, 1)
 		m.write("X")
 	else
 		--Draw control description
 		m.setBackgroundColor(colors.black)
 		m.setTextColor(colors.white)
 		m.setCursorPos(1, 8)
 		m.write("Controls:")
 		m.setCursorPos(1, 9)
 		m.write("Arrow keys")
 		m.setCursorPos(1, 10)
 		m.write("(R)eset")
 		m.setCursorPos(1, 11)
-		m.write("E(x)it")
+		m.write("Switch site - X")
 	end
 
 	drawScore()
 
 	drawGrid()
 end
 
 function drawScore()
 	m.setBackgroundColor(colors.black)
 	m.setTextColor(colors.white)
 	scoreText = "Score: "..score
 	m.setCursorPos(termWidth / 2 - string.len(scoreText) / 2 + 1, SCORE_Y) --Center the score on the X axis
 	m.write(scoreText)
 end
 
 function drawGrid()
 	for r = 0, 3 do --Row
 		for c = 0, 3 do --Column
 			drawSquare(r, c, grid[r][c])
 		end
 	end
 end
 
 function drawSquare(r, c, value, randomColor)
 	--Draws an individual square on the board
 	--Board squares are 4 wide and 3 tall so multiply c & r values respectively
 	--randomColor and -1 value used for intro sequence only
 	if value == 0 then --Black out the square
 		m.setBackgroundColor(colors.black)
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + tlGridY)
 		m.write("    ")
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 1 + tlGridY)
 		m.write("    ")
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 2 + tlGridY)
 		m.write("    ")
 	elseif value == -1 then --Only used for rendering the 0, which normally is invisible, during the intro sequence
 		if not randomColor then
 			m.setBackgroundColor(colors.green)
 		else
 			m.setBackgroundColor(2^math.random(2, 14)) --Any color but white or black
 		end
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + tlGridY)
 		m.write("    ")
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 1 + tlGridY)
 		m.write("  0 ")
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 2 + tlGridY)
 		m.write("    ")
 	else
 		if not randomColor then
 			m.setBackgroundColor(value)
 		else
 			m.setBackgroundColor(2^math.random(2, 14)) --Any color but white or black
 		end
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + tlGridY)
 		m.write("    ")
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 1 + tlGridY)
 		--Center the number string within spaces (e.g. "  2 " or " 32 ")
 		local strlen = string.len(value)
 		if strlen == 1 then
 			m.write("  "..value.." ")
 		elseif strlen == 2 then
 			m.write(" "..value.." ")
 		elseif strlen == 3 then
 			m.write(" "..value)
 		else
 			m.write(tostring(value))
 		end
 		m.setCursorPos(c * 4 + tlGridX, r * 3 + 2 + tlGridY)
 		m.write("    ")
 	end
 end
 
 function clearGrid()
 	--Initializes the grid
 	for r = 0, 3 do
 		grid[r] = {}
 		for c = 0, 3 do
 			grid[r][c] = 0
 		end
 	end
 end
 
 function placeNewTile()
 	--Places a 2 or 4 at a random empty location in the grid
 	local number
 
 	if math.random(10) == 10 then --Place a 4 10% of the time, else 2
 		number = 4
 	else
 		number = 2
 	end
 	--Get a count of empty cells in the grid
 	local emptyCount = 0
 	for r = 0, 3 do
 		for c = 0, 3 do
 			if grid[r][c] == 0 then
 				emptyCount = emptyCount + 1
 			end
 		end
 	end
 	--Choose an empty cell and place the number
 	local target = math.random(emptyCount)
 	emptyCount = 0
 	for r = 0, 3 do
 		for c = 0, 3 do
 			if grid[r][c] == 0 then
 				emptyCount = emptyCount + 1
 				if emptyCount == target then
 					grid[r][c] = number
 				end
 			end
 		end
 	end
 end
 
 function transpose()
 	--[[ Turns rows into columns and vice-versa, like so:
 		0, 1, 2, 3, 			0, 4, 8, C,
 		4, 5, 6, 7,				1, 5, 9, D,
 		8, 9, A, B,		becomes	2, 6, A, E,
 		C, D, E, F				3, 7, B, F
 	]]--
     local res = {}
 
     for r = 0, 3 do
         res[r] = {}
         for c = 0, 3 do
             res[r][c] = grid[c][r]
         end
     end
 
     grid = res
 end
 
 function rotateClockwise()
 	transpose() --Transposing then reversing the order of the rows is equivalent to rotating the grid clockwise
 	reverseRows()
 end
 
 function rotateCounterClockwise()
 	transpose() --Transposing then reversing the order of the columns is equivalent to rotating the grid counterclockwise
 	reverseColumns()
 end
 
 function reverseRows()
 	for r = 0, 3 do
 		grid[r][0], grid[r][3] = grid[r][3], grid[r][0] --Swap the first and fourth values
 		grid[r][1], grid[r][2] = grid[r][2], grid[r][1] --Swap the second and third values
 	end
 end
 
 function reverseColumns()
 	for c = 0, 3 do
 		grid[0][c], grid[3][c] = grid[3][c], grid[0][c] --Swap the first and fourth values
 		grid[1][c], grid[2][c] = grid[2][c], grid[1][c] --Swap the second and third values
 	end
 end
 
 function collapseLeft()
 	--For each empty (0) cell, shift the next non-zero number into the cell
 	--For each cell with a number, merge with an equal number to the right if possible
 	local hadMove = false
 	local tempC
 
 	for r = 0, 3 do --For each row
 		for c = 0, 3 do --For each column in row r
 			if grid[r][c] == 0 then
 				--Find the next non-zero and shift it here
 				tempC = c + 1
 				while tempC < 4 and grid[r][tempC] == 0 do
 					tempC = tempC + 1
 				end
 				if tempC < 4 then
 					hadMove = true
 					grid[r][c] = grid[r][tempC]
 					grid[r][tempC] = 0
 				end
 			end
 			--Check for merges
 			--If the next non-zero in the row matches this cell then merge
 			tempC = c + 1
 			while tempC < 4 and grid[r][tempC] == 0 do
 				tempC = tempC + 1
 			end
 			if grid[r][c] == grid[r][tempC] then
 				hadMove = true
 				score = score + grid[r][c] + grid[r][tempC]
 				grid[r][c] = grid[r][c] + grid[r][tempC]
 				grid[r][tempC] = 0
 			end
 		end
 	end
 
 	return hadMove
 end
 
 function isGameOver()
 	--If there are any zeroes in the grid then there's a valid move
 	--Otherwise, if the cell to the right or underneath the current
 	--	cell has the same value then a merge is possible.
 	local r = 0
 	while r < 4 do
 		local c = 0
 		while c < 4 do
 			if grid[r][c] == 0 then
 				return false
 			elseif r < 3 and grid[r][c] == grid[r+1][c] then
 				return false
 			elseif c < 3 and grid[r][c] == grid[r][c+1] then
 				return false
 			end
 			c = c + 1
 		end
 		r = r + 1
 	end
 
 	return true
 end
 
 function moveLeft()
 	return collapseLeft()
 end
 
 function moveRight()
 	--Mirror the grid so it can be collapsed to the left, then mirror it back
 	reverseRows()
 	hadMove = collapseLeft()
 	reverseRows()
 	return hadMove
 end
 
 function moveDown()
 	--Rotate the grid so it's down becomes left, collapse, revert
 	rotateClockwise()
 	hadMove = collapseLeft()
 	rotateCounterClockwise()
 	return hadMove
 end
 
 function moveUp()
 	--Rotate the grid so it's up becomes left, collapse, revert
 	rotateCounterClockwise()
 	hadMove = collapseLeft()
 	rotateClockwise()
 	return hadMove
 end
 
 function introShiftColumns(column, counter)
 	--Weird, hacky code to animate the intro sequence.
 	counter = counter - column
 	if counter >= 0 and counter < 3 then
 		grid[counter + 1][column] = grid[counter][column]
 		grid[counter][column] = 0
 	elseif counter >= 0 and counter < 5 then
 		grid[5 - counter][column] = grid[5 - counter + 1][column]
 		grid[5 - counter + 1][column] = 0
 	end
 end
 
 function intro()
 	--This is a bit ugly
 	clearGrid()
 	for counter = 0, 8 do
 		if counter == 0 then
 			grid[0][0] = 2
 		elseif counter == 1 then
 			grid[0][1] = -1
 		elseif counter == 2 then
 			grid[0][2] = 4
 		elseif counter == 3 then
 			grid[0][3] = 8
 		end
 		drawScreen(true)
 		sleep(ANIMATION_TIME)
 		for i = 0, 3 do
 			introShiftColumns(i, counter)
 		end
 	end
 	--Color cycle
 	for counter = 0, 10 do
 		drawSquare(1, 0, 2, true)
 		drawSquare(1, 1, -1, true)
 		drawSquare(1, 2, 4, true)
 		drawSquare(1, 3, 8, true)
 		sleep(ANIMATION_TIME)
 	end
 	m.setBackgroundColor(colors.black)
 	if isValidMonitorConnected then
 		m.setCursorPos(termWidth / 2 - string.len("Touch to begin") / 2 + 1, tlGridY + 7)
 		m.write("Touch to begin")
 		m.setCursorPos(tlGridX + 1, tlGridY + 9)
 		m.write("Controls: Click")
 		m.setCursorPos(tlGridX + 1, tlGridY + 10)
 		m.write("a side to move.")
-		_, _, x, y = os.pullEvent("monitor_touch") --Wait for click after intro
+		_, _, x, y = sapphUtils.pullEvent("monitor_touch") --Wait for click after intro
 		if x == termWidth and y == 1 then --If quit was pressed
-			error() --Ghetto quit
+		while true do sapphUtils.pullEvent() end	 --Ghetto quit
 		end
 	else
 		m.setCursorPos(termWidth / 2 - string.len("Press any key...") / 2 + 1, tlGridY + 7)
 		m.write("Press any key...")
-		_, keycode = os.pullEvent("key") --Wait for keypress after intro
+		_, keycode = sapphUtils.pullEvent("key") --Wait for keypress after intro
 		if keys.getName(keycode) == "x" then --If quit was pressed
 			m.setBackgroundColor(colors.black)
 			m.clear()
-			error() --Ghetto quit
+			while true do sapphUtils.pullEvent() end --Ghetto quit
 		end
 	end
 end
 
  --
  --MAIN GAME LOOP
  --
 grid = {} --Main 2D array for the game grid
 score = 0 --Score is the sum of all merges performed during a game
 
 isValidMonitorConnected = getMonitor() --Detect a monitor for output instead of the term if one is connected
 if isValidMonitorConnected then
 	termWidth, termHeight = m.getSize()
 	tlGridX = termWidth / 2 - 7 --Top left X coord of the game grid (not including borders)
 	tlGridY = 3 --Top left Y coord of the game grid (not including borders)
 else
 	m = term --Use the computer's terminal as output
 	termWidth, termHeight = term.getSize()
 	tlGridX = termWidth / 2 - 7
 	tlGridY = 3
 end
 
 if not m.isColor() then --Color monitors/computers only
 	print("An advanced monitor or computer is required.")
 	print("Press any key to exit...")
-	os.pullEvent("key")
+	sapphUtils.pullEvent("key")
 	return
 end
 
 while true do
 	intro() --Comment this out to disable the intro.  I won't judge
 	clearGrid() --Initialize the game board array
 
 	--Place the initial two tiles
 	score = 0
 	placeNewTile()
 	placeNewTile()
 	drawScreen()
 
 	--Begin main round loop
 	gameOver = false
 	hadMove = false
 	while not gameOver do
 		hadMove = false
 		if isValidMonitorConnected then --Use touch if a monitor is being used
 			--Detect a click event for the buttons
-			_, _, xT, yT = os.pullEvent("monitor_touch")
+			_, _, xT, yT = sapphUtils.pullEvent("monitor_touch")
 			--If a direction button was pressed
 			if yT >= tlGridY - 1 and yT <= tlGridY + 1 and xT >= tlGridX + 4 and xT <= tlGridX + 11 then
 				hadMove = moveUp()
 			elseif yT >= tlGridY + 9 and yT <= tlGridY + 12 and xT >= tlGridX + 4 and xT <= tlGridX + 11 then
 				hadMove = moveDown()
 			elseif yT >= tlGridY + 3 and yT <= tlGridY + 8 and xT >= tlGridX - 1 and xT <= tlGridX + 3 then
 				hadMove = moveLeft()
 			elseif yT >= tlGridY + 3 and yT <= tlGridY + 8 and xT >= tlGridX + 12 and xT <= tlGridX + 16 then
 				hadMove = moveRight()
 			elseif yT == CONTROLS_Y and xT >= (termWidth / 2 - string.len("RESET") / 2 + 1) and xT <= termWidth / 2 - string.len("RESET") / 2 + 1 + string.len("RESET") then
 				hadMove = false
 				gameOver = true --Reset button hit
 			elseif yT == 1 and xT == termWidth then
 				m.setBackgroundColor(colors.black)
 				m.clear()
 				return --Quit
 			end
 		else --Use keyboard controls if playing directly on a computer
 			_, keycode = os.pullEvent("key")
 			if keys.getName(keycode) == "up" then
 				hadMove = moveUp()
 			elseif keys.getName(keycode) == "down" then
 				hadMove = moveDown()
 			elseif keys.getName(keycode) == "left" then
 				hadMove = moveLeft()
 			elseif keys.getName(keycode) == "right" then
 				hadMove = moveRight()
 			elseif keys.getName(keycode) == "r" then --Reset
 				hadMove = false
 				gameOver = true
 			elseif keys.getName(keycode) == "x" then --Quit
 				m.setBackgroundColor(colors.black)
 				m.clear()
 				m.setCursorPos(1,1)
 				return --Quit
 			end
 		end
 
 		if hadMove then
 			placeNewTile()
 			drawGrid()
 			drawScore()
 		end
 
 		if isGameOver() then
 			gameOver = true
 		end
 	end
 
 	--Draw game over
 	m.setTextColor(colors.white)
 	m.setBackgroundColor(colors.red)
 	m.setCursorPos(termWidth / 2 - string.len("GAME OVER") / 2 + 1, CONTROLS_Y - 1)
 	m.write("GAME OVER")
 	m.setBackgroundColor(colors.black)
 	if isValidMonitorConnected then
 		m.setCursorPos(termWidth / 2 - string.len("Touch to reset...") / 2 + 1, CONTROLS_Y)
 		m.write("Touch to reset...")
 		--Wait for any click to continue
-		os.pullEvent("monitor_touch")
+		sapphUtils.pullEvent("monitor_touch")
 	else
 		m.setCursorPos(termWidth / 2 - string.len("Press any key...") / 2 + 1, CONTROLS_Y)
 		m.write("Press any key...")
 		--Wait for any click to continue
-		os.pullEvent("key")
+		sapphUtils.pullEvent("key")
 	end
 end
 while true do
   sapphUtils.pullEvent()
 --keeps sapphari on "life support"
 end