[HELP] Help with Dynamic tree growth and recycling?

I have started a script that I find off Roblox Models. I redone the coding at lest I thought I was making it better which I was till I run in to problems. Let me explain what the code I have linked below should be doing and what I want it to do.

How the code works and should work: The code should create Trees. and grow the tree from the bottom up like a real tree should do. How ever I only got it to make the tree but the code is not doing what I need it to do It was working fine then it started doing strange things. It should create branches the more Complex meaning higher number means the more branches are groing to be added on to other branches but its limited to 2 - 4 pre branch and it then should rotate at a angle like real tree does with the branches randomly angles/rotations. It does do that how ever for some reason it just keeps putting them closer and closer together till the tree looks like one huge blob of just leaves and branches get to small they should only be allowed to go to the max size of Wide 1 and hieght 1 and length is random. I am not asking for anyone to up and create a complex tree system. That not why I am here just like to get help and maybe learn new stuff. I do give credits inreturn and If I can Vote on your Answer if it helps me out at all. The script I am trying to make is like Lumber Tycoon 2. At first I thought it was going to be easy how ever that turned out to be a LIE well at lest for me it did. Here example of how it should work. VIDEO: https://pbs.twimg.com/tweet_video/CIk5GizUkAEmrdi.mp4 Don't know If I am allowed to post links if not then I'll remove it but its from one of Defaultio post on Josh Twitter.

My Code:

local spawnedTrees = {}

local treeTypes = {
    [0] = {
        ["TreeClass"] = "Generic",
        ["Regions"] = {
            [0] = game.Workspace.Region_Main
        },
        ["Size"] = {
            ["Min"] = Vector2.new(1,7),
            ["Max"] = Vector2.new(2,11)
        },
        ["Branches"] = {
            ["Min"] = 2,
            ["Max"] = 4,
            ["Color"] = BrickColor.new("Bright red"),
            ["Material"] = Enum.Material.Concrete
        },
        ["Leaves"] = {
            ["Color"] = BrickColor.new("Really red"),
            ["Material"] = Enum.Material.Grass
        },
        ["Complex"] = {
            ["Min"] = 2,
            ["Max"] = 3
        },
        ["Config"] = {
            ["Min"] = 100,
            ["Max"] = 150,
            ["Growth"] = {
                ["FastMode"] = false,
                ["Hours"] = 0,
                ["Minutes"] = 0,
                ["Seconds"] = 10
            },
            ["Decay"] = {
                ["FastMode"] = false,
                ["Hours"] = 0,
                ["Minutes"] = 20,
                ["Seconds"] = 0
            }
        },
        ["Current"] = {
            ["Model"] = nil,
            ["Branch"] = nil,
            ["Branches"] = 0,
            ["Complex"] = 0,
            ["Width"] = 0,
            ["Heigth"] = 0
        },
    },
}

function getTreeParts(part, basePart)
    local tree = nil
    if part ~= nil and basePart == false and part == "T" then
        tree = Instance.new("Model")

        local cutEvent = Instance.new("BindableEvent",tree)
        cutEvent.Name = "CutEvent"

        local Owner = Instance.new("ObjectValue",tree)
        Owner.Name = "Owner"

        local LastInteraction = Instance.new("IntValue",Owner)
        LastInteraction.Name = "LastInteraction"

        local TreeClass = Instance.new("StringValue",tree)
        TreeClass.Name = "TreeClass"

        local Leaves = Instance.new("Model",tree)
        Leaves.Name = "Leaves"

        return tree
    elseif part ~= nil and basePart == true and part == "WS" then
        tree = part

        local ID = Instance.new("IntValue",tree)
        ID.Name = "ID"

        local ParentID = Instance.new("IntValue",tree)
        ParentID.Name = "ParentID"

        local ChildIDs = Instance.new("IntValue",tree)
        ChildIDs.Name = "ChildIDs"

        local Child = Instance.new("IntValue",ChildIDs)
        Child.Name = "Child"

        local Angle = Instance.new("CFrameValue",Child)
        Angle.Name = "Angle"

        return tree
    end
    return nil
end

-- get dot product of yz angles
function dot(c1,c2)
    local m = CFrame.Angles(math.pi/2,0,0)
    return (c1*m).lookVector:Dot((c2*m).lookVector)
end

-- multiplier for various sizes of foliage
local leaf_mult = {
    Vector3.new(1.5,1.5,1.2);
    Vector3.new(1.5,1,1.5);
    Vector3.new(1.2,1.5,1.5);
    Vector3.new(1.5,1.5,1.5);
}

function setSurfaceType(part)
    part.Anchored = true
    part.BackSurface = Enum.SurfaceType.SmoothNoOutlines
    part.FrontSurface = Enum.SurfaceType.SmoothNoOutlines
    part.RightSurface = Enum.SurfaceType.SmoothNoOutlines
    part.LeftSurface = Enum.SurfaceType.SmoothNoOutlines
    part.TopSurface = Enum.SurfaceType.SmoothNoOutlines
    part.BottomSurface = Enum.SurfaceType.SmoothNoOutlines
end

function Branch(tree, complexity, treeM)
    if complexity <= 0 then
        -- if the complexity has run out, generate some foliage
        local leaves = Instance.new("Part")
        setSurfaceType(leaves)
        leaves.CanCollide = false
        leaves.Material = treeM["Leaves"]["Material"]
        leaves.BrickColor = treeM["Leaves"]["Color"]
        local vol = tree.Size.x + tree.Size.y + tree.Size.z 
        -- determine size based on branch size 
        leaves.Size = (leaf_mult[math.random(1,#leaf_mult)]*math.random(vol/3*10,vol/3*12)/10)*0.75
        leaves.CFrame = tree.CFrame * CFrame.new(0,tree.Size.y/2,0)
         -- center foliage at top of branch
        leaves.Parent = treeM["Current"]["Model"].Leaves
    else
        -- otherwise, make some more branches
        local pos = tree.CFrame*CFrame.new(0,tree.Size/2,0)
        local height = tree.Size.y
        local width = tree.Size.x
        local branches = treeM["Current"]["Branches"]
        -- # of possible branches (2 seems to work fine for now)
        local rotation = math.random(45,135) 
        -- rotation of branches on y axis

        -- branch split angle difference
        -- the less complexity, the greater the possible angle
        -- minimum: 20-75; maximum: 40-80
        -- local da = math.random(20+55/complexity,40+40/complexity)
        local differenceAngle = math.random(75/complexity,80/complexity)

        -- branch angle (overall angle of all branches)
        local branchAngle = math.random(-differenceAngle/3,differenceAngle/3)
        print("Name : " .. treeM["TreeClass"] .. " Angle : " .. branchAngle+differenceAngle/2)
        -- branchAngle+differenceAnge/2 shouldn't be near or greater than 90 degrees

        for i = 0, branches-1 do 
            -- for each branch
            local branch = tree:Clone()
            branch.Name = "WoodSection"
            local h = height*math.random(95,115)/100 
            -- height .95 to 1.15 of original

            -- make new cframe
            -- move new to top of base, then apply branch angle (ba)
            local new = branch.CFrame * CFrame.new(0,height/2,0) * CFrame.Angles(0,0,math.rad(branchAngle))
            -- next, rotate branch so that it faces away from others, also apply overall rotation (r)
            -- also, apply the split angle (da)
            -- finally, move branch upward by half it's size
            new = new * CFrame.Angles(0,i*(math.pi*2/branches)+rotation,math.rad(differenceAngle/2)) * CFrame.new(0,h/2,0)

            -- determine width by branch's final angle; greater the angle, smaller the width
            -- also shave off a bit of width for more dramatic change in size
            -- a frustum cone mesh would really help here
            local w = dot(new,branch.CFrame)*width*0.9

            branch.Size = Vector3.new(w,h,w)
            branch.CFrame = new
            branch.Material = treeM["Branches"]["Material"]
            branch.BrickColor = treeM["Branches"]["Color"]
            branch.Parent = treeM["Current"]["Model"]

            -- create the next set of branches with one less complexity
            Branch(branch, complexity-1, treeM)
        end
    end
    wait()  -- remove to generate faster
end

-- Main Function ----------------
function _G.GenerateTree(location, treeTypeID)
    local tree = treeTypes[treeTypeID]
    tree["Current"]["Model"] = getTreeParts("T", false)
    tree["Current"]["Model"].Parent = game.Workspace
    tree["Current"]["Width"] = math.random(tree["Size"]["Min"].x, tree["Size"]["Max"].x)
    tree["Current"]["Heigth"] = math.random(tree["Size"]["Min"].y, tree["Size"]["Max"].y)
    tree["Current"]["Complex"] = math.random(tree["Complex"]["Min"], tree["Complex"]["Max"])
    tree["Current"]["Branches"] = math.random(tree["Branches"]["Min"], tree["Branches"]["Max"])
    local WoodSection = Instance.new("Part", tree["Current"]["Model"])
    setSurfaceType(WoodSection)
    WoodSection.Name = "WoodSection"
    WoodSection.BrickColor = tree["Branches"]["Color"]
    WoodSection.Material = tree["Branches"]["Material"]
    WoodSection.Size = Vector3.new(tree["Current"]["Width"], tree["Current"]["Heigth"], tree["Current"]["Width"])
    -- move up by half its height, and rotate randomly
    WoodSection.CFrame = CFrame.new(location) * CFrame.new(0,tree["Current"]["Heigth"]/2,0) * CFrame.Angles(0,math.rad(math.random(1,360)),0)
    tree["Current"]["Branch"] = WoodSection
    -- start branching
    Branch(WoodSection, tree["Current"]["Complex"], tree)
    return tree
end

function snapToGrid(p, gH, gW, gD)
    return p.x - (p.x % gW), p.y - (p.y % gH), p.z - (p.z % gD)
end

function clamp(n, a, b)
    local temp = a;
    a, b = math.min(a, b), math.max(temp, b)
    return math.min(math.max(n, a), b)
end

local pos = game.Workspace.Region_Main.Ground.Position
local size = game.Workspace.Region_Main.Ground.Size/2.04
local pos1 = Vector3.new((pos.X + size.X)-0.01, pos.Y, (pos.Z - size.Z)+0.01)
local pos2 = Vector3.new((pos.X - size.X)+0.01, pos.Y, (pos.Z + size.Z)-0.01)
local highBounds = Vector3.new(pos2.X, pos2.Y, pos2.Z)
local lowBounds = Vector3.new(pos1.X, pos1.Y, pos1.Z)

local minX = math.min(lowBounds.X, highBounds.X);
local minZ = math.min(lowBounds.Z, highBounds.Z);
local maxX = math.max(lowBounds.X, highBounds.X);
local maxZ = math.max(lowBounds.Z, highBounds.Z);

function setupTreeeRegion()
    local x = minX
    local z = minZ
    for x = minX, maxX, 30 do
        for z = minZ, maxZ, 30 do
            if math.random() < 0.09 then
                local xx, yy, zz = snapToGrid(Vector3.new(x,pos.Y,z), 1, 30, 30)
                xx = clamp(xx, lowBounds.X, highBounds.X)
                yy = clamp(yy, lowBounds.Y, highBounds.Y)
                zz = clamp(zz, lowBounds.Z, highBounds.Z)
                print(math.floor(xx), math.floor(yy), math.floor(zz))
                _G.GenerateTree(Vector3.new(xx,yy,zz), 0)
            end
        end
    end
end
setupTreeeRegion()