Exemplo n.º 1
0
    public override void MoveTo(NodeSideInfo info)
    {
        if (_moving || (info._node == null) ||
            ((info._side == _startNodeInfo._side) && (info._node != _startNodeInfo._node)) ||
            ((info._side == _startNodeInfo._side) && (info._node == _startNodeInfo._node)))
        {
            return;
        }

        if (info._node == _startNodeInfo._node)
        {
            Vector3 startPosition = _startNodeInfo.GetWorldPosition();
            Vector3 diff          = BoardManager.SideToVector3Offset(info._side);

            _cornerPosition = startPosition + diff;
        }
        else
        {
            _cornerPosition = NodeSideInfo.GetClosestEdge(_startNodeInfo, info);
        }

        _targetNodeInfo = info;
        _targetPosition = _targetNodeInfo._node.GetWorldPositionBySide(_targetNodeInfo._side);

        if (_targetPosition != _startPosition)
        {
            _moving = true;
            _movementManager.OnMovementStart();
        }
    }
Exemplo n.º 2
0
    private void BuildLine()
    {
        List <Vector3> positionList = new List <Vector3>(_selectedInfoList.Count * 2);

        if (_selectedInfoList.Count > 0)
        {
            Vector3 closestEdge = Vector3.zero;

            Vector3 currentSideOffset = Vector3.zero;
            Vector3 nextSideOffset    = Vector3.zero;

            NodeSideInfo current = null;
            NodeSideInfo next    = null;

            if (_selectedInfoList.Count == 1)
            {
                current = _selectedInfoList[0];

                currentSideOffset = BoardManager.SideToOffset(current._side).ToVector3() * 0.1f;
                Vector3 currentMouseNodePos = GameStateManager.Instance.MouseNodeSidePosition;

                Vector3 diff = (currentMouseNodePos - currentSideOffset).normalized;
                positionList.Add(current.GetWorldPosition() + currentSideOffset);
                positionList.Add(current.GetWorldPosition() + (BoardManager.SideToVector3Offset(Side.Right) * 0.5f) + currentSideOffset);
            }
            else
            {
                for (int i = 0; i < _selectedInfoList.Count - 1; ++i)
                {
                    current = _selectedInfoList[i];
                    next    = _selectedInfoList[i + 1];

                    currentSideOffset = BoardManager.SideToOffset(current._side).ToVector3() * 0.1f;
                    nextSideOffset    = BoardManager.SideToOffset(next._side).ToVector3() * 0.1f;

                    closestEdge = NodeSideInfo.GetClosestEdge(current, next);
                    positionList.Add(current.GetWorldPosition() + currentSideOffset);
                    positionList.Add(closestEdge + nextSideOffset);
                }
                current           = _selectedInfoList[_selectedInfoList.Count - 1];
                currentSideOffset = BoardManager.SideToOffset(current._side).ToVector3() * 0.1f;
                positionList.Add(current.GetWorldPosition() + currentSideOffset);
            }

            _lineRenderer.positionCount = positionList.Count;
            _lineRenderer.SetPositions(positionList.ToArray());
        }
    }
Exemplo n.º 3
0
        public static Mesh BuildQuadsFromNodeInfoList(List <NodeSideInfo> list, Vector2[,] inputUV, float lineWidth)
        {
            Mesh mesh = new Mesh();

            mesh.name = "ListMesh";

            List <Vector3> vertices  = new List <Vector3>();
            List <Vector2> uvs       = new List <Vector2>();
            List <Vector3> normals   = new List <Vector3>();
            List <int>     triangles = new List <int>();

            Vector3[] localVertices = new Vector3[4];
            Vector3[] localNormals  = new Vector3[4];
            Vector2[] localUVs      = new Vector2[4];

            int[] localTriangles = new int[6];

            List <Vector3> vertexList = new List <Vector3>();
            List <Side>    sideList   = new List <Side>();

            for (int i = 0; i < list.Count - 1; ++i)
            {
                NodeSideInfo current = list[i];
                NodeSideInfo next    = list[i + 1];

                Vector3 closestEdge = NodeSideInfo.GetClosestEdge(current, next);

                vertexList.Add(current.GetWorldPosition());
                vertexList.Add(closestEdge);
                vertexList.Add(next.GetWorldPosition());

                sideList.Add(current._side);
                sideList.Add(next._side);
            }


            int quadIndexCount = 0;

            int sideIndex = 0;

            for (int i = 0; i < vertexList.Count; i += 3)
            {
                Vector3 min    = vertexList[i + 0];
                Vector3 middle = vertexList[i + 1];
                Vector3 max    = vertexList[i + 2];

                Side minSide = sideList[sideIndex];
                Side maxSide = sideList[sideIndex + 1];

                //if (minSide == maxSide)
                {
                    BuildLineQuadData(min, middle,
                                      minSide,
                                      lineWidth, quadIndexCount++,
                                      ref localVertices, ref localNormals, ref localTriangles);
                    vertices.AddRange(localVertices);
                    normals.AddRange(localNormals);
                    triangles.AddRange(localTriangles);

                    BuildLineQuadData(middle, max,
                                      maxSide,
                                      lineWidth, quadIndexCount++,
                                      ref localVertices, ref localNormals, ref localTriangles);
                    vertices.AddRange(localVertices);
                    normals.AddRange(localNormals);
                    triangles.AddRange(localTriangles);
                }
                //else
                //{
                //    BuildCornerLineQuadData(
                //        min, middle,
                //        minSide, maxSide,
                //        lineWidth, quadIndexCount++,
                //        ref localVertices, ref localNormals, ref localTriangles);

                //    vertices.AddRange(localVertices);
                //    normals.AddRange(localNormals);
                //    triangles.AddRange(localTriangles);

                //    BuildCornerLineQuadData(
                //        middle, max,
                //        minSide, maxSide,
                //        lineWidth, quadIndexCount++,
                //        ref localVertices, ref localNormals, ref localTriangles);

                //    vertices.AddRange(localVertices);
                //    normals.AddRange(localNormals);
                //    triangles.AddRange(localTriangles);
                //}

                sideIndex += 2;
            }

            mesh.vertices  = vertices.ToArray();
            mesh.normals   = normals.ToArray();
            mesh.triangles = triangles.ToArray();
            mesh.uv        = uvs.ToArray();

            mesh.RecalculateNormals();
            mesh.RecalculateBounds();

            return(mesh);
        }