function OnGeoEnter(geo, player, objId)

 

        return true

 

function OnGeoExit(geo, player, objId)

 

        return true

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

GEO = {}

GEO.__index = GEO

 

math.inf = 1 / 0

 

function inSphere(objId, x, y, z, r)

 

    local ox, oy, oz = getobjectcoords(objId)

    if ox then

        -- Pythagorean

        local dist = math.sqrt((x - ox) ^ 2 + (y - oy) ^ 2 + (z - oz) ^ 2)

        if dist <= r then

            return true

        end

    end

       

    return false

 

function inCircle(objId, x, y, z, r, orientation)

 

    local ox, oy, oz = getobjectcoords(objId)

    if ox then

        -- Default orientation to "z"

        orientation = orientation or "z"

        -- Pythagorean based on circle's orientation

        if orientation == "z" then

            local dist = math.sqrt((x - ox) ^ 2 + (y - oy) ^ 2)

            if dist <= r and oz == z then

                return true

            end

        elseif orientation == "y" then

            local dist = math.sqrt((x - ox) ^ 2 + (z - oz) ^ 2)

            if dist <= r and oy == y then

                return true

            end

        elseif orientation == "x" then

            local dist = math.sqrt((y - oy) ^ 2 + (z - oz) ^ 2)

            if dist <= r and ox == x then

                return true

            end

        end

    end

       

    return false

 

function inCylinder(objId, x, y, z, hlow, hhigh, r, orientation)

 

    local ox, oy, oz = getobjectcoords(objId)

    if ox then

        if orientation == "z" then

            -- Pythagorean to see if object is within radius of circle

            local dist = math.sqrt((x - ox) ^ 2 + (y - oy) ^ 2)

            -- Make sure the object is also within the height of the cylinder

            if dist <= r and oz >= hlow and oz <= hhigh then

                return true

            end

        elseif orientation == "x" then

            local dist = math.sqrt((y - oy) ^ 2 + (z - oz) ^ 2)

            if dist <= r and ox >= hlow and ox <= hhigh then

                return true

            end

        elseif orientation == "y" then

            local dist = math.sqrt((z - oz) ^ 2 + (x - ox) ^ 2)

            if dist <= r and oy >= hlow and oy <= hhigh then

                return true

            end

        end

    end

       

    return false

 

function inRectangle(objId, xlow, xhigh, ylow, yhigh, zlow, zhigh)

 

    -- These functions are essentially the same

    return inRectPrism(objId, xlow, xhigh, ylow, yhigh, zlow, zhigh)

 

function inRectPrism(objId, xlow, xhigh, ylow, yhigh, zlow, zhigh)

 

    local x, y, z = getobjectcoords(objId)

    if x then

        -- Make sure the coordinates are inside of each extreme of the rectangular prism

        if x <= xhigh and x >= xlow and y <= yhigh and y >= ylow and z <= zhigh and z >= zlow then

            return true

        end

    end

       

    return false

 

function randomInSphere(x, y, z, r)

 

    -- Increase precision

    x = math.floor(x * 100)

    y = math.floor(y * 100)

    z = math.floor(z * 100)

    r = math.floor(r * 100)

       

    -- Find random values inside of the sphere.

    return math.random(x - r, x + r + 1) / 100, math.random(y - r, y + r + 1) / 100, math.random(z - r, z + r + 1) / 100

 

function randomInCircle(x, y, z, r, orientation)

 

    -- Increase precision

    r = math.floor(r * 100)

       

    -- Possible values depend on circle's orientation.

    if orientation == "z" then

        x = math.floor(x * 100)

        y = math.floor(y * 100)

        return math.random(x - r, x + r + 1) / 100, math.random(y - r, y + r + 1) / 100, z    

    elseif orientation == "x" then

        y = math.floor(y * 100)

        z = math.floor(z * 100)

        return x, math.random(y - r, y + r + 1) / 100, math.random(z - r, z + r + 1) / 100

    elseif orientation == "y" then

        x = math.floor(x * 100)

        z = math.floor(z * 100)

        return math.random(x - r, x + r + 1) / 100, y, math.random(z - r, z + r + 1) / 100

    end

 

function randomInCylinder(x, y, z, hlow, hhigh, r, orientation)

 

    -- Increase precision

    x = math.floor(x * 100)

    y = math.floor(y * 100)

    z = math.floor(z * 100)

    hlow = math.floor(hlow * 100)

    hhigh = math.floor(hhigh * 100)

    r = math.floor(r * 100)

       

    -- Find random values inside of the cylinder depending on its orientation.

    if orientation == "z" then

        return math.random(x - r, x + r + 1) / 100, math.random(y - r, y + r + 1) / 100, math.random(hlow, hhigh + 1) / 100

    elseif orientation == "y" then

        return math.random(x - r, x + r + 1) / 100, math.random(hlow, hhigh + 1) / 100, math.random(z - r, z + r + 1) / 100

    elseif orientation == "x" then

        return math.random(hlow, hhigh + 1) / 100, math.random(y - r, r + r + 1) / 100, math.random(z - r, z + r + 1) / 100

    end

 

function randomInRectPrism(xlow, xhigh, ylow, yhigh, zlow, zhigh)

 

    -- Increase precision

    xlow = math.floor(xlow * 100)

    xhigh = math.floor(xhigh * 100)

    ylow = math.floor(ylow * 100)

    yhigh = math.floor(yhigh * 100)

    zlow = math.floor(zlow * 100)

    zhigh = math.floor(zhigh * 100)

       

    -- Find random values inside of the rectangular prism.

    return math.random(xlow, xhigh + 1) / 100, math.random(ylow, yhigh + 1) / 100, math.random(zlow, zhigh)

 

function sphereintersect(sphere, pointA, pointB)

 

        local points = {}

 

        local a = (pointA.x - pointB.x) ^ 2 + (pointA.y - pointB.y) ^ 2 + (pointA.z - pointB.z) ^ 2

        local c = (pointA.x - sphere.x) ^ 2 + (pointA.y - sphere.y) ^ 2 + (pointA.z - sphere.z) ^ 2 - sphere.r ^ 2

        local b = (pointB.x - sphere.x) ^ 2 + (pointB.y - sphere.y) ^ 2 + (pointB.z - sphere.z) ^ 2 - c - a - sphere.r ^ 2

 

        -- Make sure square root is not imaginary.

        local q = b ^ 2 - 4 * a * c

 

        if q > 0 then

               

                -- Quadratic Formula:

                local t1 = (-b + math.sqrt(q)) / (2 * a)

                local t2 = (-b - math.sqrt(q)) / (2 * a)

 

                local xt1 = pointA.x * (1 - t1) + t1 * pointB.x

                local yt1 = pointA.y * (1 - t1) + t1 * pointB.y

                local zt1 = pointA.z * (1 - t1) + t1 * pointB.z

 

                local xt2 = pointA.x * (1 - t2) + t2 * pointB.x

                local yt2 = pointA.y * (1 - t2) + t2 * pointB.y

                local zt2 = pointA.z * (1 - t2) + t2 * pointB.z

 

                -- Make sure the intersection is on this line.

                local ipoint1, ipoint2

                if t1 >= 0 and t1 <= 1 then

                        table.insert(points, {x = xt1, y = yt1, z = zt1})

                end

 

                -- Make sure the intersection is on this line.

                if t2 >= 0 and t2 <= 1 then

                        table.insert(points, {x = xt2, y = yt2, z = zt2})

                end

        end

 

        return points

 

function cylinderintersect(cylinder, pointA, pointB)

 

        -- Change x, y and z depending on orientation.

        local x, y, z

 

        if cylinder.o == "z" then

                x, y, z = "x", "y", "z"

        elseif cylinder.o == "x" then

                x, y, z = "z", "y", "x"

        elseif cylinder.o == "y" then

                x, y, z = "x", "z", "y"

        end

 

        local points = {}

 

        -- Determine if line intersects cylinder's edges.

        local a = (pointA[x] - pointB[x]) ^ 2 + (pointA[y] - pointB[y]) ^ 2

        local c = (pointA[x] - cylinder[x]) ^ 2 + (pointA[y] - cylinder[y]) ^ 2 - cylinder.r ^ 2

        local b = (pointB[x] - cylinder[x]) ^ 2 + (pointB[y] - cylinder[y]) ^ 2 - a - c - cylinder.r ^ 2

 

        local q = b ^ 2 - 4 * a * c

 

        if q > 0 then

 

                local t1 = (-b + math.sqrt(q)) / (2 * a)

                local t2 = (-b - math.sqrt(q)) / (2 * a)

 

                local xt1 = pointA[x] * (1 - t1) + t1 * pointB[x]

                local yt1 = pointA[y] * (1 - t1) + t1 * pointB[y]

                local zt1 = pointA[z] * (1 - t1) + t1 * pointB[z]

 

                local xt2 = pointA[x] * (1 - t2) + t2 * pointB[x]

                local yt2 = pointA[y] * (1 - t2) + t2 * pointB[y]

                local zt2 = pointA[z] * (1 - t2) + t2 * pointB[z]

 

                -- Make sure the intersection is on this line and within the cylinder's height.

                if t1 >= 0 and t1 <= 1 and zt1 >= cylinder.hlow and zt1 <= cylinder.hhigh then

                        table.insert(points, {[x] = xt1, [y] = yt1, [z] = zt1})

                end

 

                -- Make sure the intersection is on this line and within the cylinder's height.

                if t2 >= 0 and t2 <= 1 and zt2 >= cylinder.hlow and zt2 <= cylinder.hhigh then

                        table.insert(points, {[x] = xt2, [y] = yt2, [z] = zt2})

                end

 

                -- Check end caps

                -- If either point on the line is lower than or equal to the lowest point on the cylinder...

                if pointA[z] <= cylinder.hlow or pointB[z] <= cylinder.hlow then

                        local tzlow = (cylinder.hlow - pointA[z]) / (pointA[z] + pointB[z])

 

                        local xtlow = pointA[x] * (1 - tzlow) + tzlow * pointB[x]

                        local ytlow = pointA[y] * (1 - tzlow) + tzlow * pointB[y]

 

                        local dist = math.sqrt((cylinder[x] - xtlow) ^ 2 + (cylinder[y] - ytlow) ^ 2)

 

                        if dist < cylinder.r then

                                table.insert(points, {[x] = xtlow, [y] = ytlow, [z] = cylinder.hlow})

                        end

                end

 

                -- If either point on the line is higher than or equal to the lowest point on the cylinder...

                if pointA[z] >= cylinder.hhigh or pointB[z] >= cylinder.hhigh then

                        local tzhigh = (cylinder.hhigh - pointA[z]) / (pointA[z] + pointB[z])

 

                        local xthigh = pointA[x] * (1 - tzhigh) + tzhigh * pointB[x]

                        local ythigh = pointA[y] * (1 - tzhigh) + tzhigh * pointB[y]

 

                        local dist = math.sqrt((cylinder[x] - xthigh) ^ 2 + (cylinder[y] - ythigh) ^ 2)

 

                        if dist < cylinder.r then

                                table.insert(points, {[x] = xthigh, [y] = ythigh, [z] = cylinder.hhigh})

                        end

                end

        end

 

        return points

 

function rectprismintersect(rectprism, pointA, pointB)

 

        local points = {}

 

        -- Get the time "t" on the line where intersection with each coordinate's extreme occurs.

        local txlow = (rectprism.xlow - pointA.x) / (pointA.x + pointB.x)

        local txhigh = (rectprism.xhigh - pointA.x) / (pointA.x + pointB.x)

        local tylow = (rectprism.ylow - pointA.y) / (pointA.y + pointB.y)

        local tyhigh = (rectprism.yhigh - pointA.y) / (pointA.y + pointB.y)

        local tzlow = (rectprism.zlow - pointA.z) / (pointA.z + pointB.z)

        local tzhigh = (rectprism.zhigh - pointA.z) / (pointA.z + pointB.z)

 

        -- Find other coordinates given t.

        local xlowy = pointA.y * (1 - txlow) + txlow * pointB.y

        local xlowz = pointA.z * (1 - txlow) + txlow * pointB.z

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if xlowy <= rectprism.yhigh and xlowy >= rectprism.ylow and xlowz <= rectprism.zhigh and xlowz >= rectprism.zlow then

                table.insert(points, {x = rectprism.xlow, y = xlowy, z = xlowz})

        end

 

        -- Find other coordinates given t.

        local xhighy = pointA.y * (1 - txhigh) + txhigh * pointB.y

        local xhighz = pointA.z * (1 - txhigh) + txhigh * pointB.z

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if xhighy <= rectprism.yhigh and xhighy >= rectprism.ylow and xhighz <= rectprism.zhigh and xhighz >= rectprism.zlow then

                table.insert(points, {x = rectprism.xhigh, y = xhighy, z = xhighz})

        end

 

        -- Find other coordinates given t.

        local ylowx = pointA.x * (1 - tylow) + tylow * pointB.x

        local ylowz = pointA.z * (1 - tylow) + tylow * pointB.z

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if ylowx <= rectprism.xhigh and ylowx >= rectprism.xlow and ylowz <= rectprism.zhigh and ylowz >= rectprism.zlow then

                table.insert(points, {x = ylowx, y = rectprism.ylow, z = ylowz})

        end

 

        -- Find other coordinates given t.

        local yhighx = pointA.x * (1 - tyhigh) + tyhigh * pointB.x

        local yhighz = pointA.z * (1 - tyhigh) + tyhigh * pointB.z

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if yhighx <= rectprism.xhigh and yhighx >= rectprism.xlow and yhighz <= rectprism.zhigh and yhighz >= rectprism.zlow then

                table.insert(points, {x = yhighx, y = rectprism.yhigh, z = yhighz})

        end

 

        -- Find other coordinates given t.

        local zlowx = pointA.x * (1 - tzlow) + tzlow * pointB.x

        local zlowy = pointA.y * (1 - tzlow) + tzlow * pointB.y

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if zlowx <= rectprism.xhigh and zlowx >= rectprism.xlow and zlowy <= rectprism.yhigh and zlowy >= rectprism.ylow then

                table.insert(points, {x = zlowx, y = zlowy, z = rectprism.zlow})

        end

 

        -- Find other coordinates given t.

        local zhighx = pointA.x * (1 - tzhigh) + tzhigh * pointB.x

        local zhighy = pointA.y * (1 - tzhigh) + tzhigh * pointB.y

 

        -- Ensure that this intersection is within the bounds of the rectangular prism.

        if zhighx <= rectprism.xhigh and zhighx >= rectprism.xlow and zhighy <= rectprism.yhigh and zhighy >= rectprism.ylow then

                table.insert(points, {x = zhighx, y = zhighy, z = rectprism.zhigh})

        end

 

        -- Corner and edge check

        if #points > 2 then

                -- Remove entries from the table while we loop through it.

                local i = 0

                while i <= #points do

                        -- There can be a total of three copies of the same coordinates (if the intersection happens at a corner).

                        local rem1, rem2

                        for k,v in ipairs(points) do

                                if points[i].x == v.x and points[i].y == v.y and points[i].z == v.z then

                                        if rem1 then

                                                rem2 = i - 1  -- Subtract 1 from the key since rem1 will be removed first and this key will be lowered by 1 when that happens.

                                        else

                                                rem1 = i

                                        end

                                end

                        end

 

                        -- Remove the two keys.

                        if rem1 or rem2 then

                                if rem1 then

                                        table.remove(points, rem1)

                                elseif rem2 then

                                        table.remove(points, rem2)

                                end

                        else

                                i = i + 1  -- Increment i only if an entry has not been deleted.

                        end

                end

        end

 

        return points

 

function circleintersect(circle, pointA, pointB)

 

        -- Change x, y and z depending on orientation.

        local x, y, z

 

        if circle.o == "z" then

                x, y, z = "x", "y", "z"

        elseif circle.o == "x" then

                x, y, z = "z", "y", "x"

        elseif circle.o == "y" then

                x, y, z = "x", "z", "y"

        end

 

        local points = {}

 

        -- Find the time "t" when the line intersects the plane at which the circle is oriented.

        local tz = (circle[z] - pointA[z]) / (pointA[z] + pointB[z])

        local xtz = pointA[x] * (1 - tz) + tz * pointB[x]

        local ytz = pointA[y] * (1 - tz) + tz * pointB[y]

 

        -- Find the distance from this intersection point to the center of the circle and compare it against the radius.

        local dist = math.sqrt((xtz - circle[x]) ^ 2 + (ytz - circle[y]) ^ 2)

        if dist <= circle.r then

                table.insert(points, {[x] = xtz, [y] = ytz, [z] = circle[z]})

        end

 

        return points

 

function rectangleintersect(rectangle, pointA, pointB)

 

        -- Change x, y and z depending on orientation.

        local x, y, z

 

        if rectangle.o == "z" then

                x, y, z = "x", "y", "z"

        elseif rectangle.o == "x" then

                x, y, z = "z", "y", "x"

        elseif rectangle.o == "y" then

                x, y, z = "x", "z", "y"

        end

 

        local points = {}

       

        -- Find the time "t" when the line intersects the plane at which the rectangle is oriented.

        local tz = (rectangle[z] - pointA[z]) / (pointA[z] + pointB[z])

        local xtz = pointA[x] * (1 - tz) + tz * pointB[x]

        local ytz = pointA[y] * (1 - tz) + tz * pointB[y]

 

        -- Find if the intersection point is within the bounds of the rectangle.

        if xtz >= rectangle[x .. "low"] and xtz <= rectangle[x .. "high"] and ytz >= rectangle[y .. "low"] and ytz <= rectangle[y .. "high"] then

                table.insert(points, {[x] = xtz, [y] = ytz, [z] = rectangle[z]})

        end

 

        return points

 

function GEO.newSphere(name, r, x, y, z)

 

    -- Check to see if there is already a GEO with this name.

    if not GEO[name] then

        -- Create new table

        GEO[name] = {}

        GEO[name].t = "sphere"  -- type

        GEO[name].n = name  -- name

        GEO[name].r = r or 1  -- radius (default value of 1)

        GEO[name].x = x or 0  -- x coordinate of center (default value of 0)

        GEO[name].y = y or 0  -- y coordinate of center (default value of 0)

        GEO[name].z = z or 0  -- z coordinate of center (default value of 0)

           

        -- Initialize monitor and contain tables

        GEO[name].m = {}

        GEO[name].c = {}

           

        -- Initialize list of antigeos

        GEO[name].anti = {}

           

        -- Notify the console that a sphere has been created.

        hprintf("Sphere \"" .. name .. "\" created.")

        setmetatable(GEO[name], GEO)  -- Add this object to the GEO metatable to allow GEO-editing functions to work on it.

        return GEO[name]  -- Return the object

    end

       

    -- If no object was returned, the name was invalid; notify the console.

    hprintf("Invalid name: \"" .. name .. "\"")

 

function GEO.newCircle(name, r, x, y, z, orientation)

 

    if not GEO[name] then

        GEO[name] = {}

        GEO[name].t = "circle"

        GEO[name].n = name

        GEO[name].o = orientation or "z"  -- orientation

        GEO[name].r = r or 0

        GEO[name].x = x or 0

        GEO[name].y = y or 0

        GEO[name].z = z or 0

           

        -- Initialize monitor and contain tables

        GEO[name].m = {}

        GEO[name].c = {}

           

        -- Initialize list of antigeos

        GEO[name].anti = {}

           

        hprintf("Circle \"" .. name .. "\" created.")

        setmetatable(GEO[name], GEO)

        return GEO[name]

    end

       

    hprintf("Invalid name: \"" .. name .. "\"")

 

function GEO.newCylinder(name, r, h, x, y, z, orientation)

 

    if not GEO[name] then

        GEO[name] = {}

        GEO[name].t = "cylinder"

        GEO[name].n = name

        x = x or 0

        y = y or 0

        z = z or 0

        r = r or 1

        h = h or 1

        orientation = orientation or "z"

        GEO[name].x = x

        GEO[name].y = y

        GEO[name].z = z

        GEO[name].r = r

        GEO[name].h = h  -- height

        GEO[name].o = orientation  -- orientation "x", "y", or "z"

        GEO[name].hlow = GEO[name][orientation] - h / 2  -- lowest orientation coordinate still within the cylinder

        GEO[name].hhigh = GEO[name][orientation] + h / 2  -- highest orientation coordinate still within the cylinder

           

        -- Initialize monitor and contain tables

        GEO[name].m = {}

        GEO[name].c = {}

           

        -- Initialize list of antigeos

        GEO[name].anti = {}

           

        hprintf("Cylinder \"" .. name .. "\" created.")

        setmetatable(GEO[name], GEO)

        return GEO[name]

    end

 

function GEO.newRectPrism(name, lx, ly, lz, x, y, z)

 

    if not GEO[name] then

        GEO[name] = {}

        GEO[name].t = "rectprism"

        GEO[name].n = name

        lx = lx or 1

        ly = ly or 1

        lz = lz or 1

        x = x or 0

        y = y or 0

        z = z or 0

        GEO[name].lx = lx  -- x length

        GEO[name].ly = ly  -- y length

        GEO[name].lz = lz  -- z length

        GEO[name].x = x

        GEO[name].y = y

        GEO[name].z = z

        GEO[name].xlow = x - lx / 2  -- lowest x-coordinate still within the rectangular prism

        GEO[name].xhigh = lx / 2 + x  -- highest x-coordinate still within in the rectangular prism

        GEO[name].ylow = y - ly / 2  -- lowest y-coordinate still within the rectangular prism

        GEO[name].yhigh = ly / 2 + y  -- highest y-coordinate still within the rectangular prism

        GEO[name].zlow = z - lz / 2  -- lowest z-coordinate still within the rectangular prism

        GEO[name].zhigh = lz / 2 + z  -- highest z-coordinate still within the rectangular prism

           

        -- Initialize monitor and contain tables

        GEO[name].m = {}

        GEO[name].c = {}

           

        -- Initialize list of antigeos

        GEO[name].anti = {}

           

        hprintf("Rectangular Prism \"" .. name .. "\" created.")

        setmetatable(GEO[name], GEO)

        return GEO[name]

    end

       

    hprintf("Invalid name: \"" .. name .. "\"")

 

function GEO.newRect(name, width, height, x, y, z, orientation)

 

    if not GEO[name] then

        GEO[name] = {}

        GEO[name].t = "rectangle"

        GEO[name].n = name

        width = width or 1

        height = height or 1

        x = x or 0

        y = y or 0

        z = z or 0

        orientation = orientation or "z"

        GEO[name].width = width

        GEO[name].height = height

        GEO[name].x = x

        GEO[name].y = y

        GEO[name].z = z

        GEO[name].o = orientation

           

        -- Coordinates' highs and lows depend on orientation

        if orientation == "z" then

            GEO[name].xlow = x - width / 2

            GEO[name].xhigh = x + width / 2

            GEO[name].ylow = y - height / 2

            GEO[name].yhigh = y + height / 2

            GEO[name].zlow = z

            GEO[name].zhigh = z

        elseif orientation == "x" then

            GEO[name].xlow = x

            GEO[name].xhigh = x

            GEO[name].ylow = y - width / 2

            GEO[name].yhigh = y + width / 2

            GEO[name].zlow = z - height / 2

            GEO[name].zhigh = z + height / 2

        elseif orientation == "y" then

            GEO[name].xlow = x - width / 2

            GEO[name].xhigh = x + width / 2

            GEO[name].ylow = y

            GEO[name].yhigh = y

            GEO[name].zlow = z - height / 2

            GEO[name].zhigh = z + height / 2

        end

           

        -- Initialize monitor and contain tables

        GEO[name].m = {}

        GEO[name].c = {}

           

        -- Initialize list of antigeos

        GEO[name].anti = {}

           

        hprintf("Rectangle \"" .. name .. "\" created.")

        setmetatable(GEO[name], GEO)

        return GEO[name]

    end

       

    hprintf("Invalid name: \""  .. name .. "\"")

 

function GEO.get(name)

 

    return GEO[name]

 

function GEO.clear()

 

    for k,v in pairs(GEO) do

        if type(v) == "table" and k ~= "__index" then  -- make sure we're actually getting a GEO object

            v:delete()  -- Delete every GEO

        end

    end

 

function GEO:delete()

 

    -- Get rid of perimeter and surface objects

    self:hide()

       

    -- Make sure any GEO that this is an AntiGEO of is aware that this GEO no longer exists

    for k,v in pairs(GEO) do

        if type(v) == "table" and k ~= "__index" then

            for name,bool in pairs(v.anti) do

                if name == self.n then

                    GEO[v.n].anti[name] = nil

                    break

                end

            end

        end

    end

       

    -- Nullify GEO

    GEO[self.n] = nil

    hprintf("Geo \"" .. self.n .. "\" deleted.")

 

function GEO:move(x, y, z)

 

    -- Move the center of the object

    -- Default to GEO's current coordinates

    GEO[self.n].x = x or GEO[self.n].x

    GEO[self.n].y = y or GEO[self.n].y

    GEO[self.n].z = z or GEO[self.n].z

       

    -- If this is a rectangular prism...

    if self.t == "rectprism" then

        -- Change the x, y, and z lows and highs accordingly to adjust to the new center

        GEO[self.n].xlow = x - GEO[self.n].lx / 2  

        GEO[self.n].xhigh = GEO[self.n].lx / 2 + x

        GEO[self.n].ylow = y - GEO[self.n].ly / 2

        GEO[self.n].yhigh = GEO[self.n].ly / 2 + y

        GEO[self.n].zlow = z - GEO[self.n].lz / 2

        GEO[self.n].zhigh = GEO[self.n].lz / 2 + z

       

    -- If this is a rectangle...

    elseif self.t == "rectangle" then

        -- Change the x, y, and z lows and highs accordingly to adjust to the new center (depends on orientation)

        if self.o == "z" then

            GEO[self.n].xlow = self.x - self.width / 2

            GEO[self.n].xhigh = self.x + self.width / 2

            GEO[self.n].ylow = self.y - self.height / 2

            GEO[self.n].yhigh = self.y + self.height / 2

            GEO[self.n].zlow = self.z

            GEO[self.n].zhigh = self.z

        elseif self.o == "x" then

            GEO[self.n].xlow = self.x

            GEO[self.n].xhigh = self.x

            GEO[self.n].ylow = self.y - self.width / 2

            GEO[self.n].yhigh = self.y + self.width / 2

            GEO[self.n].zlow = self.z - self.height / 2

            GEO[self.n].zhigh = self.z + self.height / 2

        elseif self.o == "y" then

            GEO[self.n].xlow = self.x - self.width / 2

            GEO[self.n].xhigh = self.x + self.width / 2

            GEO[self.n].ylow = self.y

            GEO[self.n].yhigh = self.y

            GEO[self.n].zlow = self.z - self.height / 2

            GEO[self.n].zhigh = self.z + self.height / 2

        end

       

    -- If this is a cylinder...

    elseif self.t == "cylinder" then

        GEO[self.n].hlow = self[self.o] - self.h / 2

        GEO[self.n].hhigh = self[self.o] + self.h / 2

    end

 

function GEO:radius(new)

 

    if self.t == "sphere" or self.t == "circle" or self.t == "cylinder" then

        if new then  -- If "new" is defined...

            GEO[self.n].r = new  -- Change the radius to its value.

        else  -- If not...

            return GEO[self.n].r  -- Return its current radius.

        end

    end

 

function GEO:size(x, y, z)

 

    -- If this is a rectangular prism...

    if self.t == "rectprism" then

        if x or y or z then  -- If any of these variables have been defined...

            -- Adjust lengths and x, y, and z highs and lows accordingly.

            GEO[self.n].lx = x or GEO[self.n].lx

            GEO[self.n].ly = y or GEO[self.n].ly

            GEO[self.n].lz = z or GEO[self.n].lz

            GEO[self.n].xlow = GEO[self.n].x - x / 2

            GEO[self.n].xhigh = x / 2 + GEO[self.n].x

            GEO[self.n].ylow = GEO[self.n].y - y / 2

            GEO[self.n].yhigh = y / 2 + GEO[self.n].y

            GEO[self.n].zlow = GEO[self.n].z - z / 2

            GEO[self.n].zhigh = z / 2 + GEO[self.n].z

        else  -- Otherwise...

            return GEO[self.n].lx, GEO[self.n].ly, GEO[self.n].lz  -- Return the x, y, and z lengths.

        end

       

    -- If this is a rectangle...

    elseif self.t == "rectangle" then

        if x or y or z then  -- If any of these variables are defined...

            -- Adjust width, height, and x, y, and z highs and lows accordingly (depends on orientation).

            if self.o == "z" then

                GEO[self.n].width = x

                GEO[self.n].height = y

                GEO[self.n].xlow = self.x - self.width / 2

                GEO[self.n].xhigh = self.x + self.width / 2

                GEO[self.n].ylow = self.y - self.height / 2

                GEO[self.n].yhigh = self.y + self.height / 2

                GEO[self.n].zlow = self.z

                GEO[self.n].zhigh = self.z

            elseif self.o == "x" then

                GEO[self.n].width = y

                GEO[self.n].height = z

                GEO[self.n].xlow = self.x

                GEO[self.n].xhigh = self.x

                GEO[self.n].ylow = self.y - self.width / 2

                GEO[self.n].yhigh = self.y + self.width / 2

                GEO[self.n].zlow = self.z - self.height / 2

                GEO[self.n].zhigh = self.z + self.height / 2

            elseif self.o == "y" then

                GEO[self.n].width = x

                GEO[self.n].height = z

                GEO[self.n].xlow = self.x - self.width / 2

                GEO[self.n].xhigh = self.x + self.width / 2

                GEO[self.n].ylow = self.y

                GEO[self.n].yhigh = self.y

                GEO[self.n].zlow = self.z - self.height / 2

                GEO[self.n].zhigh = self.z + self.height / 2

            end

        else  -- Otherwise...

            return GEO[self.n].width, GEO[self.n].height  -- Return the width and height of the rectangle.

        end

       

    -- If this is a cylinder...

    elseif self.t == "cylinder" then

        local h = x or y or z  -- Whichever variable is defined, it is taken as the height.

        if h then  -- If a height is specified...

            -- Adjust height and z high and low accordingly.

            GEO[self.n].h = h

            GEO[self.n].hlow = self[self.o] - h / 2

            GEO[self.n].hhigh = self[self.o] + h / 2

        else  -- Otherwise...

            return GEO[self.n].h  -- Return the height.

        end

    end

 

function GEO:extend(orientation, direction, amount)

 

    -- Change the direction from "+" or "-" to "high" or "low".

    local dir

    dir = string.gsub(direction, "-", "low")

    dir = string.gsub(direction, "+", "high")

       

    -- Get the face we're trying to extend (i.e. "xhigh")

    local face = string.lower(orientation) .. direction

       

    -- If this is a rectangular prism or a rectangle...

    if self.t == "rectprism" or self.t == "rectangle" then

        -- Make sure "face" is actually a valid face (and not something like "cheesederp")

        if self[face] then

            -- Use "GEO[self.n]" when you want to actually permanently change the value of something within the object; use "self" for reading information from the object.

            -- Change the length of the GEO in the orientation specified.

            GEO[self.n]["l" .. string.lower(orientation)] = self["l" .. string.lower(orientation)] + amount

               

            -- Figure out if the positive or negative face is being extended.

            if direction == "+" then

                GEO[self.n][face] = self[face] + amount

                GEO[self.n][string.lower(orientation)] = self[string.lower(orientation)] + amount / 2

            else

                GEO[self.n][face] = self[face] - amount

                GEO[self.n][string.lower(orientation)] = self[string.lower(orientation)] - amount / 2

            end

        end

       

    -- If this is a cylinder...

    elseif self.t == "cylinder" then

        -- The orientation must be the orientation of the cylinder

        if orientation == self.o then

            if self[face] then

                GEO[self.n].h = self.h + amount