コード例 #1
0
 public RCT2TrackData(RCT2TrackData trackData)
 {
     TrackData = new List <RCT2TrackPiece>();
     TrackData.AddRange(trackData.TrackData);
     MaxPositiveG     = trackData.MaxPositiveG;
     MaxNegativeG     = trackData.MaxNegativeG;
     MaxLateralG      = trackData.MaxLateralG;
     AirTimeInSeconds = trackData.AirTimeInSeconds;
     NumOfInversions  = trackData.NumOfInversions;
     NumOfDrops       = trackData.NumOfDrops;
     HighestDrop      = trackData.HighestDrop;
     AverageSpeed     = trackData.AverageSpeed;
     MaxSpeed         = trackData.MaxSpeed;
     Excitement       = trackData.Excitement;
     Intensity        = trackData.Intensity;
     Nausea           = trackData.Nausea;
 }
コード例 #2
0
        public RCT2RideData(RCT2RideData copy)
        {
            if (copy.TrackType != null)
            {
                TrackType = new RCT2RideCode(copy.TrackType);
            }
            else
            {
                TrackType = new RCT2RideCode();
            }

            if (copy.TrackData != null)
            {
                TrackData = new RCT2TrackData(copy.TrackData);
            }
            else
            {
                TrackData = new RCT2TrackData();
            }

            if (copy.RideFeatures != null)
            {
                RideFeatures = new RCT2RideFeatures(copy.RideFeatures);
            }
            else
            {
                RideFeatures = new RCT2RideFeatures();
            }
            OperatingMode = copy.OperatingMode;
            if (copy.ColourScheme != null)
            {
                ColourScheme = new RCT2VehicleColourScheme(copy.ColourScheme);
            }
            else
            {
                ColourScheme = new RCT2VehicleColourScheme();
            }
            EntranceStyle    = copy.EntranceStyle;
            AirTimeInSeconds = copy.AirTimeInSeconds;
            if (copy.DepartureFlags != null)
            {
                DepartureFlags = new RCT2DepartureControlFlags(copy.DepartureFlags);
            }
            else
            {
                DepartureFlags = new RCT2DepartureControlFlags();
            }
            NumberOfTrains            = copy.NumberOfTrains;
            NumberOfCarsPerTrain      = copy.NumberOfCarsPerTrain;
            MinWaitTimeInSeconds      = copy.MinWaitTimeInSeconds;
            MaxWaitTimeInSeconds      = copy.MaxWaitTimeInSeconds;
            SpeedOfPoweredLaunch      = copy.SpeedOfPoweredLaunch;
            NumberOfGoKartLaps        = copy.NumberOfGoKartLaps;
            MaxNumberOfPeopleMaze     = copy.MaxNumberOfPeopleMaze;
            MaxSpeedOfRide            = copy.MaxSpeedOfRide;
            AverageSpeedOfRide        = copy.AverageSpeedOfRide;
            RideLengthInMetres        = copy.RideLengthInMetres;
            PosGForce                 = copy.PosGForce;
            NegGForce                 = copy.NegGForce;
            LatGForce                 = copy.LatGForce;
            NumberOfInversions        = copy.NumberOfInversions;
            NumberOfDrops             = copy.NumberOfDrops;
            HighestDrop               = copy.HighestDrop;
            ExcitementTimesTen        = copy.ExcitementTimesTen;
            IntensityTimesTen         = copy.IntensityTimesTen;
            NauseaTimesTen            = copy.NauseaTimesTen;
            TrackMainColour           = copy.TrackMainColour;
            TrackMainColourAlt1       = copy.TrackMainColourAlt1;
            TrackMainColourAlt2       = copy.TrackMainColourAlt2;
            TrackMainColourAlt3       = copy.TrackMainColourAlt3;
            TrackAdditionalColour     = copy.TrackAdditionalColour;
            TrackAdditionalColourAlt1 = copy.TrackAdditionalColourAlt1;
            TrackAdditionalColourAlt2 = copy.TrackAdditionalColourAlt2;
            TrackAdditionalColourAlt3 = copy.TrackAdditionalColourAlt3;
            TrackSupportColour        = copy.TrackSupportColour;
            TrackSupportColourAlt1    = copy.TrackSupportColourAlt1;
            TrackSupportColourAlt2    = copy.TrackSupportColourAlt2;
            TrackSupportColourAlt3    = copy.TrackSupportColourAlt3;
            IsSixFlagsDesign          = copy.IsSixFlagsDesign;
            if (copy.DatFile != null)
            {
                DatFile = new DATFileHeader(copy.DatFile);
            }
            else
            {
                DatFile = new DATFileHeader();
            }
            if (copy.RequiredMapSpace != null)
            {
                RequiredMapSpace = new Vector2(copy.RequiredMapSpace);
            }
            else
            {
                RequiredMapSpace = new Vector2(0, 0);
            }
            LiftChainSpeed   = copy.LiftChainSpeed;
            NumberOfCircuits = copy.NumberOfCircuits;
        }
コード例 #3
0
        public void Populate(RCT2TrackData track)
        {
            //If the track is empty, return
            if (track == null || track.TrackData == null || track.TrackData.Count <= 0)
            {
                return;
            }

            //Give all our bytes an initial value
            StraightFlat    = false;
            StationPlatform = false;
            LiftChain       = false;
            SteepLiftChain  = false;
            CurveLiftChain  = false;
            Banking         = false;
            VerticalLoop    = false;

            NormalSlope       = false;
            SteepSlope        = false;
            FlatToSteep       = false;
            SlopedCurves      = false;
            SteepTwist        = false;
            SBends            = false;
            SmallRadiusCurves = false;
            SmallRadiusBanked = false;

            MediumRadiusCurves = false;
            InlineTwist        = false;
            HalfLoop           = false;
            HalfCorkscrew      = false;
            TowerBaseVertical  = false;
            HelixBanked        = false;
            HelixUnbanked      = false;

            Brakes           = false;
            Booster          = false;
            OnRidePhoto      = false;
            WaterSplash      = false;
            VerticalTrack    = false;
            BarrelRoll       = false;
            LaunchedLiftHill = false;
            LargeHalfLoop    = false;


            //Go through every track piece and populate our bytes
            RCT2TrackElements.RCT2TrackElement prevTrackPiece = track.TrackData[0].TrackElement;
            for (int i = 0; i < track.TrackData.Count; i++)
            {
                RCT2TrackElements.RCT2TrackElement currentTrack = track.TrackData[i].TrackElement;

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.Flat)
                {
                    StraightFlat = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.BeginStation ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.MiddleStation ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.EndStation)
                {
                    StationPlatform = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.CableLiftHill ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.LeftCurvedLiftHill ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.PoweredLift ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.RightCurvedLiftHill)
                {
                    LiftChain = true;
                }

                //Steep Lift Chain not needed for our chosen problem space

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.LeftCurvedLiftHill ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.RightCurvedLiftHill)
                {
                    CurveLiftChain = true;
                }

                if (RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackBank != RCT2TrackElementProperty.RCT2TrackBank.None ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackBank != RCT2TrackElementProperty.RCT2TrackBank.None)
                {
                    Banking = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.LeftVerticalLoop ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.RightVerticalLoop)
                {
                    VerticalLoop = true;
                }

                if (RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up25 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up25 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down25 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down25)
                {
                    NormalSlope = true;
                }

                if (RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up60 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up60 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down60 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down60)
                {
                    SteepSlope = true;
                }

                if (RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackBank == RCT2TrackElementProperty.RCT2TrackBank.Flipped ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackBank == RCT2TrackElementProperty.RCT2TrackBank.Flipped)
                {
                    SteepTwist = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.LeftSBend ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.LeftSBendCovered ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.RightSBend ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.RightSBendCovered)
                {
                    SBends = true;
                }

                if (currentTrack.ToString().ToLower().Contains("across1"))
                {
                    SmallRadiusCurves = true;
                }

                if (currentTrack.ToString().ToLower().Contains("bank"))
                {
                    SmallRadiusBanked = true;
                }

                if (currentTrack.ToString().ToLower().Contains("across3"))
                {
                    MediumRadiusCurves = true;
                }

                if (currentTrack.ToString().ToLower().Contains("twist"))
                {
                    InlineTwist = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.HalfLoopUp ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.HalfLoopDown ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.FlyerHalfLoopUp ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.FlyerHalfLoopDown)
                {
                    HalfLoop = true;
                }

                if (currentTrack.ToString().ToLower().Contains("corkscrew"))
                {
                    HalfCorkscrew = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.TowerBase ||
                    currentTrack == RCT2TrackElements.RCT2TrackElement.TowerSection)
                {
                    TowerBaseVertical = true;
                }

                if (currentTrack.ToString().ToLower().Contains("bankedhelix"))
                {
                    HelixBanked = true;
                }
                else if (currentTrack.ToString().ToLower().Contains("helix"))
                {
                    HelixUnbanked = true;
                }

                if (currentTrack.ToString().ToLower().Contains("brake"))
                {
                    Brakes = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.OnRidePhoto)
                {
                    OnRidePhoto = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.Watersplash)
                {
                    WaterSplash = true;
                }

                if (RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down90 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Down90 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].InputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up90 ||
                    RCT2TrackElements.TrackElementPropertyMap[currentTrack].OutputTrackDegree == RCT2TrackElementProperty.RCT2TrackDegree.Up90)
                {
                    VerticalTrack = true;
                }

                if (currentTrack.ToString().ToLower().Contains("barrelroll"))
                {
                    BarrelRoll = true;
                }

                if (currentTrack == RCT2TrackElements.RCT2TrackElement.PoweredLift)
                {
                    LaunchedLiftHill = true;
                }

                if (currentTrack.ToString().ToLower().Contains("largehalfloop"))
                {
                    LargeHalfLoop = true;
                }

                prevTrackPiece = currentTrack;
            }
        }