Exemplo n.º 1
0
        /// <summary>
        /// Raycast against all hazards
        /// </summary>
        /// <param name="ray"></param>
        /// <param name="distance"></param>
        /// <returns></returns>
        public static HazardHit RaycastHazards(Ray ray, float distance = 10)
        {
            ray.direction = new Vector3(ray.direction.x, 0, ray.direction.z).normalized;

            HazardHit hit       = new HazardHit();
            bool      hitted    = false;
            bool      insideOOB = false;

            List <HazardBase> hazards = Hazards;

            for (int i = 0; i < hazards.Count; ++i)
            {
                HazardHit temp = new HazardHit();
                if (hazards[i].Raycast(ray, temp, distance))
                {
                    switch (temp.type)
                    {
                    case HazardBase.Type.Out_of_Bounds:
                        insideOOB = true;
                        break;

                    default:
                        hitted = true;
                        hit    = temp;
                        break;
                    }
                }
            }

            if (hitted)
            {
                return(hit);
            }
            else
            {
                if (insideOOB)
                {
                    return(hit);
                }
                else
                {
                    Layer layer = CourseBase.GetLayer(Utility.GetName(HazardBase.Type.Out_of_Bounds), CourseBase.HazardLayers);
                    if (Hazards.Find(x => x.Layer == layer))
                    {
                        hit.type       = HazardBase.Type.Out_of_Bounds;
                        hit.InstanceID = Hazards.Find(x => x.Layer == layer).Info.InstanceID;
                        return(hit);
                    }
                    else
                    {
                        hit.type = HazardBase.Type.Out_of_Bounds;
                        return(hit);
                    }
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// Creates spline
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        public static SplineBase CreateSpline(SplineBase.SplineInfo info)
        {
            SplineBase spline = CreateSpline(info.points.ToVector3(), CourseBase.GetLayer(info.layerName, SplineLayers), (SplineBase.SplineInfo.Flags)info.flags, info.InstanceID);

            spline.Info.pin = info.pin;

            spline.UpdateLine();
            splines.Add(spline);
            spline.LineChanged();

            return(spline);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Raycast the hazard for intesections
        /// </summary>
        /// <param name="ray"></param>
        /// <param name="hit"></param>
        /// <param name="distance"></param>
        /// <returns></returns>
        public bool Raycast(Ray ray, CourseBase.HazardHit hit, float distance = 10)
        {
            Vector3[] points = Lines.Points;
            Color[]   colors = Lines.Colors;

            if (!InBounds(ray.origin))
            {
                return(false);
            }
            if (!ray.origin.IsInside(points))
            {
                return(false);
            }

            distance = Mathf.Max(distance, Lines.Points.LineLength());
            Vector3 startPosition = ray.origin + ray.direction.normalized * distance;

            bool crossed = false;

            for (int i = 0; i < points.Length; ++i)
            {
                if (MathUtility.IsSegmentSegment(ray.origin.ToVector2(), startPosition.ToVector2(), points.GetAt(i - 1).ToVector2(), points.GetAt(i).ToVector2()))
                {
                    string name = CourseBase.HazardLayers.Find(h => h.hazardColor == colors.GetAt(i - 1)).name;
                    if (CourseBase.IsHazard(name))
                    {
                        Vector3 point = MathUtility.LineLine(ray.origin.ToVector2(), startPosition.ToVector2(), points.GetAt(i - 1).ToVector2(), points.GetAt(i).ToVector2()).Value;
                        point = new Vector3(point.x, CourseBase.MeshHeight(point.x, point.y), point.y);

                        if (hit.point == Vector3.zero || (point - ray.origin).magnitude < (hit.point - ray.origin).magnitude)
                        {
                            hit.type       = CourseBase.HazardType(name);
                            hit.point      = point;
                            hit.pointIndex = i;
                            hit.InstanceID = Info.InstanceID;
                            crossed        = true;
                        }
                    }
                }
            }

            return(crossed);
        }
Exemplo n.º 4
0
        Vector3 GetNormal(Vector3 middle, Vector3 left, Vector3 right, Vector2 position, bool blendNormals = false)
        {
            Vector3 n  = Vector3.zero;
            Vector3 nl = Vector3.zero;
            Vector3 nr = Vector3.zero;
            Vector3 nm = CourseBase.TerrainNormal(middle);

            if (right != Vector3.zero)
            {
                nr = (middle - right).normalized;
                nr = Quaternion.AngleAxis(90, Vector3.Cross(new Vector3(nr.x, 0, nr.z).normalized, Vector3.up)) * nr;
            }
            if (left != Vector3.zero)
            {
                nl = (left - middle).normalized;
                nl = Quaternion.AngleAxis(90, Vector3.Cross(new Vector3(nl.x, 0, nl.z).normalized, Vector3.up)) * nl;
            }
            if (right != Vector3.zero && left != Vector3.zero)
            {
                /*
                 * if (blendNormals) n = new Vector3(nr.x + nl.x, nr.y * nl.y, nr.z + nl.z);
                 * else n = Vector3.Lerp(nl, nr, 0.5f);
                 *
                 * n = new Vector3(n.x + nm.x, n.y * nm.y, n.z + nm.z);
                 * n.Normalize();
                 */

                n = Vector3.Lerp(nl, nr, 0.5f);
                n = Vector3.Lerp(nm, n, 0.75f);
            }
            else
            {
                n = CourseBase.TerrainNormal(middle);
            }

            return(n);
        }
Exemplo n.º 5
0
        public override void UpdateMaterial()
        {
            base.UpdateMaterial();

            for (int i = 0; i < posts.Count; ++i)
            {
                MonoBehaviour.DestroyImmediate(posts[i]);
                posts.RemoveAt(i);
                i = -1;
                continue;
            }

            Vector3[] path   = Lines.Lines;
            Color[]   colors = Lines.LinesColors;
            for (int i = 1; i < path.Length; ++i)
            {
                if (colors[i - 1] != colors[i])
                {
                    Layer layer1 = CourseBase.HazardLayers.Find(h => h.hazardColor == colors[i - 1]);
                    if (layer1 == null)
                    {
                        continue;
                    }
                    GameObject prefab1 = layer1.HazardPost;
                    if (prefab1 == null)
                    {
                        continue;
                    }

                    GameObject post1 = MonoBehaviour.Instantiate(prefab1) as GameObject;
                    post1.transform.parent         = transform;
                    post1.transform.localPosition  = path[i - 1];
                    post1.transform.forward        = path[i].Direction(path[i - 1]);
                    post1.transform.localRotation *= Quaternion.Euler(-90, 0, 0);
                    posts.Add(post1);

                    Layer layer2 = CourseBase.HazardLayers.Find(h => h.hazardColor == colors[i]);
                    if (layer2 == null)
                    {
                        continue;
                    }
                    GameObject prefab2 = layer2.HazardPost;
                    if (prefab2 == null)
                    {
                        continue;
                    }

                    GameObject post2 = MonoBehaviour.Instantiate(prefab2) as GameObject;
                    post2.transform.parent         = transform;
                    post2.transform.localPosition  = path[i];
                    post2.transform.forward        = path[i].Direction(path[i - 1]);
                    post2.transform.localRotation *= Quaternion.Euler(-90, 0, 0);
                    posts.Add(post2);
                }
            }

            float length = Lines.Lines.LineLength();

            for (float x = 0; x < length - Layer.metersPerOnePost; x += Layer.metersPerOnePost)
            {
                Vector3 position = Position(x);
                position.y = CourseBase.MeshHeight(position.x, position.z);

                if (posts.Find(h => (h.transform.position - position).magnitude < Layer.metersPerOnePost * 0.75f))
                {
                    continue;
                }

                Vector3 nextPosition = Position(x + 0.1f);
                nextPosition.y = CourseBase.MeshHeight(nextPosition.x, nextPosition.z);

                Color color = Color(x);
                Layer layer = CourseBase.HazardLayers.Find(h => h.hazardColor == color);
                if (layer == null)
                {
                    continue;
                }
                GameObject prefab = CourseBase.HazardLayers.Find(h => h.hazardColor == color).HazardPost;
                if (prefab == null)
                {
                    continue;
                }
                GameObject post = MonoBehaviour.Instantiate(prefab) as GameObject;
                post.transform.parent         = transform;
                post.transform.localPosition  = position;
                post.transform.forward        = nextPosition.Direction2D(position);
                post.transform.localRotation *= Quaternion.Euler(-90, 0, 0);
                posts.Add(post);
            }
        }
Exemplo n.º 6
0
                /// <summary>
                /// Retrieve target position based on the hole information
                /// </summary>
                /// <param name="holeIndex"></param>
                /// <param name="nodes"></param>
                /// <param name="pinPosition"></param>
                /// <param name="shotPosition"></param>
                /// <param name="teePosition"></param>
                /// <returns></returns>
                public Vector3 TargetPosition(int holeIndex, List <Node> nodes, Vector3 pinPosition, Vector3 shotPosition, Vector3 teePosition)
                {
                    switch (target)
                    {
                    case Target.Probe:
                        return(probe.position.ToVector3());

                    case Target.Tee:
                        if (CourseBase.IsHoleEnabled(holeIndex))
                        {
                            if (teePosition != Vector3.zero)
                            {
                                return(teePosition);
                            }
                            else
                            {
                                return(CourseBase.Holes[holeIndex].tees[0].Position);
                            }
                        }
                        break;

                    case Target.Pin:
                        if (CourseBase.IsHoleEnabled(holeIndex))
                        {
                            if (pinPosition != Vector3.zero)
                            {
                                return(pinPosition);
                            }
                            else
                            {
                                return(CourseBase.Holes[holeIndex].pins[0].Position);
                            }
                        }
                        break;

                    case Target.Shot:
                        if (CourseBase.IsHoleEnabled(holeIndex))
                        {
                            if (shotPosition != Vector3.zero)
                            {
                                return(shotPosition);
                            }
                            else if (CourseBase.Holes[holeIndex].shots.Count > 0)
                            {
                                return(CourseBase.Holes[holeIndex].shots[0].Position);
                            }
                        }
                        break;

                    case Target.GameObject:
                        if (cameraTarget == null)
                        {
                            return(position.ToVector3());
                        }
                        else
                        {
                            return(cameraTarget.position);
                        }

                    case Target.Next:
                        if (this == nodes[nodes.Count - 1])
                        {
                            return(position.ToVector3());
                        }
                        return(GetNext(nodes).position.ToVector3());

                    case Target.Previous:
                        if (this == nodes[0])
                        {
                            return(position.ToVector3());
                        }
                        return(GetPrevious(nodes).position.ToVector3());

                    case Target.NextProbe:
                        if (this == nodes[nodes.Count - 1])
                        {
                            return(position.ToVector3());
                        }
                        return(GetNext(nodes).TargetPosition(holeIndex, nodes, pinPosition, shotPosition, teePosition));

                    case Target.PreviousProbe:
                        if (this == nodes[0])
                        {
                            return(position.ToVector3());
                        }
                        return(GetPrevious(nodes).TargetPosition(holeIndex, nodes, pinPosition, shotPosition, teePosition));

                    default:
                        return(Vector3.zero);
                    }
                    return(Vector3.zero);
                }
Exemplo n.º 7
0
 void OnDisable()
 {
     self = null;
     ForceUpdate();
 }
Exemplo n.º 8
0
 void OnEnable()
 {
     self = this;
     ForceUpdate();
 }
Exemplo n.º 9
0
        Vector3 GetPosition(Vector2 position, float offset)
        {
            float height = CourseBase.TerrainHeight(position.x, position.y);

            return(new Vector3(position.x, height + offset, position.y));
        }
Exemplo n.º 10
0
        /// <summary>
        /// Update the lines
        /// </summary>
        /// <param name="spline"></param>
        public void UpdateLines(SplineBase spline)
        {
            if (spline.IsSquare)
            {
                List <Vector3> temp = editorPoints.ToList();
                temp.Add(temp[0]);
                editorLinesPoints = temp.ToArray();
            }
            else
            {
                editorLinesPoints = editorPoints.CatmullRom(spline.Layer.pointsPerEdge, true).ToArray();
            }
            if (spline.IsHazard)
            {
                editorLinesColors = new Color[editorLinesPoints.Length];

                string[] colorNames = spline.Info.colorNames;
                editorColors = new Color[colorNames.Length];
                for (int i = 0; i < colorNames.Length; ++i)
                {
                    editorColors[i] = CourseBase.GetLayer(colorNames[i], CourseBase.HazardLayers).hazardColor;
                }

                int step = (int)(editorLinesPoints.Length / editorPoints.Length);

                int index   = 0;
                int counter = 0;
                for (int i = 0; i < editorLinesPoints.Length; ++i)
                {
                    try
                    {
                        editorLinesColors[i] = editorColors[index];
                        counter++;
                        if (counter == step)
                        {
                            counter = 0;
                            if (index != editorPoints.Length - 1)
                            {
                                index++;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.Log(editorColors.Length + "[" + index + "]");
                        Debug.LogException(e);
                    }
                }
            }

            editorBoxesPoints = new Vector3[editorPoints.Length * 9];
            for (int i = 0; i < editorPoints.Length; ++i)
            {
                editorBoxesPoints[i * 9 + 0].Set(editorPoints[i].x - Utility.squareHalf, editorPoints[i].y, editorPoints[i].z - Utility.squareHalf);
                editorBoxesPoints[i * 9 + 1].Set(editorPoints[i].x + Utility.squareHalf, editorPoints[i].y, editorPoints[i].z - Utility.squareHalf);
                editorBoxesPoints[i * 9 + 2].Set(editorPoints[i].x - Utility.squareHalf, editorPoints[i].y, editorPoints[i].z - Utility.squareHalf);
                editorBoxesPoints[i * 9 + 3].Set(editorPoints[i].x - Utility.squareHalf, editorPoints[i].y, editorPoints[i].z + Utility.squareHalf);
                editorBoxesPoints[i * 9 + 4].Set(editorPoints[i].x - Utility.squareHalf, editorPoints[i].y, editorPoints[i].z + Utility.squareHalf);
                editorBoxesPoints[i * 9 + 5].Set(editorPoints[i].x + Utility.squareHalf, editorPoints[i].y, editorPoints[i].z + Utility.squareHalf);
                editorBoxesPoints[i * 9 + 6].Set(editorPoints[i].x + Utility.squareHalf, editorPoints[i].y, editorPoints[i].z - Utility.squareHalf);
                editorBoxesPoints[i * 9 + 7].Set(editorPoints[i].x + Utility.squareHalf, editorPoints[i].y, editorPoints[i].z + Utility.squareHalf);
                editorBoxesPoints[i * 9 + 8].Set(0, float.PositiveInfinity, 0);
            }

            editorMin = editorLinesPoints[0];
            editorMax = editorLinesPoints[0];
            for (int i = 0; i < editorLinesPoints.Length; ++i)
            {
                if (editorLinesPoints[i].x < editorMin.x)
                {
                    editorMin.x = editorLinesPoints[i].x;
                }
                if (editorLinesPoints[i].y < editorMin.y)
                {
                    editorMin.y = editorLinesPoints[i].y;
                }
                if (editorLinesPoints[i].z < editorMin.z)
                {
                    editorMin.z = editorLinesPoints[i].z;
                }

                if (editorLinesPoints[i].x > editorMax.x)
                {
                    editorMax.x = editorLinesPoints[i].x;
                }
                if (editorLinesPoints[i].y > editorMax.y)
                {
                    editorMax.y = editorLinesPoints[i].y;
                }
                if (editorLinesPoints[i].z > editorMax.z)
                {
                    editorMax.z = editorLinesPoints[i].z;
                }
            }
            editorMin /= 1.01f;
            editorMax *= 1.01f;
        }