View difference between Paste ID: qYUwj0LR and 0gsKnS4u

 function getAccessPoints()
---		Code by minecraft: montana_1
+
---		please send comments or questions to [email protected] with a subject I might read
+
---
+
---		Description of code:
+
---			This is a program written for use in minecraft with the mod "OpenComputers"
+
---			This is the server side or host code for a single computer or possible micro-controller to broadcast
+
---			a signal from a minimum of 4 (possibly more but not tested) access points containing there predetermined
+
---			co-ordinates which are entered into the program upon first run and saved in a file for later use.
+
---			The co-ordinates can then be determined by a client program from this information
+
---		Note:
+
---			Because the co-ordinates are calculated by the distance from each access point,
+
---			it is very important that all other access points within range are set to NOT REPEAT.
+
---			Which by default is ON. If you do not know how to change this, there is another program
+
---			on my pastebin account (montana_1) that will first find all access points on a network
+
---			and second set there range to zero and turn Repeating OFF. This is good practice with any programs
+
---			to turn the access points effectively off when not being immediately used to save power and
+
---			prevent errors.
+
---		Also Note:
+
---			The timings for this program are set so that there are no processors placed within the access points
+
-]]--
+
 		print(component.proxy(accessPoints[i]).isRepeater())
 	end
 end
 
 function testPointEquality(p1,p2)
 	if(p1[2] == p2[2] and p1[3] == p2[3] and p1[4] == p2[4]) then
 	return true
 	else return false
 	end
 end
 
 function getGPSCoordinates(timeOut)
 	local computer = require("computer")
 	local timer = computer.uptime()
 	while(computer.uptime() - timer < timeOut*4) do
 		local event = require("event")
 		local points = {}
 		local eventType, recieverAddress, senderAddress, port, distenace, x,y,z = event.pull(timeOut, "modem_message")
 		if(eventType ~= nil) then
 			points[1] = {distenace, x,y,z}
 			--print(points[1][1])
 		else
 			return nil
 		end
 		while #points < 4 and computer.uptime() - timer < timeOut*4 do
 			local eventType, recieverAddress, senderAddress, port, distenace, x,y,z = event.pull(timeOut, "modem_message")
 			local tmp = {distenace, x,y,z}
 			local same = false
 			for i=1, #points do
 				if(testPointEquality(points[i], tmp)) then
 					same = true
 					--print("Same point!")
 					break
 				end
 			end
 			if(not same) then
-        local t={} ; i=0
+				points[#points+1] = tmp
 				--print("Point added:".. tostring(tmp[1]))
 			end
 		end
 		return points
 	end
 end
 
 function split(inputstr, sep)
 	if(inputstr == nil or inputstr == "") then
                 return nil
-turnOffRepeaters(accessPoints)
+
         if sep == nil then
                 sep = ","
         end
-if(#accessPoints+1 < 4) then
+        local t={} ; i=1
-	print("Insuficient access_points, 4 are required you have (".. #accessPoints+1 ..")")
+
-	error()
+
                 i = i + 1
         end
         return t
 end
 
 function addVector(p1,p2)
 	--p1 + p2
 	return {p1[1]+p2[1], p1[2]+p2[2], p1[3]+p2[3]}
 end
 
 function subtractVector(p1,p2)
 	--p1 - p2
 	return {p1[1]-p2[1], p1[2]-p2[2], p1[3]-p2[3]}
 end
 
 function scaleVector(p1, scalar)
 	--p1 * scalar
 	return {p1[1]*scalar, p1[2]*scalar, p1[3]*scalar}
-		print("Enter coordinates (x,y,z) for access_point: " .. accessPoints[i])
+
-		local tmp = term.read()
+
-		hostCoordinates[i] = split(accessPoints[i]..","..tmp,",")
+function dotVector(p1,p2)
-		file:write(accessPoints[i]..","..tmp)
+	return p1[1]*p2[1] + p1[2]*p2[2] + p1[3]*p2[3]
 end
 
 function crossVector(p1,p2)
 	return {p1[2]*p2[3] - p1[3]*p2[2], p1[3]*p2[1] - p1[1]*p2[3], p1[1]*p2[2] - p1[2]*p2[1]}
 end
 
-	for i=0, #hostCoordinates do
+function magnitudeVector(p1)
-		io.write(i..": "..hostCoordinates[i][0].." "..hostCoordinates[i][1]..","..hostCoordinates[i][2]..","..hostCoordinates[i][3])
+	return math.sqrt(math.pow(p1[1], 2) + math.pow(p1[2], 2) + math.pow(p1[3], 2))
-		component.setPrimary("access_point",hostCoordinates[i][0])
+
-		print("Primary set")
+
-		component.proxy(hostCoordinates[i][0]).setStrength(signal_strength)
+function normalizeVector(p1)
-		component.modem.broadcast(gps_port, tonumber(hostCoordinates[i][1]),tonumber(hostCoordinates[i][2]),tonumber(hostCoordinates[i][3]))
+	return p1/magnitudeVector(p1)
-		os.sleep(0.25)
+
-		component.getPrimary("access_point").setStrength(0)
+
-		os.sleep(1)
+function rotateVectorZAxis(p1,theta)
 	return {p1[1]*math.cos(theta) - p1[2]*math.sin(theta), p1[1]*math.sin(theta) + p1[2]*math.cos(theta), p1[3]}
-end
+
 
 function rotateVectorXAxis(p1,theta)
 	return {p1[1], p1[2]*math.cos(theta) - p1[3]*math.sin(theta), p1[2]*math.sin(theta) + p1[3]*math.cos(theta)}
 end
 
 function rotateVectorYAxis(p1,theta)
 	return {p1[1]*math.cos(theta) + p1[3]*math.sin(theta), p1[2], p1[3]*math.cos(theta) - p1[1]*math.sin(theta)}
 end
 
 function tostringVector(p1)
 	return tostring(p1[1]) .. "," .. tostring(p1[2]) .. "," .. tostring(p1[3])
 end
 
 function tonumberVector(p1)
 	return {tonumber(p1[1]), tonumber(p1[2]), tonumber(p1[3])}
 end
 
 function distanceBetweenPoints(p1,p2)
 	return math.sqrt(math.pow(p1[1]-p2[1],2) + math.pow(p1[2]-p2[2],2) + math.pow(p1[3]-p2[3],2))
 end
 
 function findPossiblePoints2D(d1,p1,d2,p2)
 	local distance = distanceBetweenPoints(p1,p2)
 	local a = (math.pow(d1, 2) - math.pow(d2, 2) + math.pow(distance, 2)) / (2 * distance)
 	--print(a)
 	local intersect = addVector(p1,scaleVector(scaleVector(subtractVector(p2,p1), a), (1/distance)))
 	--print(tostringVector(intersect))
 	local h = math.sqrt(math.pow(d1, 2) - math.pow(a, 2))
 	--print(h)
 	local x_plus = intersect[1] + ((h*(p2[2]-p1[2]))/distance)
 	local x_minus = intersect[1] - ((h*(p2[2]-p1[2]))/distance)
 	local y_plus = intersect[2] + ((h*(p2[1]-p1[1]))/distance)
 	local y_minus = intersect[2] - ((h*(p2[1]-p1[1]))/distance)
 	return {x_plus,y_minus,0}, {x_minus,y_plus,0}
 end
 
 function findPossiblePoints3D(d1,p1,d2,p2,d3,p3)
 
 	--print(tostringVector(p1)..";"..tostringVector(p2)..";"..tostringVector(p3))
 
 	--offset vectors such that p1 is at 0,0,0
 	local offset = scaleVector(p1, -1)
 	--print("Offset: "..tostringVector(offset))
 	local p1p = addVector(p1, offset)
 	--print("p1p: "..tostringVector(p1p))
 	local p2p = addVector(p2, offset)
 	--print("p2p: "..tostringVector(p2p))
 	local p3p = addVector(p3, offset)
 	--print("p3p: "..tostringVector(p3p))
 
 	--print("Offset vectors: "..tostringVector(p1p).."; "..tostringVector(p2p).."; "..tostringVector(p3p))
 
 
 	--find the equation of the plane
 	local p12 = subtractVector(p2p,p1p)
 	--print("p12: "..tostringVector(p12))
 	local p13 = subtractVector(p3p,p1p)
 	--print("p13: "..tostringVector(p13))
 	local plane = crossVector(p12,p13)
 	--print("Plane: "..tostringVector(plane))
 
 	-- checked up to here --
 
 	--rotate first about the y axis
 	local angle1 = math.atan(plane[1]/plane[3])
 	--print("Angle1: "..angle1)
 	local plane_ry = rotateVectorYAxis(plane, angle1)
 	--print("plane_ry: "..tostringVector(plane_ry))
 	local p1p_ry = rotateVectorYAxis(p1p, angle1)
 	--print("p1p_ry: "..tostringVector(p1p_ry))
 	local p2p_ry = rotateVectorYAxis(p2p, angle1)
 	--print("p2p_ry: "..tostringVector(p2p_ry))
 	local p3p_ry =rotateVectorYAxis(p3p, angle1)
 	--print("p3p_ry: "..tostringVector(p3p_ry))
 
 	--rotate second about the x axis
 	local angle2 = math.atan(plane_ry[2]/plane_ry[3])
 	--print("Angle2: "..angle2)
 	local plane_ryx = rotateVectorXAxis(plane_ry, angle2)
 	--print("plane_ryx: "..tostringVector(plane_ryx))
 	local p1p_ryx = rotateVectorXAxis(p1p_ry, angle2)
 	--print("p1p_ryx: "..tostringVector(p1p_ryx))
 	local p2p_ryx = rotateVectorXAxis(p2p_ry, angle2)
 	--print("p2p_ryx: "..tostringVector(p2p_ryx))
 	local p3p_ryx = rotateVectorXAxis(p3p_ry, angle2)
 	--print("p3p_ryx: "..tostringVector(p3p_ryx))
 
 	--at this point, the plane should lie such that all z=0
 
 	--rotate plane about the z axis such that p2 is at x = 0
 	local angle3 = (-1) * math.atan(p2p_ryx[2]/p2p_ryx[1])
 	--print("Angle3: "..angle3)
 	local plane_ryxz = rotateVectorZAxis(plane_ryx, angle3)
 	local p1p_ryxz = rotateVectorZAxis(p1p_ryx, angle3)
 	local p2p_ryxz = rotateVectorZAxis(p2p_ryx, angle3)
 	local p3p_ryxz = rotateVectorZAxis(p3p_ryx, angle3)
 
 	--at this point, p1 should be at 0,0,0; p2 should be such that y=0,z=0; and p3 should be such that z=0
 
 	--calculations for finding rotated, offset points
 	local xp_ryxz = (math.pow(d1,2) - math.pow(d2,2) + math.pow(p2p_ryxz[1],2))/(2*p2p_ryxz[1])
 	local yp_ryxz = ((math.pow(d1,2) - math.pow(d3,2) + math.pow(p3p_ryxz[1],2) + math.pow(p3p_ryxz[2],2))/(2*p3p_ryxz[2])) - ((p3p_ryxz[1]/p3p_ryxz[2])*xp_ryxz)
 	local z1p_ryxz = math.sqrt(math.pow(d1,2)-math.pow(xp_ryxz,2)-math.pow(yp_ryxz,2))
 	local z2p_ryxz = (-1) * math.sqrt(math.pow(d1,2)-math.pow(xp_ryxz,2)-math.pow(yp_ryxz,2))
 
 	--possible rotated, offset points
 	local point1p_ryxz = {xp_ryxz, yp_ryxz, z1p_ryxz}
 	local point2p_ryxz = {xp_ryxz, yp_ryxz, z2p_ryxz}
 
 	--rotate back around the z axis
 	plane_ryx = rotateVectorZAxis(plane_ryxz, (-1)*angle3)
 	local point1p_ryx = rotateVectorZAxis(point1p_ryxz, (-1)*angle3)
 	local point2p_ryx = rotateVectorZAxis(point2p_ryxz, (-1)*angle3)
 
 	--rotate back around the x axis
 	plane_ry = rotateVectorXAxis(plane_ryx, (-1)*angle2)
 	local point1p_ry = rotateVectorXAxis(point1p_ryx, (-1)*angle2)
 	local point2p_ry = rotateVectorXAxis(point2p_ryx, (-1)*angle2)
 
 	--rotate back around the y axis
 	plane = rotateVectorYAxis(plane_ry, (-1)*angle1)
 	local point1p = rotateVectorYAxis(point1p_ry, (-1)*angle1)
 	local point2p = rotateVectorYAxis(point2p_ry, (-1)*angle1)
 	--print(tostringVector(plane))
 
 	--remove offset
 	local point1 = addVector(point1p, scaleVector(offset,-1))
 	local point2 = addVector(point2p, scaleVector(offset,-1))
 
 	--print("Possible points are either: "..tostringVector(point1).." or "..tostringVector(point2))
 	return point1, point2
 
 end
 
 function narrow(p1,p2,d4,p4)
 	if(distanceBetweenPoints(p1,p4) == d4) then
 		return p1
 	end
 	if(distanceBetweenPoints(p2,p4) == d4) then
 		return p2
 	end
 end
 
 function getLocation(timeout)
 	local timeout = timeout or 2
 	local coords = getGPSCoordinates(timeout)
 	if(coords == nil) then
 		print("could not obtain")
 		return nil
 	end
 	if(#coords < 4) then
 		print("Not enough points")
 		return nil
 	end
 	local d1 = coords[1][1]
 	local p1 = {coords[1][2],coords[1][3],coords[1][4]}
 	local d2 = coords[2][1]
 	local p2 = {coords[2][2],coords[2][3],coords[2][4]}
 	local d3 = coords[3][1]
 	local p3 = {coords[3][2],coords[3][3],coords[3][4]}
 	local d4 = coords[4][1]
 	local p4 = {coords[4][2],coords[4][3],coords[4][4]}
 	local point1, point2 = findPossiblePoints3D(d1,p1,d2,p2,d3,p3)
 	local location = narrow(point1,point2,d4,p4)
 	return location
 end
 
 local term = require("term")
 local component = require("component")
 local event = require("event")
 local fileSystem = require("filesystem")
 local shell = require("shell")
 
 local accessPoints = getAccessPoints()
 local gps_port = 3665
 local signal_strength = 400
 local sleep = 0.001
 local hostCoordinates = {}
 
 component.modem.open(gps_port)
 
 if(fileSystem.exists(shell.resolve("gpsHostData"))) then
 	local file = io.open(shell.resolve("gpsHostData"), "r")
 	local i = 0
 	for line in io.lines(shell.resolve("gpsHostData")) do
 		hostCoordinates[i] = split(line,",")
 		hostCoordinates = tonumberVector({hostCoordinates[i][2],hostCoordinates[i][3],hostCoordinates[i][4]})
 		print(line)
 		i=i+1
 	end
 	file:close()
 elseif(getLocation() ~= nil) then
 	local location = getLocation()
 	print(tostringVector(location))
 	local file = io.open(shell.resolve("gpsHostData"), "a")
 	local address = component.getPrimary("modem").address
 	file:write(tostring(address)..","..tostringVector(location))
 	print("File written")
 	file:close()
 	hostCoordinates = location
 else
 	local file = io.open(shell.resolve("gpsHostData"), "a")
 	print("Location data could not be obtained, please enter in (x,y,z) coords of modem: ")
 	local tmp = term.read()
 	hostCoordinates = tonumberVector(split(tmp,","))
 	local address = component.getPrimary("modem").address
 	file:write(tostring(address)..","..tmp)
 	print("File written")
 	file:close()
 end
 
 print(hostCoordinates[1]..type(hostCoordinates[1]))
 print(hostCoordinates[2]..type(hostCoordinates[2]))
 print(hostCoordinates[3]..type(hostCoordinates[3]))
 
 
 while true do
 	component.modem.setStrength(signal_strength)
 	component.modem.broadcast(gps_port, hostCoordinates[1], hostCoordinates[2],hostCoordinates[3])
 	os.sleep(sleep)
 end
 --[[
 if(getLocation() == nil) then
 	local location = getLocation()
 
 	print("Location of this station has been found to be: "..location)
 	local file = io.open(shell.resolve("gpsHostData"), "a")
 	file:write(tostring(component.getPrimary("modem").address)..","..tostringVector(location))
 	hostCoordinates[0] = location
 else
 	local file = io.open(shell.resolve("gpsHostData"), "a")
 	print("Enter coordinates (x,y,z) for modem: ")
 	local tmp = term.read()
 	hostCoordinates[0] = split(tmp,",")
 	file:write(tostring(component.getPrimary("modem").address)..","..tmp)
 	file:close()
 end
 
 component.modem.open(gps_port)
 while true do
 	io.write(i..": "..hostCoordinates[i][0].." "..hostCoordinates[i][1]..","..hostCoordinates[i][2]..","..hostCoordinates[i][3])
 	component.modem.setStrength(signal_strength)
 	component.modem.broadcast(gps_port, tonumber(hostCoordinates[0][1]),tonumber(hostCoordinates[0][2]),tonumber(hostCoordinates[0][3]))
 end
 ]]--