public static Vector3 GetDrawLineOffset(NetworkNode node, Direction direction)
        {
            if (node is TransitionNode)
            {
                return(Vector3.zero);
            }

            // 用自身的quaternion去乘,以修正3D中节点被旋转的情况
            if (direction == Direction.Up)
            {
                return(node.transform.localRotation * verticalOffset);
            }
            if (direction == Direction.Right)
            {
                return(node.transform.localRotation * horizontalOffset);
            }
            if (direction == Direction.Down)
            {
                return(node.transform.localRotation * -verticalOffset);
            }
            if (direction == Direction.Left)
            {
                return(node.transform.localRotation * -horizontalOffset);
            }
            return(Vector3.zero);
        }
 private void VisitNode(NetworkNode node)
 {
     if (!visitedNode.ContainsKey(node))
     {
         visitedNode.Add(node, true);
     }
     queue.Enqueue(node);
 }
 public void SetNeighbor(Direction direction, NetworkNode value)
 {
     Neighbors[(int)direction] = value;
     Debug.Log(string.Format("{0}: {1}, {2}, {3}, {4}", gameObject.name,
                             Neighbors[0] != null ? Neighbors[0].ToString() : "null",
                             Neighbors[1] != null ? Neighbors[1].ToString() : "null",
                             Neighbors[2] != null ? Neighbors[2].ToString() : "null",
                             Neighbors[3] != null ? Neighbors[3].ToString() : "null"));
 }
 private void RegisterEvents(NetworkNode node)
 {
     node.OnClick       += OnNodeClick;
     node.OnFocus       += OnNodeFocus;
     node.OnDataChanged += OnNodeDataChanged;
     if (node is EndNode)
     {
         (node as EndNode).OnPuzzleComplete += OnPuzzleComplete;
     }
 }
Beispiel #5
0
        public override void OnInit(NetworkNode node)
        {
            base.OnInit(node);
            IsUnlocked = false;

            ShowLock();
            for (int i = 0; i < NetworkNode.NeighborNum; i++)
            {
                InputLockSprites[i].gameObject.SetActive(InputLockSetting[i]);
            }
        }
 public Direction GetNeighborDirection(NetworkNode neighbor)
 {
     for (int i = 0; i < NeighborNum; i++)
     {
         if (GetNeighbor(i) == neighbor)
         {
             return((Direction)i);
         }
     }
     throw new Exception("is not neighbor");
 }
        public bool IsReachableTo(NetworkNode neighbor)
        {
            if (networkNodeLock != null)
            {
                return(false);
            }

            int direction = (int)GetNeighborDirection(neighbor);

            return(Outputs[direction]);
        }
Beispiel #8
0
        public override void OnInput(NetworkNode.Direction from, bool isActive)
        {
            base.OnInput(from, isActive);
            int i = (int)from;

            if (InputLockSetting[i])
            {
//				OnLockChanged(from, isActive);
                NetworkNode.SetSpriteActiveColor(InputLockSprites[i], isActive);
            }
            CheckLocks();
        }
Beispiel #9
0
 public override void OnClear()
 {
     base.OnClear();
     NetworkNode.SetSpriteActiveColor(LockBackgroundSprite, false);
     for (int i = 0; i < NetworkNode.NeighborNum; i++)
     {
         if (InputLockSetting[i])
         {
             NetworkNode.SetSpriteActiveColor(InputLockSprites[i], false);
         }
     }
 }
        private GameObject CreateFlowGameObject(NetworkNode first, NetworkNode second, NetworkNode.Direction direction)
        {
            Vector3 offset1 = NetworkNode.GetDrawLineOffset(first, direction);
            Vector3 offset2 = NetworkNode.GetDrawLineOffset(second, direction);

            GameObject   flowGo       = Instantiate(NetworkFlowPrefab, NetworkFlows);
            LineRenderer lineRenderer = flowGo.GetComponent <LineRenderer>();

            lineRenderer.SetPositions(new Vector3[]
            {
                first.transform.localPosition + offset1,
                second.transform.localPosition - offset2
            });
            return(flowGo);
        }
Beispiel #11
0
 private void CheckLocks()
 {
     IsUnlocked = true;
     for (int i = 0; i < NetworkNode.NeighborNum; i++)
     {
         if (InputLockSetting[i] && !node.Inputs[i])
         {
             IsUnlocked = false;
             break;
         }
     }
     NetworkNode.SetSpriteActiveColor(LockBackgroundSprite, IsUnlocked);
     if (OnCheckAllLock != null)
     {
         OnCheckAllLock(IsUnlocked);
     }
 }
Beispiel #12
0
        public void Deactivate(NetworkNode from, NetworkNode to)
        {
            if (from == FirstNode && to == SecondNode)
            {
                fromFirstNodeActive = false;
            }
            else if (from == SecondNode && to == FirstNode)
            {
                fromSecondNodeActive = false;
            }

            if (!fromFirstNodeActive && !fromSecondNodeActive)
            {
                IsActive = false;
                lineRenderer.startColor     = lineRenderer.endColor = NetworkBypassController.DeactiveColor;
                lineRenderer.material.color = NetworkBypassController.DeactiveColor;
            }
        }
        private void CreateFlowBetween(NetworkNode first, NetworkNode second, NetworkNode.Direction direction)
        {
            NetworkFlow existFlow = activeFlowList.Find(x => x.FirstNode == second && x.SecondNode == first);
            // 两条有向边共享同一个flow GameObject
            GameObject flowObject = existFlow == null?
                                    CreateFlowGameObject(first, second, direction) :
                                        existFlow.FlowObject;

            NetworkFlow newFlow = new NetworkFlow(flowObject)
            {
                FirstNode  = first,
                SecondNode = second,
                Direction  = direction
            };

            first.SetFlow(direction, newFlow);
            activeFlowList.Add(newFlow);
        }
Beispiel #14
0
 public virtual void OnInit(NetworkNode _node)
 {
     node = _node != null ? _node : GetComponent <NetworkNode>();
 }
        private void TraverseNetwork()
        {
            foreach (var node in activeNodeList)
            {
                if (!(node is StartNode))
                {
                    node.Clear();
                }
            }
            foreach (var flow in activeFlowList)
            {
                flow.Clear();
            }

            visitedNode.Clear();
            visitedFlow.Clear();
            // 广度优先遍历
            VisitNode(startNode);
            while (queue.Count > 0)
            {
                NetworkNode node = queue.Dequeue();
                // 不允许从结束节点访问邻居节点
                if (node is EndNode)
                {
                    continue;
                }

                for (int i = 0; i < NetworkNode.NeighborNum; i++)
                {
                    var direction = (NetworkNode.Direction)i;
                    var neighbor  = node.GetNeighbor(direction);

                    if (neighbor == null)
                    {
                        continue;
                    }
                    var flow = node.GetFlow(direction);
                    // 特例:结束(带锁)节点是可以被重复访问的
                    if (visitedNode.ContainsKey(neighbor) &&
                        visitedFlow.ContainsKey(flow) && visitedFlow[flow] &&
                        !(neighbor is EndNode))
                    {
                        continue;
                    }

                    // 激活或反激活邻居节点的输入
                    if (node.IsReachableTo(direction))
                    {
                        flow.Activate(node, neighbor);
                        neighbor.SetInput(NetworkNode.GetOppositeDirection(direction), true);
                    }
                    else
                    {
                        flow.Deactivate(node, neighbor);
                        neighbor.SetInput(NetworkNode.GetOppositeDirection(direction), false);
                    }
                    VisitNode(neighbor);
                    VisitFlow(flow);
                }
            }
        }
        private void TraverseNetworkFlow()
        {
            // 清理工作:将所有节点和流都关闭
            foreach (var node in activeNodeList)
            {
                if (!(node is StartNode))
                {
                    node.Clear();
                }
            }
            foreach (var flow in activeFlowList)
            {
                flow.Clear();
            }
            visitedFlowList.Clear();

            // 从起点开始,查找周边的通路
            for (int i = 0; i < NetworkNode.NeighborNum; i++)
            {
                var flow = startNode.GetFlow(i);
                if (flow != null && startNode.IsReachableTo(flow.Direction))
                {
                    flowQueue.Enqueue(flow);
                    Log(string.Format("Enqueue: {0}", flow));
                }
            }

            // 开始遍历网络图
            while (flowQueue.Count > 0)
            {
                NetworkFlow flow     = flowQueue.Dequeue();
                NetworkNode node     = flow.FirstNode;
                NetworkNode neighbor = flow.SecondNode;

                visitedFlowList.Add(flow);
                Log(string.Format("Visit {0}", flow));

                // 激活流和输入状态
                NetworkNode.Direction direction = node.GetNeighborDirection(neighbor);
                flow.Activate(node, neighbor);
                neighbor.SetInput(NetworkNode.GetOppositeDirection(direction), true);

                bool nextFlowFound = false;
                for (int i = 0; i < NetworkNode.NeighborNum; i++)
                {
                    var nextFlow = neighbor.GetFlow(i);
                    if (nextFlow == null ||
                        visitedFlowList.Contains(nextFlow) ||
                        flowQueue.Contains(nextFlow) ||
                        // 第一趟查找,不包含那些已经走过一遍的通路
                        IsVisitedFlowExist(nextFlow.SecondNode, nextFlow.FirstNode))
                    {
                        continue;
                    }
                    if (neighbor.IsReachableTo(nextFlow.Direction))
                    {
                        Log(string.Format("Enqueue: {0}", nextFlow));
                        flowQueue.Enqueue(nextFlow);
                        nextFlowFound = true;
                    }
                }
                // 第二趟查找,可能包含反向的通路
                if (!nextFlowFound)
                {
                    for (int i = 0; i < NetworkNode.NeighborNum; i++)
                    {
                        var nextFlow = neighbor.GetFlow(i);
                        if (nextFlow == null ||
                            visitedFlowList.Contains(nextFlow) ||
                            flowQueue.Contains(nextFlow))
                        {
                            continue;
                        }
                        if (neighbor.IsReachableTo(nextFlow.Direction))
                        {
                            Log(string.Format("Enqueue2: {0}", nextFlow));
                            flowQueue.Enqueue(nextFlow);
                        }
                    }
                }
            }
        }
 private bool IsVisitedFlowExist(NetworkNode first, NetworkNode second)
 {
     return(visitedFlowList.Find(
                x => x.FirstNode == first && x.SecondNode == second) != null);
 }
 private void OnNodeClick(NetworkNode node)
 {
     debugGUIText = "Click " + node.name;
     node.Execute();
 }
 private void OnNodeFocus(NetworkNode node)
 {
     debugGUIText = node != null ?
                    "Hover " + node.name : string.Empty;
 }
        private void OnNodeDataChanged(NetworkNode node)
        {
            isPuzzleComplete = false;
//            TraverseNetwork();
            TraverseNetworkFlow();
        }