brickScaleX = 3

function DrawPaddle (x, y, color)
	paintutils.drawPixel(x - 2, y, color)
	paintutils.drawPixel(x - 1, y, color)
	paintutils.drawPixel(x, y, color)
	paintutils.drawPixel(x + 1, y, color)
	paintutils.drawPixel(x + 2, y, color)
end

function DrawBlocks (blocks, blocks_horizontal)
	for i = 1, #blocks do
		local x, y
		x = math.floor((i % blocks_horizontal - 1) * brickScaleX) + 1
		y = math.floor(i / blocks_horizontal)
		paintutils.drawPixel(x, y, blocks[i])
		paintutils.drawPixel(x + 1, y, blocks[i])
		paintutils.drawPixel(x + 2, y, blocks[i])
	end
end

function Game ()
	local blocks = {}

	-- Get terminal size
	local width, height = term.getSize()

	-- Set game size
	local blocks_horizontal = math.floor(width / brickScaleX)
	local blocks_vertical = math.floor(height * .4)

	local paddleX = math.floor(blocks_horizontal / 2)
	local paddlePrevX = 1

	local ballX = paddleX
	local ballY = height - 2
	local velocity = 1
	local angle = math.pi / -4

	local prevX = 1
	local prevY = math.floor(height * .6) -- Put inital value off in the woods so it doesn't mess with anything

	local score = 0

	-- Randomize blocks
	for j=1, blocks_vertical do
		for i=1, blocks_horizontal do
			blocks[i + (j-1) * blocks_horizontal] = bit.blshift(1, math.random(0, 14))
		end
	end

	-- Clear screen
	term.clear()

	-- Main loop
	while true do
		-- Erase old positions
		DrawPaddle (paddlePrevX * brickScaleX, height - 1, colors.black)
		paintutils.drawPixel(prevX * brickScaleX, prevY, colors.black)

		-- Update screen
		DrawBlocks (blocks, blocks_horizontal)
		DrawPaddle (paddleX * brickScaleX, height - 1, colors.yellow)
		paintutils.drawPixel(ballX * brickScaleX, ballY, colors.white)
		term.setCursorPos(1, height)
		term.setBackgroundColor(colors.black)
		term.write('Score: ' .. score .. '     ' .. velocity .. ' ' .. angle)

		-- Save old position
		prevX = ballX
		prevY = ballY

		-- Convert velocity vector to rectangular
		velX = velocity * math.cos(angle)
		velY = velocity * math.sin(angle)

		-- Move ball
		ballX = ballX + velX
		ballY = ballY + velY

		-- Check collision with walls
		if ballX <= 1 or (ballX * brickScaleX) >= width then
			velX = -1 * velX
			ballX = prevX + velX
		end
		if ballY <= 1 or ballY >= height then
			velY = -1 * velY
			ballY = prevY + velY
		end

		-- Check for collision with balls
		for i = 1, #blocks do
			if blocks[i] ~= colors.black then
				local blockX, blockY
				blockX = math.floor((i % blocks_horizontal - 1)) + 1
				blockY = math.floor(i / blocks_horizontal)

				if blockX == math.floor(ballX) and blockY == math.floor(ballY) then
					blocks[i] = colors.black
					score = score + 100
					if velY <= 0 then
						velY = -1 * velY
						ballY = prevY + velY
					end
				end
			end
		end

		-- Convert velocity vector back to polar
		--velocity = math.sqrt(math.pow(velX, 2) + math.pow(velY, 2))
		angle = math.atan(velX / velY)

		-- Change velocity based on score
		velocity = math.floor(1 + score * 0.0005)

		-- Sleep until next tick
		os.sleep(0.25)
	end
end

Game()