-- Tetris by MKmisfit

 --level increases every 10 lines cleared
 --score rewards increase by 100% per 5 levels
 --speed increases by 100% per 10 levels

 --

local timerLength = 0.5
local timerLengthMin = 0.05

local pieceX
local pieceY
local pieceR
local pieceType
local nextPieceType
local score
local level
local gameOver

local pieceArray = {
{ {0,0},{-1,0},{1,0},{0,1} },
{ {0,0},{-1,0},{-2,0},{1,0} },
{ {0,0},{-1,0},{0,1},{1,1} },
{ {0,0},{-1,1},{0,1},{1,0} },
{ {0,0},{1,0},{0,1},{1,1} },
{ {0,0},{-1,0},{1,0},{1,1} },
{ {0,0},{-1,0},{1,0},{-1,1} }
}

local pieceColor = {colors.magenta, colors.lightBlue, colors.red, colors.lime, colors.yellow, colors.blue, colors.orange}

local numPieces = 7

local boardArray
local boardWidth = 12
local boardHeight = 21
local edgeColor = colors.white
local boardColor = colors.black

local boardX = 8
local boardY = -1
local scoreX = 26
local scoreY = 3
local nextPieceX = 26
local nextPieceY = 8

local highScore = {}
local saveFile = "tetris_scores"

local function loadHighScore()

	if fs.exists(saveFile) then
		local file = fs.open(saveFile,"r")
		for n = 1, 10 do
			highScore[n] = {file.readLine(), tonumber(file.readLine())}
		end
		file.close()
	else
		for n = 1, 10 do
			highScore[n] = {"", 0}
		end
	end
end

local function saveHighScore()
	local file = fs.open(saveFile,"w")

	for n = 1, 10 do
		file.write(highScore[n][1].."\n")
		file.write(tostring(highScore[n][2]).."\n")
	end
	file.close()
end

local function testHighScore()
	for n = 1, 10 do
		if score > highScore[n][2] then
			term.setCursorPos(1,1)
			term.write("You got a High Score!")
			term.setCursorPos(1,2)
			term.write("Enter your name: ")
			name = string.sub(io.read(), 1, 16)
			name = name .. string.sub("                  ", 1, 18 - string.len(name))
			table.insert(highScore, n, {name, score})
			return true
		end
	end
	return false
end

local function drawCredits()
	term.setCursorPos(1,1)
	term.write("Tetris")
	term.setCursorPos(1,2)
	term.write("Original by Alexey Pajitnov circa 1984")
	term.setCursorPos(1,3)
	term.write("Lua adaptation by MKmisfit")
	term.setCursorPos(1,4)
	term.write("arrow keys move, (1, 2) keys rotate, ENTER pauses")

	if highScore[1][2] > 0 then
		term.setCursorPos(1,6)
		term.write("High Scores")
		for n = 1, 10 do
			if highScore[n][2] == 0 then break end
			term.setCursorPos(1,n+6)
			term.write(highScore[n][1] .. highScore[n][2])
		end
	end

end

local function testPiece(piece, x, y, rotation)
	if rotation == 0 then
		for i = 1, 4 do
			if boardArray[x + piece[i][1]][y + piece[i][2]] ~= boardColor then
				return true
			end
		end
	end
	if rotation == 1 then
			for i = 1, 4 do
			if boardArray[x - piece[i][2]][y + piece[i][1]] ~= boardColor then
				return true
			end
		end
	end
	if rotation == 2 then
			for i = 1, 4 do
			if boardArray[x - piece[i][1]][y - piece[i][2]] ~= boardColor then
				return true
			end
		end
	end
	if rotation == 3 then
			for i = 1, 4 do
			if boardArray[x + piece[i][2]][y - piece[i][1]] ~= boardColor then
				return true
			end
		end
	end

	return false
end

local function setPiece(piece, x, y, rotation, color)
	if rotation == 0 then
		for i = 1, 4 do
			boardArray[x + piece[i][1]][y + piece[i][2]] = color
		end
	end
	if rotation == 1 then
		for i = 1, 4 do
			boardArray[x - piece[i][2]][y + piece[i][1]] = color
		end
	end
	if rotation == 2 then
		for i = 1, 4 do
			boardArray[x - piece[i][1]][y - piece[i][2]] = color
		end
	end
	if rotation == 3 then
		for i = 1, 4 do
			boardArray[x + piece[i][2]][y - piece[i][1]] = color
		end
	end

	--test for completed lines
	local minX = 2
	local maxX = boardWidth - 1
	local minY = y - 2
	local maxY = y + 2

	local hasPixels
	local linesCleared = 0

	if minY < 3 then minY = 3 end
	if maxY >= boardHeight then maxY = boardHeight - 1 end

	for by = minY, maxY do
	for bx = minX, maxX do
		if boardArray[bx][by] == boardColor then break end
		if bx == maxX then
			linesCleared = linesCleared + 1
			for copyy = by - 1, 2, -1 do
				term.setCursorPos(minX + boardX, copyy + 1 + boardY)
				hasPixels = false
				for copyx = minX, maxX do
					term.setBackgroundColor(boardArray[copyx][copyy])
					term.write(" ")
					hasPixels = hasPixels or (boardArray[copyx][copyy] ~= boardColor)
					boardArray[copyx][copyy + 1] = boardArray[copyx][copyy]
				end
				if not hasPixels then break end
				--clear top line
				if copyy == 2 then
					term.setCursorPos(minX + boardX, copyy + boardY)
					term.setBackgroundColor(boardColor)
					for copyx = minX, maxX do
						term.write(" ")
						boardArray[copyx][copyy] = boardColor
					end
				end
			end
			sleep(0.5)
		end
	end
	end

	if linesCleared ~= 0 then
		if linesCleared == 1 then
			score = score + 100 * (1 + level / 5)
		end
		if linesCleared == 2 then
			score = score + 200 * (1 + level / 5)
		end
		if linesCleared == 3 then
			score = score + 400 * (1 + level / 5)
		end
		if linesCleared == 4 then
			score = score + 800 * (1 + level / 5)
		end
		score = math.floor(score)

		level = level + linesCleared * 0.1
		timerLength = 0.5 / (1 + level / 10)
		if timerLength < timerLengthMin then timerLength = timerLengthMin end

		term.setBackgroundColor(boardColor)
		term.setCursorPos(scoreX + 7, scoreY)
		term.write(tostring(score) .. "       ")
		term.setCursorPos(scoreX + 7, scoreY + 1)
		term.write(tostring(math.floor(level)) .. "       ")
	end
end

local function drawPiece(piece, x, y, rotation, color)
	if rotation == 0 then
		for i = 1, 4 do
			term.setCursorPos(x + piece[i][1], y + piece[i][2])
			term.setBackgroundColor(color)
			term.write(" ")
		end
	end
	if rotation == 1 then
		for i = 1, 4 do
			term.setCursorPos(x - piece[i][2], y + piece[i][1])
			term.setBackgroundColor(color)
			term.write(" ")
		end
	end
	if rotation == 2 then
		for i = 1, 4 do
			term.setCursorPos(x - piece[i][1], y - piece[i][2])
			term.setBackgroundColor(color)
			term.write(" ")
		end
	end
	if rotation == 3 then
		for i = 1, 4 do
			term.setCursorPos(x + piece[i][2], y - piece[i][1])
			term.setBackgroundColor(color)
			term.write(" ")
		end
	end
end

local function dropNewPiece()
	pieceX = boardWidth / 2
	pieceY = 2
	pieceType = nextPieceType
	nextPieceType = math.floor(math.random(1, numPieces + 0.999))
	pieceR = 0

	if testPiece(pieceArray[pieceType], pieceX, pieceY, pieceR) then
		gameOver = true
	end

	drawPiece(pieceArray[pieceType], nextPieceX + 2, nextPieceY + 2, 0, boardColor)
	drawPiece(pieceArray[nextPieceType], nextPieceX + 2, nextPieceY + 2, 0, pieceColor[nextPieceType])
end

local function main()
	--clear the board
	for x = 1, boardWidth do
	for y = 1, boardHeight do
		if x == 1 or y == 1 or x == boardWidth or y == boardHeight then
			boardArray[x][y] = edgeColor
			if y > 1 and y < boardHeight then
				term.setCursorPos(x + boardX, y + boardY)
				term.setBackgroundColor(edgeColor)
				term.write(" ")
			end
		else
			boardArray[x][y] = boardColor
			term.setCursorPos(x + boardX, y + boardY)
			term.setBackgroundColor(boardColor)
			term.write(" ")
		end
	end
	end

	term.setBackgroundColor(boardColor)
	term.setCursorPos(scoreX, scoreY)
	term.write("Score: 0       ")
	term.setCursorPos(scoreX, scoreY + 1)
	term.write("Level: 0       ")
	term.setCursorPos(nextPieceX, nextPieceY)
	term.write("Next:")

	gameOver = false
	score = 0
	level = 0
	nextPieceType = math.floor(math.random(1, numPieces + 0.999))
	dropNewPiece()

	local event, param
	timer1 = os.startTimer(timerLength)
	while true do
		event, param = os.pullEvent()

		if event == "timer" and param == timer1 then
			if testPiece(pieceArray[pieceType], pieceX, pieceY + 1, pieceR) then
				setPiece(pieceArray[pieceType], pieceX, pieceY, pieceR, pieceColor[pieceType])
				dropNewPiece()
				drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
			else
				drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
				pieceY = pieceY + 1
				drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
			end

			if gameOver then
				break
			end

			timer1 = os.startTimer(timerLength)
		end

		if event == "key" then
			if param == 203 then
				if not testPiece(pieceArray[pieceType], pieceX - 1, pieceY, pieceR) then
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
					pieceX = pieceX - 1
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
				end
			elseif param == 205 then
				if not testPiece(pieceArray[pieceType], pieceX + 1, pieceY, pieceR) then
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
					pieceX = pieceX + 1
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
				end
			elseif param == 208 then
				if not testPiece(pieceArray[pieceType], pieceX, pieceY + 1, pieceR) then
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
					pieceY = pieceY + 1
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
					score = score + 2
					term.setBackgroundColor(boardColor)
					term.setCursorPos(scoreX + 7, scoreY)
					term.write(tostring(score) .. "       ")
				end
			elseif param == 2 then
				if not testPiece(pieceArray[pieceType], pieceX, pieceY, (pieceR + 1) % 4) then
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
					pieceR = (pieceR + 1) % 4
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
				end
			elseif param == 3 then
				if not testPiece(pieceArray[pieceType], pieceX, pieceY, (pieceR + 3) % 4) then
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, boardColor)
					pieceR = (pieceR + 3) % 4
					drawPiece(pieceArray[pieceType], pieceX + boardX, pieceY + boardY, pieceR, pieceColor[pieceType])
				end
			elseif param == 28 then
				term.setBackgroundColor(boardColor)
				term.setCursorPos(scoreX, scoreY + 1)
				term.write("Paused")

				repeat
					event, param = os.pullEvent()
				until event == "key" and param == 28

				term.setCursorPos(scoreX, scoreY + 1)
				term.write("      ")
				timer1 = os.startTimer(timerLength)
			end
		end
	end
end

boardArray = {}
for x = 1, boardWidth do
	boardArray[x] = {}
end

loadHighScore()
term.setBackgroundColor(boardColor)
term.clear()
drawCredits()
term.setCursorPos(1,19)
term.write("Press ENTER to continue")
repeat
	event, param = os.pullEvent()
until event == "key" and param == 28
term.clear()

main()

term.setBackgroundColor(colors.black)
term.clear()
if testHighScore() then
	saveHighScore()
	term.clear()
end
drawCredits()
term.setCursorPos(1,17)
term.write("Your final score was " .. tostring(score))
term.setCursorPos(1,18)
term.write("Thank You for Playing!")
term.setCursorPos(1,19)