예제 #1
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public override void MarkSubtree(cpBBTree tree, Node staticRoot, Func<object, object, ulong, object, ulong> func)
        {
            if (this.stamp == tree.GetStamp())
            {
                if (staticRoot != null) staticRoot.MarkLeafQuery(this, false, tree, func);

                for (Node node = this; node?.parent != null; node = node.parent)
                {
                    if (node == node.parent.A)
                    {
                        node.parent.B.MarkLeafQuery(this, true, tree, func);
                    }
                    else
                    {
                        node.parent.A.MarkLeafQuery(this, false, tree, func);
                    }
                }
            }
            else
            {
                var pair = this.pairs;
                while (pair != null)
                {
                    if (this == pair.b.leaf)
                    {
                        if (func != null)
                            func(pair.a.leaf.obj, this.obj, pair.id, null);

                        pair = pair.b.next;
                    }
                    else
                    {
                        pair = pair.a.next;
                    }
                }
            }
        }
예제 #2
0
파일: cp.cs 프로젝트: kfazi/AgarIo
 public static bool bbTreeIntersectsNode(Node a, Node b)
 {
     return (a.bb.l <= b.bb.r && b.bb.l <= a.bb.r && a.bb.b <= b.bb.t && b.bb.b <= a.bb.t);
 }
예제 #3
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public void SubtreeQuery(Node subtree, object obj, cpBB bb, Func<object, object, ulong, object, ulong> func, ref object data)
 {
     //if(bbIntersectsBB(subtree.bb, bb)){
     if (subtree.bb.Intersects(bb))
     {
         if (subtree.isLeaf)
         {
             func(obj, subtree.obj, 0, data);
         }
         else
         {
             SubtreeQuery(subtree.A, obj, bb, func, ref data);
             SubtreeQuery(subtree.B, obj, bb, func, ref data);
         }
     }
 }
예제 #4
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public Node SubtreeRemove(Node subtree, Leaf leaf)
        {
            if (leaf == subtree)
            {
                return null;
            }
            else
            {
                var parent = leaf.parent;
                if (parent == subtree)
                {
                    var other = subtree.Other(leaf);
                    other.parent = subtree.parent;
                    //NodeRecycle();
                    subtree.Recycle(this);
                    return other;
                }
                else
                {
                    if (parent == null)
                        return null;

                    parent.parent.ReplaceChild(parent, parent.Other(leaf), this);
                    return subtree;
                }
            }
        }
예제 #5
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public float NodeSegmentQuery(Node node, cpVect a, cpVect b)
        {
            float idx = 1 / (b.x - a.x);
            float tx1 = (node.bb.l == a.x ? -cp.Infinity : (node.bb.l - a.x) * idx);
            float tx2 = (node.bb.r == a.x ? cp.Infinity : (node.bb.r - a.x) * idx);
            float txmin = cp.cpfmin(tx1, tx2);
            float txmax = cp.cpfmax(tx1, tx2);

            float idy = 1 / (b.y - a.y);
            float ty1 = (node.bb.b == a.y ? -cp.Infinity : (node.bb.b - a.y) * idy);
            float ty2 = (node.bb.t == a.y ? cp.Infinity : (node.bb.t - a.y) * idy);
            float tymin = cp.cpfmin(ty1, ty2);
            float tymax = cp.cpfmax(ty1, ty2);

            if (tymin <= txmax && txmin <= tymax)
            {
                float min_ = cp.cpfmax(txmin, tymin);
                float max_ = cp.cpfmin(txmax, tymax);

                if (0.0 <= max_ && min_ <= 1.0f) return cp.cpfmax(min_, 0.0f);
            }

            return cp.Infinity;
        }
예제 #6
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public void PairsClear(Node leaf)
        {
            Pair pair = leaf.pairs;
            Pair next;
            leaf.PAIRS = null;

            while (pair != null)
            {
                if (pair.a.leaf == leaf)
                {
                    next = pair.a.next;
                    pair.b.Unlink();
                    PairRecycle(pair);
                    pair = next;

                }
                else
                {
                    next = pair.b.next;
                    pair.a.Unlink();// ThreadUnlink();
                    PairRecycle(pair);
                    pair = next;
                }

            }
        }
예제 #7
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public virtual void MarkSubtree(cpBBTree tree, Node staticRoot, Func<object, object, ulong, object, ulong> func)
 {
     this.a.MarkSubtree(tree, staticRoot, func);
     this.b.MarkSubtree(tree, staticRoot, func);
 }
예제 #8
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public Pair MakePair(Node leafA, Pair nextA, Node leafB, Pair nextB)
        {
            var pair = this.pooledPairs;
            if (pair != null)
            {
                this.pooledPairs = pair.a.prev;

                pair.a.prev = null;
                pair.a.leaf = leafA;
                pair.a.next = nextA;

                pair.b.prev = null;
                pair.b.leaf = leafB;
                pair.b.next = nextB;

                return pair;
            }
            else
            {
                cp.numPairs++;
                return new Pair(leafA, nextA, leafB, nextB);
            }
        }
예제 #9
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public Node(Node a, Node b, cpBBTree tree)
        {
            this.obj = null;

            bb = cpBB.Merge(a.bb, b.bb);

            parent = null;

            this.SetA(a);
            this.SetB(b);
        }
예제 #10
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public MarkContext(cpBBTree tree, Node staticRoot, Func<object, object, ulong, object, ulong> func, object data)
 {
     this.tree = tree;
     this.staticRoot = staticRoot;
     this.func = func;
     this.data = data;
 }
예제 #11
0
파일: cp.cs 프로젝트: kfazi/AgarIo
        public static void nodeRender(Node node, int depth)
        {
            if (!node.isLeaf && depth <= 10)
            {
                nodeRender(node.A, depth + 1);
                nodeRender(node.B, depth + 1);
            }

            var str = "";
            for (var i = 0; i < depth; i++)
            {
                str += " ";
            }

            Trace(str + node.bb.b + " " + node.bb.t);
        }
예제 #12
0
파일: cp.cs 프로젝트: kfazi/AgarIo
 /// ///////////////////////////////////////////////////////////////////
 public static float bbTreeMergedArea2(Node node, float l, float b, float r, float t)
 {
     return (cp.cpfmax(node.bb.r, r) - cp.cpfmin(node.bb.l, l)) * (cp.cpfmax(node.bb.t, t) - cp.cpfmin(node.bb.b, b));
 }
예제 #13
0
파일: cp.cs 프로젝트: kfazi/AgarIo
 public static float bbTreeMergedArea(Node a, Node b)
 {
     return (cp.cpfmax(a.bb.r, b.bb.r) - cp.cpfmin(a.bb.l, b.bb.l)) * (cp.cpfmax(a.bb.t, b.bb.t) - cp.cpfmin(a.bb.b, b.bb.b));
 }
예제 #14
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public static void Unlink(Pair prev, Node leaf, Pair next)
        {
            if (next != null)
            {
                if (next.a.leaf == leaf)
                    next.a.prev = prev;
                else next.b.prev = prev;
            }

            if (prev != null)
            {
                if (prev.a.leaf == leaf) prev.a.next = next;
                else prev.b.next = next;
            }
            else
            {
                leaf.pairs = next;
            }
        }
예제 #15
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public Node Other(Node child)
 {
     return (this.A == child ? this.B : this.A);
 }
예제 #16
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public Node MakeNode(Node a, Node b)
 {
     var node = this.pooledNodes;
     if (node != null)
     {
         this.pooledNodes = node.parent;
         node = new Node(a, b, this);
         return node;
     }
     else
     {
         cp.numNodes++;
         return new Node(a, b, this);
     }
 }
예제 #17
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public virtual void Recycle(cpBBTree tree)
 {
     this.parent = tree.pooledNodes;
     tree.pooledNodes = this;
 }
예제 #18
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 //MARK: Node Functions
 public virtual void NodeRecycle(Node node)
 {
     node.parent = this.pooledNodes;
     this.pooledNodes = node;
 }
예제 #19
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public void ReplaceChild(Node child, Node value, cpBBTree tree)
        {
            cp.AssertSoft(child == this.A || child == this.B, "Node is not a child of parent.");

            if (this.A == child)
            {
                tree.NodeRecycle(this.A);//.Recycle(tree);
                this.SetA(value);
            }
            else
            {
                tree.NodeRecycle(this.B);
                this.SetB(value);
            }

            for (var node = this; node != null; node = node.parent)
            {
                node.bb = node.A.bb.Merge(node.B.bb);
            }
        }
예제 #20
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public void PairInsert(Node a, Node b)
        {
            Pair nextA = a.PAIRS, nextB = b.PAIRS;
            Pair pair = MakePair(a, nextA, b, nextB);

            a.pairs = b.pairs = pair;

            if (nextA != null)
            {
                if (nextA.a.leaf == a) nextA.a.prev = pair; else nextA.b.prev = pair;
            }

            if (nextB != null)
            {
                if (nextB.a.leaf == b) nextB.a.prev = pair; else nextB.b.prev = pair;
            }
        }
예제 #21
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public void SetA(Node value)
 {
     this.a = value;
     value.parent = this;
 }
예제 #22
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public Node SubtreeInsert(Node subtree, Leaf leaf)
        {
            if (subtree == null)
            {
                return leaf;
            }
            else if (subtree.isLeaf)
            {
                return MakeNode(leaf, subtree);
            }
            else
            {
                var cost_a = subtree.B.bbArea() + subtree.A.bb.MergedArea(leaf.bb);
                var cost_b = subtree.A.bbArea() + subtree.B.bb.MergedArea(leaf.bb);

                if (cost_a == cost_b)
                {
                    cost_a = subtree.A.bb.Proximity(leaf.bb);
                    cost_b = subtree.B.bb.Proximity(leaf.bb);
                }

                if (cost_b < cost_a)
                {
                    subtree.SetB(SubtreeInsert(subtree.B, leaf));
                }
                else
                {
                    subtree.SetA(SubtreeInsert(subtree.A, leaf));
                }

                //		subtree.bb = bbMerge(subtree.bb, leaf.bb);
                subtree.bb.l = Math.Min(subtree.bb.l, leaf.bb.l);
                subtree.bb.b = Math.Min(subtree.bb.b, leaf.bb.b);
                subtree.bb.r = Math.Max(subtree.bb.r, leaf.bb.r);
                subtree.bb.t = Math.Max(subtree.bb.t, leaf.bb.t);

                return subtree;
            }
        }
예제 #23
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public void SetB(Node value)
 {
     this.b = value;
     value.parent = this;
 }
예제 #24
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public void SubtreeRecycle(Node node)
 {
     if (!node.isLeaf)
     {
         SubtreeRecycle(node.A);
         SubtreeRecycle(node.B);
         NodeRecycle(node);
     }
 }
예제 #25
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 // Objects created with constructors are faster than object literals. :(
 public Pair(Node leafA, Pair nextA, Node leafB, Pair nextB)
 {
     a = new Thread(null, leafA, nextA);
     b = new Thread(null, leafB, nextB);
     id = 0;
 }
예제 #26
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
        public float SubtreeSegmentQuery(Node subtree, object obj, cpVect a, cpVect b, float t_exit, Func<object, object, object, float> func, object data)
        {
            if (subtree.isLeaf)
            {
                return func(obj, subtree.obj, data);
            }
            else
            {
                float t_a = subtree.A.bb.SegmentQuery(a, b);
                float t_b = subtree.B.bb.SegmentQuery(a, b);

                if (t_a < t_b)
                {
                    if (t_a < t_exit) t_exit = cp.cpfmin(t_exit, SubtreeSegmentQuery(subtree.A, obj, a, b, t_exit, func, data));
                    if (t_b < t_exit) t_exit = cp.cpfmin(t_exit, SubtreeSegmentQuery(subtree.B, obj, a, b, t_exit, func, data));
                }
                else
                {
                    if (t_b < t_exit) t_exit = cp.cpfmin(t_exit, SubtreeSegmentQuery(subtree.B, obj, a, b, t_exit, func, data));
                    if (t_a < t_exit) t_exit = cp.cpfmin(t_exit, SubtreeSegmentQuery(subtree.A, obj, a, b, t_exit, func, data));
                }

                return t_exit;
            }
        }
예제 #27
0
파일: cpBBTree.cs 프로젝트: kfazi/AgarIo
 public Thread(Pair prev, Node leaf, Pair next)
 {
     this.prev = prev;
     this.leaf = leaf;
     this.next = next;
 }
예제 #28
0
파일: cpBB.cs 프로젝트: kfazi/AgarIo
 public static float Proximity(Node a, Leaf b)
 {
     return Proximity(a.bb, b.bb);
 }
예제 #29
0
파일: cp.cs 프로젝트: kfazi/AgarIo
 public static float bbProximity(Node a, Node b)
 {
     return cp.cpfabs(a.bb.l + a.bb.r - b.bb.l - b.bb.r) + cp.cpfabs(a.bb.b + a.bb.t - b.bb.b - b.bb.t);
 }