Initial Commit

* ECS - In-Progress
* GameStates - Skeleton Implemented
* Library Integrations - Completed
* Levels - In-Progress

1 files changed, 1152 insertions, 0 deletions

diff --git a/libs/windfield/mlib/mlib.lua b/libs/windfield/mlib/mlib.lua
new file mode 100644
index 0000000..488fdb7
--- /dev/null
+++ b/libs/windfield/mlib/mlib.lua
@@ -0,0 +1,1152 @@
+--[[ License
+	A math library made in Lua
+	copyright (C) 2014 Davis Claiborne
+	This program is free software; you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation; either version 2 of the License, or
+	(at your option) any later version.
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+	You should have received a copy of the GNU General Public License along
+	with this program; if not, write to the Free Software Foundation, Inc.,
+	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+	Contact me at davisclaib@gmail.com
+]]
+
+-- Local Utility Functions ---------------------- {{{
+local unpack = table.unpack or unpack
+
+-- Used to handle variable-argument functions and whether they are passed as func{ table } or func( unpack( table ) )
+local function checkInput( ... )
+	local input = {}
+	if type( ... ) ~= 'table' then input = { ... } else input = ... end
+	return input
+end
+
+-- Deals with floats / verify false false values. This can happen because of significant figures.
+local function checkFuzzy( number1, number2 )
+	return ( number1 - .00001 <= number2 and number2 <= number1 + .00001 )
+end
+
+-- Remove multiple occurrences from a table.
+local function removeDuplicatePairs( tab )
+	for index1 = #tab, 1, -1 do
+		local first = tab[index1]
+		for index2 = #tab, 1, -1 do
+			local second = tab[index2]
+			if index1 ~= index2 then
+				if type( first[1] ) == 'number' and type( second[1] ) == 'number' and type( first[2] ) == 'number' and type( second[2] ) == 'number' then
+					if checkFuzzy( first[1], second[1] ) and checkFuzzy( first[2], second[2] ) then
+						table.remove( tab, index1 )
+					end
+				elseif first[1] == second[1] and first[2] == second[2] then
+					table.remove( tab, index1 )
+				end
+			end
+		end
+	end
+	return tab
+end
+
+
+local function removeDuplicates4Points( tab )
+    for index1 = #tab, 1, -1 do
+        local first = tab[index1]
+        for index2 = #tab, 1, -1 do
+            local second = tab[index2]
+            if index1 ~= index2 then
+                if type( first[1] ) ~= type( second[1] ) then return false end
+                if type( first[2] ) == 'number' and type( second[2] ) == 'number' and type( first[3] ) == 'number' and type( second[3] ) == 'number' then
+                    if checkFuzzy( first[2], second[2] ) and checkFuzzy( first[3], second[3] ) then
+                        table.remove( tab, index1 )
+                    end
+                elseif checkFuzzy( first[1], second[1] ) and checkFuzzy( first[2], second[2] ) and checkFuzzy( first[3], second[3] ) then
+                    table.remove( tab, index1 )
+                end
+            end
+        end
+    end
+    return tab
+end
+
+
+-- Add points to the table.
+local function addPoints( tab, x, y )
+    tab[#tab + 1] = x
+    tab[#tab + 1] = y
+end
+
+-- Like removeDuplicatePairs but specifically for numbers in a flat table
+local function removeDuplicatePointsFlat( tab )
+    for i = #tab, 1 -2 do
+        for ii = #tab - 2, 3, -2 do
+            if i ~= ii then
+                local x1, y1 = tab[i], tab[i + 1]
+                local x2, y2 = tab[ii], tab[ii + 1]
+                if checkFuzzy( x1, x2 ) and checkFuzzy( y1, y2 ) then
+                    table.remove( tab, ii ); table.remove( tab, ii + 1 )
+                end
+            end
+        end
+    end
+    return tab
+end
+
+
+-- Check if input is actually a number
+local function validateNumber( n )
+	if type( n ) ~= 'number' then return false
+	elseif n ~= n then return false -- nan
+	elseif math.abs( n ) == math.huge then return false
+	else return true end
+end
+
+local function cycle( tab, index ) return tab[( index - 1 ) % #tab + 1] end
+
+local function getGreatestPoint( points, offset )
+    offset = offset or 1
+    local start = 2 - offset
+    local greatest = points[start]
+    local least = points[start]
+    for i = 2, #points / 2 do
+        i = i * 2 - offset
+        if points[i] > greatest then
+            greatest = points[i]
+        end
+        if points[i] < least then
+            least = points[i]
+        end
+    end
+    return greatest, least
+end
+
+local function isWithinBounds( min, num, max )
+    return num >= min and num <= max
+end
+
+local function distance2( x1, y1, x2, y2 ) -- Faster since it does not use math.sqrt
+	local dx, dy = x1 - x2, y1 - y2
+	return dx * dx + dy * dy
+end -- }}}
+
+-- Points -------------------------------------- {{{
+local function rotatePoint( x, y, rotation, ox, oy )
+    ox, oy = ox or 0, oy or 0
+    return ( x - ox ) * math.cos( rotation ) + ox - ( y - oy ) * math.sin( rotation ), ( x - ox ) * math.sin( rotation ) + ( y - oy ) * math.cos( rotation ) + oy
+end
+
+local function scalePoint( x, y, scale, ox, oy )
+    ox, oy = ox or 0, oy or 0
+    return ( x - ox ) * scale + ox, ( y - oy ) * scale + oy
+end
+-- }}}
+
+-- Lines --------------------------------------- {{{
+-- Returns the length of a line.
+local function getLength( x1, y1, x2, y2 )
+	local dx, dy = x1 - x2, y1 - y2
+	return math.sqrt( dx * dx + dy * dy )
+end
+
+-- Gives the midpoint of a line.
+local function getMidpoint( x1, y1, x2, y2 )
+	return ( x1 + x2 ) / 2, ( y1 + y2 ) / 2
+end
+
+-- Gives the slope of a line.
+local function getSlope( x1, y1, x2, y2 )
+	if checkFuzzy( x1, x2 ) then return false end -- Technically it's undefined, but this is easier to program.
+	return ( y1 - y2 ) / ( x1 - x2 )
+end
+
+-- Gives the perpendicular slope of a line.
+-- x1, y1, x2, y2
+-- slope
+local function getPerpendicularSlope( ... )
+	local input = checkInput( ... )
+	local slope
+
+	if #input ~= 1 then
+		slope = getSlope( unpack( input ) )
+	else
+		slope = unpack( input )
+	end
+
+	if not slope then return 0 -- Vertical lines become horizontal.
+	elseif checkFuzzy( slope, 0 ) then return false -- Horizontal lines become vertical.
+    else return -1 / slope end
+end
+
+-- Gives the y-intercept of a line.
+-- x1, y1, x2, y2
+-- x1, y1, slope
+local function getYIntercept( x, y, ... )
+	local input = checkInput( ... )
+	local slope
+
+	if #input == 1 then
+		slope = input[1]
+	else
+		slope = getSlope( x, y, unpack( input ) )
+	end
+
+	if not slope then return x, true end -- This way we have some information on the line.
+	return y - slope * x, false
+end
+
+-- Gives the intersection of two lines.
+-- slope1, slope2, x1, y1, x2, y2
+-- slope1, intercept1, slope2, intercept2
+-- x1, y1, x2, y2, x3, y3, x4, y4
+local function getLineLineIntersection( ... )
+	local input = checkInput( ... )
+	local x1, y1, x2, y2, x3, y3, x4, y4
+	local slope1, intercept1
+	local slope2, intercept2
+	local x, y
+
+	if #input == 4 then -- Given slope1, intercept1, slope2, intercept2.
+		slope1, intercept1, slope2, intercept2 = unpack( input )
+
+		-- Since these are lines, not segments, we can use arbitrary points, such as ( 1, y ), ( 2, y )
+		y1 = slope1 and slope1 * 1 + intercept1 or 1
+		y2 = slope1 and slope1 * 2 + intercept1 or 2
+		y3 = slope2 and slope2 * 1 + intercept2 or 1
+		y4 = slope2 and slope2 * 2 + intercept2 or 2
+		x1 = slope1 and ( y1 - intercept1 ) / slope1 or intercept1
+		x2 = slope1 and ( y2 - intercept1 ) / slope1 or intercept1
+		x3 = slope2 and ( y3 - intercept2 ) / slope2 or intercept2
+		x4 = slope2 and ( y4 - intercept2 ) / slope2 or intercept2
+	elseif #input == 6 then -- Given slope1, intercept1, and 2 points on the other line.
+		slope1, intercept1 = input[1], input[2]
+		slope2 = getSlope( input[3], input[4], input[5], input[6] )
+		intercept2 = getYIntercept( input[3], input[4], input[5], input[6] )
+
+		y1 = slope1 and slope1 * 1 + intercept1 or 1
+		y2 = slope1 and slope1 * 2 + intercept1 or 2
+		y3 = input[4]
+		y4 = input[6]
+		x1 = slope1 and ( y1 - intercept1 ) / slope1 or intercept1
+		x2 = slope1 and ( y2 - intercept1 ) / slope1 or intercept1
+		x3 = input[3]
+		x4 = input[5]
+	elseif #input == 8 then -- Given 2 points on line 1 and 2 points on line 2.
+		slope1 = getSlope( input[1], input[2], input[3], input[4] )
+		intercept1 = getYIntercept( input[1], input[2], input[3], input[4] )
+		slope2 = getSlope( input[5], input[6], input[7], input[8] )
+		intercept2 = getYIntercept( input[5], input[6], input[7], input[8] )
+
+		x1, y1, x2, y2, x3, y3, x4, y4 = unpack( input )
+	end
+
+	if not slope1 and not slope2 then -- Both are vertical lines
+		if x1 == x3 then -- Have to have the same x positions to intersect
+			return true
+		else
+			return false
+		end
+	elseif not slope1 then -- First is vertical
+		x = x1 -- They have to meet at this x, since it is this line's only x
+		y = slope2 and slope2 * x + intercept2 or 1
+	elseif not slope2 then -- Second is vertical
+		x = x3 -- Vice-Versa
+		y = slope1 * x + intercept1
+	elseif checkFuzzy( slope1, slope2 ) then -- Parallel (not vertical)
+		if checkFuzzy( intercept1, intercept2 ) then -- Same intercept
+			return true
+		else
+			return false
+		end
+	else -- Regular lines
+		x = ( -intercept1 + intercept2 ) / ( slope1 - slope2 )
+		y = slope1 * x + intercept1
+	end
+
+	return x, y
+end
+
+-- Gives the closest point on a line to a point.
+-- perpendicularX, perpendicularY, x1, y1, x2, y2
+-- perpendicularX, perpendicularY, slope, intercept
+local function getClosestPoint( perpendicularX, perpendicularY, ... )
+	local input = checkInput( ... )
+	local x, y, x1, y1, x2, y2, slope, intercept
+
+	if #input == 4 then -- Given perpendicularX, perpendicularY, x1, y1, x2, y2
+		x1, y1, x2, y2 = unpack( input )
+		slope = getSlope( x1, y1, x2, y2 )
+		intercept = getYIntercept( x1, y1, x2, y2 )
+	elseif #input == 2 then -- Given perpendicularX, perpendicularY, slope, intercept
+		slope, intercept = unpack( input )
+        x1, y1 = 1, slope and slope * 1 + intercept or 1 -- Need x1 and y1 in case of vertical/horizontal lines.
+	end
+
+	if not slope then -- Vertical line
+		x, y = x1, perpendicularY -- Closest point is always perpendicular.
+	elseif checkFuzzy( slope, 0 ) then -- Horizontal line
+		x, y = perpendicularX, y1
+	else
+		local perpendicularSlope = getPerpendicularSlope( slope )
+		local perpendicularIntercept = getYIntercept( perpendicularX, perpendicularY, perpendicularSlope )
+		x, y = getLineLineIntersection( slope, intercept, perpendicularSlope, perpendicularIntercept )
+	end
+
+	return x, y
+end
+
+-- Gives the intersection of a line and a line segment.
+-- x1, y1, x2, y2, x3, y3, x4, y4
+-- x1, y1, x2, y2, slope, intercept
+local function getLineSegmentIntersection( x1, y1, x2, y2, ... )
+	local input = checkInput( ... )
+
+	local slope1, intercept1, x, y, lineX1, lineY1, lineX2, lineY2
+	local slope2, intercept2 = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )
+
+	if #input == 2 then -- Given slope, intercept
+		slope1, intercept1 = input[1], input[2]
+        lineX1, lineY1 = 1, slope1 and slope1 + intercept1
+        lineX2, lineY2 = 2, slope1 and slope1 * 2 + intercept1
+	else -- Given x3, y3, x4, y4
+        lineX1, lineY1, lineX2, lineY2 = unpack( input )
+		slope1 = getSlope( unpack( input ) )
+		intercept1 = getYIntercept( unpack( input ) )
+	end
+
+	if not slope1 and not slope2 then -- Vertical lines
+		if checkFuzzy( x1, lineX1 ) then
+			return x1, y1, x2, y2
+		else
+			return false
+		end
+	elseif not slope1 then -- slope1 is vertical
+		x, y = input[1], slope2 * input[1] + intercept2
+	elseif not slope2 then -- slope2 is vertical
+		x, y = x1, slope1 * x1 + intercept1
+	else
+		x, y = getLineLineIntersection( slope1, intercept1, slope2, intercept2 )
+	end
+
+	local length1, length2, distance
+	if x == true then -- Lines are collinear.
+		return x1, y1, x2, y2
+	elseif x then -- There is an intersection
+		length1, length2 = getLength( x1, y1, x, y ), getLength( x2, y2, x, y )
+		distance = getLength( x1, y1, x2, y2 )
+	else -- Lines are parallel but not collinear.
+		if checkFuzzy( intercept1, intercept2 ) then
+			return x1, y1, x2, y2
+		else
+			return false
+		end
+	end
+
+	if length1 <= distance and length2 <= distance then return x, y else return false end
+end
+
+-- Checks if a point is on a line.
+-- Does not support the format using slope because vertical lines would be impossible to check.
+local function checkLinePoint( x, y, x1, y1, x2, y2 )
+	local m = getSlope( x1, y1, x2, y2 )
+	local b = getYIntercept( x1, y1, m )
+
+	if not m then -- Vertical
+		return checkFuzzy( x, x1 )
+	end
+	return checkFuzzy( y, m * x + b )
+end -- }}}
+
+-- Segment -------------------------------------- {{{
+-- Gives the perpendicular bisector of a line.
+local function getPerpendicularBisector( x1, y1, x2, y2 )
+	local slope = getSlope( x1, y1, x2, y2 )
+	local midpointX, midpointY = getMidpoint( x1, y1, x2, y2 )
+	return midpointX, midpointY, getPerpendicularSlope( slope )
+end
+
+-- Gives whether or not a point lies on a line segment.
+local function checkSegmentPoint( px, py, x1, y1, x2, y2 )
+	-- Explanation around 5:20: https://www.youtube.com/watch?v=A86COO8KC58
+	local x = checkLinePoint( px, py, x1, y1, x2, y2 )
+	if not x then return false end
+
+	local lengthX = x2 - x1
+	local lengthY = y2 - y1
+
+	if checkFuzzy( lengthX, 0 ) then -- Vertical line
+		if checkFuzzy( px, x1 ) then
+			local low, high
+			if y1 > y2 then low = y2; high = y1
+			else low = y1; high = y2 end
+
+			if py >= low and py <= high then return true
+			else return false end
+		else
+			return false
+		end
+	elseif checkFuzzy( lengthY, 0 ) then -- Horizontal line
+		if checkFuzzy( py, y1 ) then
+			local low, high
+			if x1 > x2 then low = x2; high = x1
+			else low = x1; high = x2 end
+
+			if px >= low and px <= high then return true
+			else return false end
+		else
+			return false
+		end
+	end
+
+	local distanceToPointX = ( px - x1 )
+	local distanceToPointY = ( py - y1 )
+	local scaleX = distanceToPointX / lengthX
+	local scaleY = distanceToPointY / lengthY
+
+	if ( scaleX >= 0 and scaleX <= 1 ) and ( scaleY >= 0 and scaleY <= 1 ) then -- Intersection
+		return true
+	end
+	return false
+end
+
+-- Gives the point of intersection between two line segments.
+local function getSegmentSegmentIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )
+	local slope1, intercept1 = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )
+	local slope2, intercept2 = getSlope( x3, y3, x4, y4 ), getYIntercept( x3, y3, x4, y4 )
+
+	if ( ( slope1 and slope2 ) and checkFuzzy( slope1, slope2 ) ) or ( not slope1 and not slope2 ) then -- Parallel lines
+		if checkFuzzy( intercept1, intercept2 ) then -- The same lines, possibly in different points.
+			local points = {}
+			if checkSegmentPoint( x1, y1, x3, y3, x4, y4 ) then addPoints( points, x1, y1 ) end
+			if checkSegmentPoint( x2, y2, x3, y3, x4, y4 ) then addPoints( points, x2, y2 ) end
+			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then addPoints( points, x3, y3 ) end
+			if checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then addPoints( points, x4, y4 ) end
+
+			points = removeDuplicatePointsFlat( points )
+			if #points == 0 then return false end
+			return unpack( points )
+		else
+			return false
+		end
+	end
+
+	local x, y = getLineLineIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )
+	if x and checkSegmentPoint( x, y, x1, y1, x2, y2 ) and checkSegmentPoint( x, y, x3, y3, x4, y4 ) then
+		return x, y
+	end
+	return false
+end -- }}}
+
+-- Math ----------------------------------------- {{{
+-- Get the root of a number (i.e. the 2nd (square) root of 4 is 2)
+local function getRoot( number, root )
+	return number ^ ( 1 / root )
+end
+
+-- Checks if a number is prime.
+local function isPrime( number )
+	if number < 2 then return false end
+
+	for i = 2, math.sqrt( number ) do
+		if number % i == 0 then
+			return false
+		end
+	end
+	return true
+end
+
+-- Rounds a number to the xth decimal place (round( 3.14159265359, 4 ) --> 3.1416)
+local function round( number, place )
+	local pow = 10 ^ ( place or 0 )
+    return math.floor( number * pow + .5 ) / pow
+end
+
+-- Gives the summation given a local function
+local function getSummation( start, stop, func )
+	local returnValues = {}
+	local sum = 0
+	for i = start, stop do
+		local value = func( i, returnValues )
+		returnValues[i] = value
+		sum = sum + value
+	end
+	return sum
+end
+
+-- Gives the percent of change.
+local function getPercentOfChange( old, new )
+	if old == 0 and new == 0 then
+        return 0
+	else
+		return ( new - old ) / math.abs( old )
+	end
+end
+
+-- Gives the percentage of a number.
+local function getPercentage( percent, number )
+	return percent * number
+end
+
+-- Returns the quadratic roots of an equation.
+local function getQuadraticRoots( a, b, c )
+	local discriminant = b ^ 2 - ( 4 * a * c )
+	if discriminant < 0 then return false end
+	discriminant = math.sqrt( discriminant )
+	local denominator = ( 2 * a )
+	return ( -b - discriminant ) / denominator, ( -b + discriminant ) / denominator
+end
+
+-- Gives the angle between three points.
+local function getAngle( x1, y1, x2, y2, x3, y3 )
+    local a = getLength( x3, y3, x2, y2 )
+    local b = getLength( x1, y1, x2, y2 )
+    local c = getLength( x1, y1, x3, y3 )
+
+   return math.acos( ( a * a + b * b - c * c ) / ( 2 * a * b ) )
+end -- }}}
+
+-- Circle --------------------------------------- {{{
+-- Gives the area of the circle.
+local function getCircleArea( radius )
+	return math.pi * ( radius * radius )
+end
+
+-- Checks if a point is within the radius of a circle.
+local function checkCirclePoint( x, y, circleX, circleY, radius )
+	return getLength( circleX, circleY, x, y ) <= radius
+end
+
+-- Checks if a point is on a circle.
+local function isPointOnCircle( x, y, circleX, circleY, radius )
+	return checkFuzzy( getLength( circleX, circleY, x, y ), radius )
+end
+
+-- Gives the circumference of a circle.
+local function getCircumference( radius )
+	return 2 * math.pi * radius
+end
+
+-- Gives the intersection of a line and a circle.
+local function getCircleLineIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
+	slope = getSlope( x1, y1, x2, y2 )
+	intercept = getYIntercept( x1, y1, slope )
+
+	if slope then
+		local a = ( 1 + slope ^ 2 )
+		local b = ( -2 * ( circleX ) + ( 2 * slope * intercept ) - ( 2 * circleY * slope ) )
+		local c = ( circleX ^ 2 + intercept ^ 2 - 2 * ( circleY ) * ( intercept ) + circleY ^ 2 - radius ^ 2 )
+
+		x1, x2 = getQuadraticRoots( a, b, c )
+
+		if not x1 then return false end
+
+		y1 = slope * x1 + intercept
+		y2 = slope * x2 + intercept
+
+		if checkFuzzy( x1, x2 ) and checkFuzzy( y1, y2 ) then
+			return 'tangent', x1, y1
+		else
+			return 'secant', x1, y1, x2, y2
+		end
+	else -- Vertical Lines
+		local lengthToPoint1 = circleX - x1
+		local remainingDistance = lengthToPoint1 - radius
+		local intercept = math.sqrt( -( lengthToPoint1 ^ 2 - radius ^ 2 ) )
+
+		if -( lengthToPoint1 ^ 2 - radius ^ 2 ) < 0 then return false end
+
+		local bottomX, bottomY = x1, circleY - intercept
+		local topX, topY = x1, circleY + intercept
+
+		if topY ~= bottomY then
+			return 'secant', topX, topY, bottomX, bottomY
+		else
+			return 'tangent', topX, topY
+		end
+	end
+end
+
+-- Gives the type of intersection of a line segment.
+local function getCircleSegmentIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
+	local Type, x3, y3, x4, y4 = getCircleLineIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
+	if not Type then return false end
+
+	local slope, intercept = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )
+
+	if isPointOnCircle( x1, y1, circleX, circleY, radius ) and isPointOnCircle( x2, y2, circleX, circleY, radius ) then -- Both points are on line-segment.
+		return 'chord', x1, y1, x2, y2
+	end
+
+	if slope then
+		if checkCirclePoint( x1, y1, circleX, circleY, radius ) and checkCirclePoint( x2, y2, circleX, circleY, radius ) then -- Line-segment is fully in circle.
+			return 'enclosed', x1, y1, x2, y2
+		elseif x3 and x4 then
+			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) and not checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then -- Only the first of the points is on the line-segment.
+				return 'tangent', x3, y3
+			elseif checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) and not checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then -- Only the second of the points is on the line-segment.
+				return 'tangent', x4, y4
+			else -- Neither of the points are on the circle (means that the segment is not on the circle, but "encasing" the circle)
+				if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) and checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then
+					return 'secant', x3, y3, x4, y4
+				else
+					return false
+				end
+			end
+		elseif not x4 then -- Is a tangent.
+			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then
+				return 'tangent', x3, y3
+			else -- Neither of the points are on the line-segment (means that the segment is not on the circle or "encasing" the circle).
+				local length = getLength( x1, y1, x2, y2 )
+				local distance1 = getLength( x1, y1, x3, y3 )
+				local distance2 = getLength( x2, y2, x3, y3 )
+
+				if length > distance1 or length > distance2 then
+					return false
+				elseif length < distance1 and length < distance2 then
+					return false
+				else
+					return 'tangent', x3, y3
+				end
+			end
+		end
+	else
+		local lengthToPoint1 = circleX - x1
+		local remainingDistance = lengthToPoint1 - radius
+		local intercept = math.sqrt( -( lengthToPoint1 ^ 2 - radius ^ 2 ) )
+
+		if -( lengthToPoint1 ^ 2 - radius ^ 2 ) < 0 then return false end
+
+		local topX, topY = x1, circleY - intercept
+		local bottomX, bottomY = x1, circleY + intercept
+
+		local length = getLength( x1, y1, x2, y2 )
+		local distance1 = getLength( x1, y1, topX, topY )
+		local distance2 = getLength( x2, y2, topX, topY )
+
+		if bottomY ~= topY then -- Not a tangent
+			if checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) and checkSegmentPoint( bottomX, bottomY, x1, y1, x2, y2 ) then
+				return 'chord', topX, topY, bottomX, bottomY
+			elseif checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) then
+				return 'tangent', topX, topY
+			elseif checkSegmentPoint( bottomX, bottomY, x1, y1, x2, y2 ) then
+				return 'tangent', bottomX, bottomY
+			else
+				return false
+			end
+		else -- Tangent
+			if checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) then
+				return 'tangent', topX, topY
+			else
+				return false
+			end
+		end
+	end
+end
+
+-- Checks if one circle intersects another circle.
+local function getCircleCircleIntersection( circle1x, circle1y, radius1, circle2x, circle2y, radius2 )
+	local length = getLength( circle1x, circle1y, circle2x, circle2y )
+	if length > radius1 + radius2 then return false end -- If the distance is greater than the two radii, they can't intersect.
+	if checkFuzzy( length, 0 ) and checkFuzzy( radius1, radius2 ) then return 'equal' end
+	if checkFuzzy( circle1x, circle2x ) and checkFuzzy( circle1y, circle2y ) then return 'collinear' end
+
+	local a = ( radius1 * radius1 - radius2 * radius2 + length * length ) / ( 2 * length )
+	local h = math.sqrt( radius1 * radius1 - a * a )
+
+	local p2x = circle1x + a * ( circle2x - circle1x ) / length
+	local p2y = circle1y + a * ( circle2y - circle1y ) / length
+	local p3x = p2x + h * ( circle2y - circle1y ) / length
+	local p3y = p2y - h * ( circle2x - circle1x ) / length
+	local p4x = p2x - h * ( circle2y - circle1y ) / length
+	local p4y = p2y + h * ( circle2x - circle1x ) / length
+
+	if not validateNumber( p3x ) or not validateNumber( p3y ) or not validateNumber( p4x ) or not validateNumber( p4y ) then
+		return 'inside'
+	end
+
+	if checkFuzzy( length, radius1 + radius2 ) or checkFuzzy( length, math.abs( radius1 - radius2 ) ) then return 'tangent', p3x, p3y end
+	return 'intersection', p3x, p3y, p4x, p4y
+end
+
+-- Checks if circle1 is entirely inside of circle2.
+local function isCircleCompletelyInsideCircle( circle1x, circle1y, circle1radius, circle2x, circle2y, circle2radius )
+	if not checkCirclePoint( circle1x, circle1y, circle2x, circle2y, circle2radius ) then return false end
+	local Type = getCircleCircleIntersection( circle2x, circle2y, circle2radius, circle1x, circle1y, circle1radius )
+	if ( Type ~= 'tangent' and Type ~= 'collinear' and Type ~= 'inside' ) then return false end
+	return true
+end
+
+-- Checks if a line-segment is entirely within a circle.
+local function isSegmentCompletelyInsideCircle( circleX, circleY, circleRadius, x1, y1, x2, y2 )
+	local Type = getCircleSegmentIntersection( circleX, circleY, circleRadius, x1, y1, x2, y2 )
+	return Type == 'enclosed'
+end -- }}}
+
+-- Polygon -------------------------------------- {{{
+-- Gives the signed area.
+-- If the points are clockwise the number is negative, otherwise, it's positive.
+local function getSignedPolygonArea( ... )
+	local points = checkInput( ... )
+
+	-- Shoelace formula (https://en.wikipedia.org/wiki/Shoelace_formula).
+	points[#points + 1] = points[1]
+	points[#points + 1] = points[2]
+
+	return ( .5 * getSummation( 1, #points / 2,
+		function( index )
+			index = index * 2 - 1 -- Convert it to work properly.
+			return ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) )
+		end
+	) )
+end
+
+-- Simply returns the area of the polygon.
+local function getPolygonArea( ... )
+	return math.abs( getSignedPolygonArea( ... ) )
+end
+
+-- Gives the height of a triangle, given the base.
+-- base, x1, y1, x2, y2, x3, y3, x4, y4
+-- base, area
+local function getTriangleHeight( base, ... )
+	local input = checkInput( ... )
+	local area
+
+	if #input == 1 then area = input[1] -- Given area.
+	else area = getPolygonArea( input ) end -- Given coordinates.
+
+	return ( 2 * area ) / base, area
+end
+
+-- Gives the centroid of the polygon.
+local function getCentroid( ... )
+	local points = checkInput( ... )
+
+	points[#points + 1] = points[1]
+	points[#points + 1] = points[2]
+
+	local area = getSignedPolygonArea( points ) -- Needs to be signed here in case points are counter-clockwise.
+
+	-- This formula: https://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
+	local centroidX = ( 1 / ( 6 * area ) ) * ( getSummation( 1, #points / 2,
+		function( index )
+			index = index * 2 - 1 -- Convert it to work properly.
+			return ( ( points[index] + cycle( points, index + 2 ) ) * ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) ) )
+		end
+	) )
+
+	local centroidY = ( 1 / ( 6 * area ) ) * ( getSummation( 1, #points / 2,
+		function( index )
+			index = index * 2 - 1 -- Convert it to work properly.
+			return ( ( points[index + 1] + cycle( points, index + 3 ) ) * ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) ) )
+		end
+	) )
+
+	return centroidX, centroidY
+end
+
+-- Returns whether or not a line intersects a polygon.
+-- x1, y1, x2, y2, polygonPoints
+local function getPolygonLineIntersection( x1, y1, x2, y2, ... )
+	local input = checkInput( ... )
+	local choices = {}
+
+	local slope = getSlope( x1, y1, x2, y2 )
+	local intercept = getYIntercept( x1, y1, slope )
+
+	local x3, y3, x4, y4
+	if slope then
+		x3, x4 = 1, 2
+		y3, y4 = slope * x3 + intercept, slope * x4 + intercept
+	else
+		x3, x4 = x1, x1
+		y3, y4 = y1, y2
+	end
+
+	for i = 1, #input, 2 do
+		local x1, y1, x2, y2 = getLineSegmentIntersection( input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ), x3, y3, x4, y4 )
+		if x1 and not x2 then choices[#choices + 1] = { x1, y1 }
+		elseif x1 and x2 then choices[#choices + 1] = { x1, y1, x2, y2 } end
+        -- No need to check 2-point sets since they only intersect each poly line once.
+	end
+
+	local final = removeDuplicatePairs( choices )
+	return #final > 0 and final or false
+end
+
+-- Returns if the line segment intersects the polygon.
+-- x1, y1, x2, y2, polygonPoints
+local function getPolygonSegmentIntersection( x1, y1, x2, y2, ... )
+	local input = checkInput( ... )
+	local choices = {}
+
+	for i = 1, #input, 2 do
+		local x1, y1, x2, y2 = getSegmentSegmentIntersection( input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ), x1, y1, x2, y2 )
+		if x1 and not x2 then choices[#choices + 1] = { x1, y1 }
+		elseif x2 then choices[#choices + 1] = { x1, y1, x2, y2 } end
+	end
+
+	local final = removeDuplicatePairs( choices )
+	return #final > 0 and final or false
+end
+
+-- Checks if the point lies INSIDE the polygon not on the polygon.
+local function checkPolygonPoint( px, py, ... )
+	local points = { unpack( checkInput( ... ) ) } -- Make a new table, as to not edit values of previous.
+
+	local greatest, least = getGreatestPoint( points, 0 )
+	if not isWithinBounds( least, py, greatest ) then return false end
+	greatest, least = getGreatestPoint( points )
+	if not isWithinBounds( least, px, greatest ) then return false end
+
+	local count = 0
+	for i = 1, #points, 2 do
+		if checkFuzzy( points[i + 1], py ) then
+			points[i + 1] = py + .001 -- Handles vertices that lie on the point.
+            -- Not exactly mathematically correct, but a lot easier.
+		end
+		if points[i + 3] and checkFuzzy( points[i + 3], py ) then
+			points[i + 3] = py + .001 -- Do not need to worry about alternate case, since points[2] has already been done.
+		end
+		local x1, y1 = points[i], points[i + 1]
+		local x2, y2 = points[i + 2] or points[1], points[i + 3] or points[2]
+
+		if getSegmentSegmentIntersection( px, py, greatest, py, x1, y1, x2, y2 ) then
+			count = count + 1
+		end
+	end
+
+	return count and count % 2 ~= 0
+end
+
+-- Returns if the line segment is fully or partially inside.
+-- x1, y1, x2, y2, polygonPoints
+local function isSegmentInsidePolygon( x1, y1, x2, y2, ... )
+	local input = checkInput( ... )
+
+	local choices = getPolygonSegmentIntersection( x1, y1, x2, y2, input ) -- If it's partially enclosed that's all we need.
+	if choices then return true end
+
+	if checkPolygonPoint( x1, y1, input ) or checkPolygonPoint( x2, y2, input ) then return true end
+	return false
+end
+
+-- Returns whether two polygons intersect.
+local function getPolygonPolygonIntersection( polygon1, polygon2 )
+	local choices = {}
+
+	for index1 = 1, #polygon1, 2 do
+		local intersections = getPolygonSegmentIntersection( polygon1[index1], polygon1[index1 + 1], cycle( polygon1, index1 + 2 ), cycle( polygon1, index1 + 3 ), polygon2 )
+		if intersections then
+			for index2 = 1, #intersections do
+				choices[#choices + 1] = intersections[index2]
+			end
+		end
+	end
+
+	for index1 = 1, #polygon2, 2 do
+		local intersections = getPolygonSegmentIntersection( polygon2[index1], polygon2[index1 + 1], cycle( polygon2, index1 + 2 ), cycle( polygon2, index1 + 3 ), polygon1 )
+		if intersections then
+			for index2 = 1, #intersections do
+				choices[#choices + 1] = intersections[index2]
+			end
+		end
+	end
+
+	choices = removeDuplicatePairs( choices )
+	for i = #choices, 1, -1 do
+		if type( choices[i][1] ) == 'table' then -- Remove co-linear pairs.
+			table.remove( choices, i )
+		end
+	end
+
+	return #choices > 0 and choices
+end
+
+-- Returns whether the circle intersects the polygon.
+-- x, y, radius, polygonPoints
+local function getPolygonCircleIntersection( x, y, radius, ... )
+	local input = checkInput( ... )
+	local choices = {}
+
+	for i = 1, #input, 2 do
+		local Type, x1, y1, x2, y2 = getCircleSegmentIntersection( x, y, radius, input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ) )
+		if x2 then
+			choices[#choices + 1] = { Type, x1, y1, x2, y2 }
+		elseif x1 then choices[#choices + 1] = { Type, x1, y1 } end
+	end
+
+	local final = removeDuplicates4Points( choices )
+
+	return #final > 0 and final
+end
+
+-- Returns whether the circle is inside the polygon.
+-- x, y, radius, polygonPoints
+local function isCircleInsidePolygon( x, y, radius, ... )
+	local input = checkInput( ... )
+	return checkPolygonPoint( x, y, input )
+end
+
+-- Returns whether the polygon is inside the polygon.
+local function isPolygonInsidePolygon( polygon1, polygon2 )
+	local bool = false
+	for i = 1, #polygon2, 2 do
+		local result = false
+		result = isSegmentInsidePolygon( polygon2[i], polygon2[i + 1], cycle( polygon2, i + 2 ), cycle( polygon2, i + 3 ), polygon1 )
+		if result then bool = true; break end
+	end
+	return bool
+end
+
+-- Checks if a segment is completely inside a polygon
+local function isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, ... )
+	local polygon = checkInput( ... )
+	if not checkPolygonPoint( x1, y1, polygon )
+	or not checkPolygonPoint( x2, y2, polygon )
+	or getPolygonSegmentIntersection( x1, y1, x2, y2, polygon ) then
+		return false
+	end
+	return true
+end
+
+-- Checks if a polygon is completely inside another polygon
+local function isPolygonCompletelyInsidePolygon( polygon1, polygon2 )
+	for i = 1, #polygon1, 2 do
+		local x1, y1 = polygon1[i], polygon1[i + 1]
+		local x2, y2 = polygon1[i + 2] or polygon1[1], polygon1[i + 3] or polygon1[2]
+		if not isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, polygon2 ) then
+			return false
+		end
+	end
+	return true
+end
+
+-------------- Circle w/ Polygons --------------
+-- Gets if a polygon is completely within a circle
+-- circleX, circleY, circleRadius, polygonPoints
+local function isPolygonCompletelyInsideCircle( circleX, circleY, circleRadius, ... )
+	local input = checkInput( ... )
+	local function isDistanceLess( px, py, x, y, circleRadius ) -- Faster, does not use math.sqrt
+		local distanceX, distanceY = px - x, py - y
+		return distanceX * distanceX + distanceY * distanceY < circleRadius * circleRadius -- Faster. For comparing distances only.
+	end
+
+	for i = 1, #input, 2 do
+		if not checkCirclePoint( input[i], input[i + 1], circleX, circleY, circleRadius ) then return false end
+	end
+	return true
+end
+
+-- Checks if a circle is completely within a polygon
+-- circleX, circleY, circleRadius, polygonPoints
+local function isCircleCompletelyInsidePolygon( circleX, circleY, circleRadius, ... )
+	local input = checkInput( ... )
+	if not checkPolygonPoint( circleX, circleY, ... ) then return false end
+
+	local rad2 = circleRadius * circleRadius
+
+	for i = 1, #input, 2 do
+		local x1, y1 = input[i], input[i + 1]
+		local x2, y2 = input[i + 2] or input[1], input[i + 3] or input[2]
+		if distance2( x1, y1, circleX, circleY ) <= rad2 then return false end
+		if getCircleSegmentIntersection( circleX, circleY, circleRadius, x1, y1, x2, y2 ) then return false end
+	end
+	return true
+end -- }}}
+
+-- Statistics ----------------------------------- {{{
+-- Gets the average of a list of points
+-- points
+local function getMean( ... )
+	local input = checkInput( ... )
+
+	mean = getSummation( 1, #input,
+		function( i, t )
+			return input[i]
+		end
+	) / #input
+
+	return mean
+end
+
+local function getMedian( ... )
+	local input = checkInput( ... )
+
+	table.sort( input )
+
+	local median
+	if #input % 2 == 0 then -- If you have an even number of terms, you need to get the average of the middle 2.
+		median = getMean( input[#input / 2], input[#input / 2 + 1] )
+	else
+		median = input[#input / 2 + .5]
+	end
+
+	return median
+end
+
+-- Gets the mode of a number.
+local function getMode( ... )
+	local input = checkInput( ... )
+
+	table.sort( input )
+	local sorted = {}
+	for i = 1, #input do
+		local value = input[i]
+		sorted[value] = sorted[value] and sorted[value] + 1 or 1
+	end
+
+	local occurrences, least = 0, {}
+	for i, value in pairs( sorted ) do
+		if value > occurrences then
+			least = { i }
+			occurrences = value
+		elseif value == occurrences then
+			least[#least + 1] = i
+		end
+	end
+
+	if #least >= 1 then return least, occurrences
+	else return false end
+end
+
+-- Gets the range of the numbers.
+local function getRange( ... )
+	local input = checkInput( ... )
+	local high, low = math.max( unpack( input ) ), math.min( unpack( input ) )
+	return high - low
+end
+
+-- Gets the variance of a set of numbers.
+local function getVariance( ... )
+	local input = checkInput( ... )
+	local mean = getMean( ... )
+	local sum = 0
+	for i = 1, #input do
+		sum = sum + ( mean - input[i] ) * ( mean - input[i] )
+	end
+	return sum / #input
+end
+
+-- Gets the standard deviation of a set of numbers.
+local function getStandardDeviation( ... )
+	return math.sqrt( getVariance( ... ) )
+end
+
+-- Gets the central tendency of a set of numbers.
+local function getCentralTendency( ... )
+	local mode, occurrences = getMode( ... )
+	return mode, occurrences, getMedian( ... ), getMean( ... )
+end
+
+-- Gets the variation ratio of a data set.
+local function getVariationRatio( ... )
+	local input = checkInput( ... )
+	local numbers, times = getMode( ... )
+	times = times * #numbers -- Account for bimodal data
+	return 1 - ( times / #input )
+end
+
+-- Gets the measures of dispersion of a data set.
+local function getDispersion( ... )
+	return getVariationRatio( ... ), getRange( ... ), getStandardDeviation( ... )
+end -- }}}
+
+return {
+	_VERSION = 'MLib 0.10.0',
+	_DESCRIPTION = 'A math and shape-intersection detection library for Lua',
+	_URL = 'https://github.com/davisdude/mlib',
+    point = {
+        rotate = rotatePoint,
+        scale = scalePoint,
+    },
+	line = {
+		getLength = getLength,
+		getMidpoint = getMidpoint,
+		getSlope = getSlope,
+		getPerpendicularSlope = getPerpendicularSlope,
+		getYIntercept = getYIntercept,
+		getIntersection = getLineLineIntersection,
+		getClosestPoint = getClosestPoint,
+		getSegmentIntersection = getLineSegmentIntersection,
+		checkPoint = checkLinePoint,
+
+		-- Aliases
+		getDistance = getLength,
+		getCircleIntersection = getCircleLineIntersection,
+		getPolygonIntersection = getPolygonLineIntersection,
+		getLineIntersection = getLineLineIntersection,
+    },
+    segment = {
+        checkPoint = checkSegmentPoint,
+		getPerpendicularBisector = getPerpendicularBisector,
+        getIntersection = getSegmentSegmentIntersection,
+
+        -- Aliases
+        getCircleIntersection = getCircleSegmentIntersection,
+        getPolygonIntersection = getPolygonSegmentIntersection,
+        getLineIntersection = getLineSegmentIntersection,
+        getSegmentIntersection = getSegmentSegmentIntersection,
+        isSegmentCompletelyInsideCircle = isSegmentCompletelyInsideCircle,
+        isSegmentCompletelyInsidePolygon = isSegmentCompletelyInsidePolygon,
+	},
+	math = {
+		getRoot = getRoot,
+		isPrime = isPrime,
+		round = round,
+		getSummation =	getSummation,
+		getPercentOfChange = getPercentOfChange,
+		getPercentage = getPercentage,
+		getQuadraticRoots = getQuadraticRoots,
+		getAngle = getAngle,
+	},
+	circle = {
+		getArea = getCircleArea,
+		checkPoint = checkCirclePoint,
+		isPointOnCircle = isPointOnCircle,
+		getCircumference = getCircumference,
+		getLineIntersection = getCircleLineIntersection,
+		getSegmentIntersection = getCircleSegmentIntersection,
+		getCircleIntersection = getCircleCircleIntersection,
+		isCircleCompletelyInside = isCircleCompletelyInsideCircle,
+		isPolygonCompletelyInside = isPolygonCompletelyInsideCircle,
+		isSegmentCompletelyInside = isSegmentCompletelyInsideCircle,
+
+		-- Aliases
+		getPolygonIntersection = getPolygonCircleIntersection,
+		isCircleInsidePolygon = isCircleInsidePolygon,
+		isCircleCompletelyInsidePolygon = isCircleCompletelyInsidePolygon,
+	},
+	polygon = {
+		getSignedArea = getSignedPolygonArea,
+		getArea = getPolygonArea,
+		getTriangleHeight = getTriangleHeight,
+		getCentroid = getCentroid,
+		getLineIntersection = getPolygonLineIntersection,
+		getSegmentIntersection = getPolygonSegmentIntersection,
+		checkPoint = checkPolygonPoint,
+		isSegmentInside = isSegmentInsidePolygon,
+		getPolygonIntersection = getPolygonPolygonIntersection,
+		getCircleIntersection = getPolygonCircleIntersection,
+		isCircleInside = isCircleInsidePolygon,
+		isPolygonInside = isPolygonInsidePolygon,
+		isCircleCompletelyInside = isCircleCompletelyInsidePolygon,
+		isSegmentCompletelyInside = isSegmentCompletelyInsidePolygon,
+		isPolygonCompletelyInside = isPolygonCompletelyInsidePolygon,
+
+		-- Aliases
+		isCircleCompletelyOver = isPolygonCompletelyInsideCircle,
+	},
+	statistics = {
+		getMean = getMean,
+		getMedian = getMedian,
+		getMode = getMode,
+		getRange = getRange,
+		getVariance = getVariance,
+		getStandardDeviation = getStandardDeviation,
+		getCentralTendency = getCentralTendency,
+		getVariationRatio = getVariationRatio,
+		getDispersion = getDispersion,
+	},
+}