Exemple #1
0
 public void AddBalancedNode(DSTNode node)
 {
     if (balancedNodes == null)
     {
         balancedNodes = new List<DSTNode>();
     }
     if (!balancedNodes.Contains(node))
     {
         balancedNodes.Add(node);
     }
 }
Exemple #2
0
 public static void RemoveDrawer(DSTNode node)
 {
     if (nodes == null)
     {
         return;
     }
     if (nodes.Contains(node))
     {
         nodes.Remove(node);
     }
 }
Exemple #3
0
 public static void AddDrawer(DSTNode node)
 {
     if (nodes == null)
     {
         nodes = new List<DSTNode>();
     }
     if (!nodes.Contains(node))
     {
         nodes.Add(node);
     }
 }
Exemple #4
0
    public void Awake()
    {
        if (nodeRoot == null)
        {
            nodeRoot = new DSTNode(true);

        }
   
        proximityLeaf = new DSTNode(transform.position,Radius, true);
        nodeRoot.Insert(proximityLeaf);     

    }
Exemple #5
0
    public void AddLeaf(DSTNode node)
    {
        if (subNodes != null && subNodes.Count > 0)
        {
            DebugOutput.Shout("there is subnodes already here.");
        }
        else
        {
            if (leaves == null)
            {
                leaves = new List<DSTNode>();
            }
            leaves.Add(node);
            node.parent = this;

        }
    }
Exemple #6
0
    public void AddNode(DSTNode node)
    {
        if (subNodes == null)
        {
            subNodes = new List<DSTNode>();
        }
        subNodes.Add(node);
        node.parent = this;

        if (node.leaf)
        {
            DebugOutput.Shout("penis leaf");
        }
    }
Exemple #7
0
 public void Swap(DSTNode oldNode, DSTNode newNode)
 {
     if(subNodes !=null)
     {
         subNodes.Remove(oldNode);
         AddNode(newNode);
         newNode.position = oldNode.position;
     }
 }
Exemple #8
0
 public void RemoveLeaf(DSTNode node)
 {
     leaves.Remove(node);
     node.parent = null;
 }
Exemple #9
0
    public void InsertLeaf(DSTNode node)
    {
        if (leaves == null)
        {
            leaves = new List<DSTNode>();
        }
        AddLeaf(node);

        if (leaves.Count >= maxLeaves)
        {

            if (parent != null)
            {
                //first check if we can rebalance siblings
                if (CheckParentSpace())
                {
                    //DebugOutput.Shout("there is space in siblings, doing KMeanSplit");
                    parent.KMeanSplit();

                }
                else
                {
                    // if we cant rebalance we have to split current
                    //DebugOutput.Shout("Expanding this node instead");

                    ExpandThisNode();
                }
            }
            else
            {
                DebugOutput.Shout("Parent is null");
            }

            //do that split yo
        }
    }
Exemple #10
0
    public void Insert(DSTNode node)
    {
        if (leaf)
        {
            DebugOutput.Shout("leaf penis");
            return;
        }
        /*if (subNodes == null )
        {
            if (subNodes == null)
            {
                subNodes = new List<DSTNode>();
                endBranch = true;
            }

            //insert right here
        }*/
        if (subNodes == null)
        {
            subNodes = new List<DSTNode>();
        }

        if (subNodes != null)
        {
            if (subNodes.Count > 0)
            {
            // there is subnodes!
                bool inserted = false;
                foreach (var branch in subNodes)
                {
                    if (branch.isPointInside(node.position))
                    {
                        branch.Insert(node);
                        inserted = true;
                        break;
                    }
                }
                if (!inserted)
                {

                    //find closest with least expansion;
                    DSTNode smallestGrowthNode = FindLeastExpanded(node);

                    if (smallestGrowthNode != null)
                    {
                        smallestGrowthNode.Insert(node);
                    }
                    else
                    {
                        DebugOutput.Shout("Failed to insert node some where");
                    }

                }
            }
            else
            {
                InsertLeaf(node);

            }
        }

        Resize();

        //does Node have Subnodes
    }
Exemple #11
0
    public DSTNode FindLeastExpanded(DSTNode node)
    {
        float minAreaGrowth = 0.0f;
        float radiusSquared;
        DSTNode smallestGrowthNode = null;
        foreach (var branch in subNodes)
        {
            if (branch.subNodes == null || branch.subNodes.Count == 0)
            {
                return branch;
            }
            else
            {
                radiusSquared = (branch.position - node.position).sqrMagnitude;
                float areaGrowth = (3.14f * radiusSquared) - (3.14f * (radius * radius));
                if (minAreaGrowth == 0.0f || areaGrowth <= minAreaGrowth)
                {
                    minAreaGrowth = areaGrowth;
                    smallestGrowthNode = branch;
                    //parent = parentSub;
                }
            }

        }
        return smallestGrowthNode;
    }
Exemple #12
0
    public void ExpandThisNode()
    {
        DSTNode topSubNode = new DSTNode(Color.magenta);
        //topSubNode.parent = parent;
        parent.Swap(this, topSubNode);

        GizmoColor = Color.red;
        topSubNode.AddNode(this);
        topSubNode.AddNode(new DSTNode(Color.green));
        topSubNode.AddNode(new DSTNode(Color.blue));
        topSubNode.KMeanSplit();
        topSubNode.Resize();
    }