コード例 #1
0
    void loadNodes(STSerializedNode sNode)
    {
        mRotor.transform.rotation = new Quaternion(sNode.rotation.X, sNode.rotation.Y, sNode.rotation.Z, sNode.rotation.W);
        transform.localPosition   = new Vector3(sNode.position.X, sNode.position.Y, sNode.position.Z);

        if (sNode.node_type == 1)
        {
            this.changeNodeType();
        }
        if (sNode.children == null)
        {
            return;
        }

        foreach (STSerializedNode nodeChild in sNode.children)
        {
            STRootNode root = STLevel.GetRootNode();
            STNode     node = Instantiate(root.NodePref) as STNode;
            if (node != null)
            {
                node.transform.parent = mRotor.transform;
                node.mParent          = this;
                mRotor.mChilds.Add(node);
                node.LoadNodes(nodeChild);
            }
        }
    }
コード例 #2
0
    public void GenNextNode(int N, int depth, int prevPattern, int curBranchLength)
    {
        if (N == 0)
        {
            return;
        }

        STPattern      pattern       = STPatternManager.GetPattern(depth);
        List <int>     paternVects   = new List <int>();
        List <Vector3> vectPositions = STLevel.GetNodesNet().GetGenPositions(pattern, transform.position, prevPattern, paternVects, curBranchLength);
        int            i             = 0;

        if (vectPositions != null)
        {
            foreach (Vector3 nodePos in vectPositions)
            {
                STRootNode root     = STLevel.GetRootNode();
                STNode     nodePref = Instantiate(root.NodePref) as STNode;
                if (nodePref != null)
                {
                    nodePref.brenchLength = this.brenchLength + (((paternVects[i] - 1) / 8) + 1);

                    nodePref.transform.parent = mRotor.transform;
                    nodePref.mParent          = this;

                    nodePref.nodeDepth = depth;
                    mRotor.mChilds.Add(nodePref);
                    nodePref.transform.position = new Vector3(nodePos.x, nodePos.y, -depth);

                    STLevel.GetRootNode().SetTreeDepth(depth);
                }

                i++;
            }
        }

        i = 0;

        foreach (STNode node in mRotor.mChilds)
        {
            node.GenNextNode(N - 1, depth + 1, paternVects[i], node.brenchLength);
            i++;
        }
    }
コード例 #3
0
    public void MirrorLevel(STNode prevNode, bool isFlipped, bool isYMirror)
    {
        List <Vector3> positions = new List <Vector3> ();

        foreach (STNode node in mRotor.mChilds)
        {
            if (isFlipped == false)
            {
                if (isYMirror == true)
                {
                    positions.Add(new Vector3(node.transform.position.x, -node.transform.position.y, node.transform.position.z));
                }
                else
                {
                    positions.Add(new Vector3(-node.transform.position.x, node.transform.position.y, node.transform.position.z));
                }
            }
            else
            {
                positions.Add(new Vector3(-node.transform.position.x, -node.transform.position.y, node.transform.position.z));
            }
        }

        int i = 0;

        foreach (Vector3 nodePos in positions)
        {
            STRootNode root     = STLevel.GetRootNode();
            STNode     nodePref = Instantiate(root.NodePref) as STNode;
            nodePref.transform.position = nodePos;
            prevNode.mRotor.mChilds.Add(nodePref);
            nodePref.transform.parent = prevNode.mRotor.transform;
            nodePref.mParent          = prevNode;
            if (mRotor.mChilds.Count > 0)
            {
                nodePref.nodeDepth = mRotor.mChilds[0].nodeDepth;
            }
            mRotor.mChilds[i].MirrorLevel(nodePref, isFlipped, isYMirror);
            i++;
        }
    }
コード例 #4
0
    void iListener.OnEvent(EVENT_T t, float val, iListener ch)
    {
        switch (t)
        {
        case (EVENT_T.ON_ADD): {
            distAdd  = 1;
            angleAdd = 0;

            STRootNode root = STLevel.GetRootNode();

            if (root != null)
            {
                STNode node = Instantiate(root.NodePref) as STNode;
                if (node != null)
                {
                    node.transform.parent = mRotor.transform;

                    do
                    {
                        if (distAdd > 5)
                        {
                            break;
                        }

                        if (angleAdd >= 360)
                        {
                            angleAdd = 0;
                            distAdd++;
                        }

                        Vector3 transformPos = new Vector3(STLevel.GetNodesNet().NetBtwNodesWidth() * Mathf.Cos(angleAdd / 180 * Mathf.PI) * distAdd, STLevel.GetNodesNet().NetBtwNodesWidth() * Mathf.Sin(angleAdd / 180 * Mathf.PI) * distAdd, 0);
                        node.transform.localPosition = mRotor.transform.localPosition + transformPos;

                        angleAdd += 45;

                        node.transform.position = STLevel.GetNodesNet().GetClothestNetNodePos(node.transform.position);

                        Debug.Log(node.transform.position);
                    }while(STLevel.GetRootNode().CheckForIntersection(node.transform.position.x, node.transform.position.y, transform.position.x, transform.position.y, 0, 0) == true);

                    node.transform.localRotation = mRotor.transform.localRotation;
                    node.mParent = this;
                    mRotor.mChilds.Add(node);

                    STLevel.GetNodesNet().ShowElementNetNode(transform.position);
                    STLevel.GetNodesNet().HideElementNetNode();
                    //node.mLink.UpdatePos (transform.position);


                    Vector3 thepos = STLevel.GetNodesNet().GetClothestNetNodePos(node.transform.position);
                    node.transform.position = new Vector3(thepos.x, thepos.y, node.transform.position.z);
                    node.UpdateLinkPosition(node.transform.position);

                    showBranchSelection();
                }
            }
            break;
        }

        case (EVENT_T.ON_REMOVE):
        {
            if (mParent != null)
            {
                Destroy(this.gameObject);
                mParent.mRotor.mChilds.Remove(this);
            }

            break;
        }


        case (EVENT_T.ON_CHANGE):
        {
            this.changeNodeType();
            STLevel.UpdateActiveNodes();
            break;
        }
        }
    }