Пример #1
0
    Vector3 GetGridWall(Vector2 gridPosition, Vector2 direction, float height = 0)
    {
        Vector3 toReturn = GridF.TransformGridToPoint(gridPosition) + GridF.Direction2ToDirection3(direction * 0.5f * LabyrinthGenerator.instance.scale);

        toReturn.y = height;
        return(toReturn);
    }
Пример #2
0
    void Draw()
    {
        //Update head
        {
            Vector3 headPosition = head.position;
            headPosition.y = CalculateHeight(head.position);
            head.position  = headPosition;
        }

        mesh.Clear();
        if (controlPoints.Count > 0)
        {
            float addedDistance = 0;

            if (moved)
            {
                addedDistance = ((head.transform.position - prevWall).magnitude / betweenWallsDistance);
                if (turning && enemy.state != EnemySmooth.State.Turning)
                {
                    turning = false; ChangeTile();
                }
            }

            List <int[]> rings = new List <int[]>();

            if (controlPoints.Count == maxControlPoints)
            {
                {
                    Point2  point = controlPoints[0];
                    Vector3 realPointLocalPosition = (GridF.TransformGridToPoint(point.position) + GridF.Direction2ToDirection3(point.direction) * addedDistance * LabyrinthGenerator.instance.scale);
                    realPointLocalPosition += CalculateHeight(realPointLocalPosition) * Vector3.up - transform.position;

                    float width = widthCurve.Evaluate(0);
                    rings.Add(mesh.AddArray(CreateRing(width, realPointLocalPosition, point.angle), 0));

                    if (addedDistance < 0.5f)
                    {
                        Point2 point2         = controlPoints[1];
                        float  distanceToHead = 0.5f - addedDistance;
                        realPointLocalPosition = (GridF.TransformGridToPoint(point.position) + CalculateHeight(GridF.TransformGridToPoint(point.position)) * Vector3.up) - transform.position;
                        Vector3 realPointLocalPosition2 = (GridF.TransformGridToPoint(point2.position) + Vector3.up * CalculateHeight(GridF.TransformGridToPoint(point2.position))) - transform.position;

                        width = widthCurve.Evaluate(distanceToHead / (controlPoints.Count - 0.5f));
                        rings.Add(mesh.AddArray(CreateRing(width, (realPointLocalPosition + realPointLocalPosition2) / 2, (point.angle + point2.angle) / 2), distanceToHead));
                    }
                }

                for (int i = 1; i < controlPoints.Count; i++)
                {
                    Point2  point                  = controlPoints[i];
                    float   distanceToHead         = i - addedDistance;
                    Vector3 realPointLocalPosition = (GridF.TransformGridToPoint(point.position) + CalculateHeight(GridF.TransformGridToPoint(point.position)) * Vector3.up) - transform.position;

                    float width = widthCurve.Evaluate(distanceToHead / (controlPoints.Count - 0.5f));
                    rings.Add(mesh.AddArray(CreateRing(width, realPointLocalPosition, point.angle), distanceToHead));
                    //rings.Add(mesh.AddArray(CreateRing(1, realPointLocalPosition + (new Vector3(point.direction.x, 0, point.direction.y) * addedDistance), point.angle)));

                    if (i == controlPoints.Count - 1)
                    {
                        distanceToHead = i + 0.5f - addedDistance;

                        /*Quaternion headAngle = head.rotation * Quaternion.Euler(0,point.angle,0);
                         * while (Mathf.Abs(headAngle - point.angle) > 360)
                         * {
                         *  if (headAngle < point.angle) headAngle += 360;
                         *  else headAngle -= 360;
                         * }
                         * Debug.Log(headAngle.eulerAngles.y);*/
                        width = widthCurve.Evaluate(distanceToHead / (controlPoints.Count - 0.5f));
                        realPointLocalPosition = (realPointLocalPosition + transform.InverseTransformPoint(head.position)) / 2;
                        rings.Add(mesh.AddArray(CreateRing(width, realPointLocalPosition, point.angle), distanceToHead));

                        distanceToHead -= 0.25f;
                        width           = widthCurve.Evaluate(distanceToHead / (controlPoints.Count - 0.5f));
                        rings.Add(mesh.AddArray(CreateRing(width, ((realPointLocalPosition + transform.InverseTransformPoint(head.position)) / 2), head.rotation), distanceToHead));
                    }

                    else
                    {
                        distanceToHead = i + 0.5f - addedDistance;
                        Point2  point2 = controlPoints[i + 1];
                        Vector3 realPointLocalPosition2 = (GridF.TransformGridToPoint(point2.position) + CalculateHeight(GridF.TransformGridToPoint(point2.position)) * Vector3.up) - transform.position;
                        width = widthCurve.Evaluate(distanceToHead / (controlPoints.Count - 0.5f));
                        rings.Add(mesh.AddArray(CreateRing(width, (realPointLocalPosition + realPointLocalPosition2) / 2, point.angle), distanceToHead));
                    }
                }
            }
            //rings.Add(mesh.AddArray(CreateRing(widthCurve.Evaluate(1), transform.InverseTransformPoint(head.position), head.rotation), maxControlPoints - 0.5f));

            for (int i = 1; i < rings.Count; i++)
            {
                mesh.ConectRings(rings[i], rings[i - 1]);
            }

            mesh.Cap(rings[0]);
            mesh.Cap(rings[rings.Count - 1], true);

            mesh.UpdateMesh();
        }
    }