Beispiel #1
0
 private bool NextIsInverted(TrackSection trackSection)
 {
     if (trackSection.Next != null && Vector3.Distance(trackSection.EndPosition, trackSection.Next.Position) > 0.05f)
     {
         return(true);
     }
     return(false);
 }
Beispiel #2
0
 private bool PreviousIsInverted(TrackSection trackSection)
 {
     if (trackSection.Previous != null && Vector3.Distance(trackSection.Previous.EndPosition, trackSection.Position) > 0.05f)
     {
         return(true);
     }
     return(false);
 }
Beispiel #3
0
        private Vector3 CalculateNewTrackPosition(TrackSection newPiece, bool invertNewPiece)
        {
            // Get the current track's attach position
            var anchor = this.Inverted ? CurrentSection.Position : CurrentSection.EndPosition;
            var offset = invertNewPiece ? newPiece.EndPosition : Vector3.zero;

            return(anchor + offset);
        }
Beispiel #4
0
        private Quaternion CalculateNewTrackRotation(TrackSection newPiece, bool invertNewPiece)
        {
            Quaternion anchorRotation = Inverted ? Helper.InvertTrackRotation(CurrentSection.Rotation) : CurrentSection.GetRotationOnTrack(CurrentSection.Length);
            //Debug.LogFormat("Anchor rotation: {0}, Inverted: {1}", anchorRotation.eulerAngles, Inverted);
            Quaternion newRotation = invertNewPiece ? Helper.InvertTrackRotation(newPiece.GetRotationOnTrack(newPiece.Length)) : Quaternion.identity;

            //Debug.LogFormat("New piece rotation: {0}, Inverted: {1}", newRotation.eulerAngles, invertNewPiece);
            //Debug.LogFormat("Total rotation: {0}", (anchorRotation * newRotation).eulerAngles);
            return(anchorRotation * newRotation);
        }
Beispiel #5
0
        /// <summary>
        /// Creates a new junction from the given sections. Note that they may not be inverted.
        /// </summary>
        /// <param name="entry">The entry track of the junction</param>
        /// <param name="left">The left branch</param>
        /// <param name="right">The right branch</param>
        public Junction(TrackSection entry, TrackSection left, TrackSection right)
        {
            Entry = entry;
            Left  = left;
            Right = right;

            // Hook up pieces
            Left.Previous  = Entry;
            Right.Previous = Entry;
            Toggle();
        }
Beispiel #6
0
        /// <summary>
        /// Creates a copy of this TrackSection
        /// </summary>
        /// <param name="connections">When true connections are copied as well</param>
        /// <returns>Copy</returns>
        public TrackSection Clone(bool connections = false)
        {
            var ts = new TrackSection();

            if (connections)
            {
                ts.Next     = Next;
                ts.Previous = Previous;
            }
            ts.Position = Position;
            ts.Rotation = Rotation;
            ts.Length   = Length;
            ts.Curved   = Curved;
            ts.Curve    = Curve;
            return(ts);
        }
Beispiel #7
0
        /// <summary>
        /// Starts a new straight track at the given position and rotation
        /// </summary>
        /// <param name="position">Track start position</param>
        /// <param name="rotation">Track start rotation</param>
        /// <param name="length">Length of track</param>
        /// <param name="inverted">If the track piece should be inverted</param>
        /// <returns></returns>
        public TrackSection StartTrack(Vector3 position, Quaternion rotation, float length, bool inverted = false)
        {
            if (CurrentSection != null)
            {
                PushState();
            }

            CurrentSection = new TrackSection()
            {
                Length   = length,
                Position = position,
                Rotation = rotation,
            };

            if (inverted)
            {
                CurrentSection.Flip();
            }

            Inverted = inverted;
            return(CurrentSection);
        }
Beispiel #8
0
        /// <summary>
        /// Places a new section of straight track after the current section
        /// </summary>
        /// <param name="length">The length of the new section</param>
        /// <param name="curve">The curve in degrees</param>
        /// <param name="inverted">If the new section is inverted</param>
        public TrackSection PlaceTrack(float length, float curve, bool inverted = false)
        {
            if (CurrentSection == null)
            {
                throw new InvalidOperationException("Use StartTrack to start a new track");
            }

            var track = new TrackSection()
            {
                Length   = length,
                Previous = inverted ? null : CurrentSection,
                Next     = inverted ? CurrentSection : null,
                Curved   = true,
                Curve    = curve
            };

            // Rotation MUST be calculated first so position offset computation functions correctly
            track.Rotation = CalculateNewTrackRotation(track, inverted);
            track.Position = CalculateNewTrackPosition(track, inverted);

            // Check to see if we are supposed to hook this up to the front or back of the current section
            if (Inverted)
            {
                CurrentSection.Previous = track;
            }
            else
            {
                CurrentSection.Next = track;
            }

            // Store state
            PushState();

            // Update state for next calls
            Inverted       = inverted;
            CurrentSection = track;

            return(CurrentSection);
        }
Beispiel #9
0
 public TrackFollower(TrackSection section, float startDistance, bool startInverted)
 {
     TrackSection = section;
     Distance     = startDistance;
     Inverted     = startInverted;
 }
Beispiel #10
0
 /// <summary>
 /// Repositions the track layer on the given track
 /// </summary>
 /// <param name="section"></param>
 /// <param name="inverted"></param>
 public void Reposition(TrackSection section, bool inverted = false)
 {
     ClearHistory();
     CurrentSection = section;
     Inverted       = inverted;
 }