Builder

local API = {}
local world = require("component").debug.getWorld()

function swap(first, second)
	return second, first
end

function setline(x0, y0, z0, x1, y1, z1, block_id, block_meta)
	world.setBlocks(x0, y0, z0, x1, y1, z1, block_id, block_meta)
end

function API.line(x0, y, z0, x1, z1, height, block_id, block_meta)

	local steep = (math.abs(z1 - z0) > math.abs(x1 - x0))

	if (steep) then
		x0, z0 = swap(x0, z0)
		x1, z1 = swap(x1, z1)
	end

	if (x0 > x1) then
		x0, x1 = swap(x0, x1)
		z0, z1 = swap(z0, z1)
	end

	local dx = x1 - x0
	local dz = math.abs(z1 - z0)

	local error = dx / 2.0

	local zstep
	if (z0 < z1) then zstep = 1 else zstep = -1 end

	local z = z0
	local maxx = x1

	for x=x0, maxx do
		if (steep) then
			setline(z, y, x, z, y+height-1, x, block_id, block_meta)
		else
			setline(x, y, z, x, y+height-1, z, block_id, block_meta)
		end

		error = error - dz
		if (error < 0) then
			z = z + zstep
			error = error + dx
		end
	end

	return -1, "Operation completed"
end

function API.patternreplace(x0, y0, z0, xbound, zbound, n, block_id, block_meta)
	for i=0, xbound-x0, n do
		for j=0, zbound-z0, n do
			setline(x0 + i, y0, z0 + j, x0 + i, y0, z0 + j, block_id, block_meta)
			setline(x0 + i, y0, z0 - j, x0 + i, y0, z0 - j, block_id, block_meta)
			setline(x0 - i, y0, z0 + j, x0 - i, y0, z0 + j, block_id, block_meta)
			setline(x0 - i, y0, z0 - j, x0 - i, y0, z0 - j, block_id, block_meta)
		end
	end
	print("Operation Complete.")
	return -1, "Operation Complete."
end

function API.ellipse(orig_x, orig_y, orig_z, height, width, height2, block_id, block_meta, filled)
	a2 = width * width
	b2 = height * height
	fa2 = 4 * a2
	fb2 = 4 * b2


	z = height2 - 1
	x = 0
	y = height
	sigma = 2 * b2+a2*(1-2*height)
	print(z, height)


	-- first half
	while b2*x <= a2*y do
	--  setline(orig_x + x, orig_y, orig_z + y, orig_x - x, orig_y, orig_z - y)
		if (filled == 1) then
			setline(orig_x + x, orig_y+z, orig_z - y, orig_x + x, orig_y+z, orig_z + y, block_id, block_meta)
			setline(orig_x - x, orig_y+z, orig_z - y, orig_x - x, orig_y+z, orig_z + y, block_id, block_meta)
		else
			setline(orig_x + x, orig_y, orig_z + y, orig_x + x, orig_y+z, orig_z + y, block_id, block_meta)
			setline(orig_x + x, orig_y, orig_z - y, orig_x + x, orig_y+z, orig_z - y, block_id, block_meta)
			setline(orig_x - x, orig_y, orig_z + y, orig_x - x, orig_y+z, orig_z + y, block_id, block_meta)
			setline(orig_x - x, orig_y, orig_z - y, orig_x - x, orig_y+z, orig_z - y, block_id, block_meta)
		end

		if (sigma >= 0) then
			sigma = sigma + (fa2 * (1-y))
			y = y-1
		end
		sigma = sigma +  (b2 * ((4 * x) + 6))
		x = x + 1
	end

	x = width
	y = 0
	sigma = 2*a2+b2*(1-2*width)

	while (a2*y <= b2*x) do
		if (filled == 1) then
			setline(orig_x + x, orig_y+z, orig_z + y, orig_x - x, orig_y+z, orig_z + y, block_id, block_meta)
			setline(orig_x + x, orig_y+z, orig_z - y, orig_x - x, orig_y+z, orig_z - y, block_id, block_meta)
		else
	--  setline(orig_x + x, orig_y+z, orig_z + y, orig_x - x, orig_y+z, orig_z + y)
			setline (orig_x + x, orig_y+z, orig_z + y, orig_x + x, orig_y, orig_z + y, block_id, block_meta)
			setline (orig_x + x, orig_y+z, orig_z - y, orig_x + x, orig_y, orig_z - y, block_id, block_meta)
	--  setline(orig_x + x, orig_y, orig_z - y, orig_x - x, orig_y, orig_z - y)
			setline (orig_x - x, orig_y+z, orig_z + y, orig_x - x, orig_y, orig_z + y, block_id, block_meta)
			setline (orig_x - x, orig_y+z, orig_z - y, orig_x - x, orig_y, orig_z - y, block_id, block_meta)
		end

		if (sigma >= 0) then
			sigma = sigma + (fb2 * (1 - x))
			x = x - 1
		end

		sigma = sigma + (a2 * ((4 * y) + 6))

		y = y + 1
	end
end

function API.findMarkerInRange(x0, y, z0, x1, z1, marker_id, marker_meta)
	local output = {}
	for z=z0, z1 do
		for x=x0, x1 do
			if (world.getBlockId(x, y, z) == marker_id and world.getMetadata(x, y, z) == marker_meta) then
				output.insert({x=x, y=y, z=z})
			end
			print (x, y, z)
			--.yield()
		end
	end

	return output
end

function API.lineFromMarkers(self, x, y, z, x1, y1, marker_id, marker_meta, height, block_id, block_meta)
	local mycoords = findMarkerInRange(x, y, z, x1, y1, marker_id, marker_meta)
	if (mycoords.getn == 2) then
		line(mycoords[1].x, mycoords[1].y, mycoords[1].z, mycoords[2].x, mycoords[2].y, height, block_id, block_meta)
	end
end

function API.ellipseFromMarkers(self, x, y, z, x1, y1, center_marker_id, center_marker_meta, length_marker_id, length_marker_meta, width_marker_id, width_marker_meta, height, block_id, block_meta, filled)
	local center = {}
	local length = {}
	local width = {}

	center = findMarkerInRange(x, y, z, x1, y1, center_marker_id, center_marker_meta)
	length = findMarkerInRange(x, y, z, x1, y1, length_marker_id, length_marker_meta)
	width = findMarkerInRange(x, y, z, x1, y1, width_marker_id, width_marker_meta)

	dumpvar(center)
	dumpvar(length)
	dumpvar(width)

	--ellipse(center.x, center.y, center.x, actual_length.x+actual_length.y, actual_width.x+actual_width.y, height, block_id, block_meta, filled)
end

return API