Example #1
0
        private static void CreateAirlineStartData(Airline airline, AirlineStartData startData)
        {
            AirportFacility checkinFacility =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.CheckIn).Find(f => f.TypeLevel == 1);
            AirportFacility cargoTerminal =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.Cargo).Find(f => f.TypeLevel > 0);

            //  int difficultyFactor = GameObject.GetInstance().Difficulty.AILevel > 1 ? 2 : 1; //level easy

            int startDataFactor = Convert.ToInt16(GameObject.GetInstance().Difficulty.StartDataLevel);
            List<StartDataRoute> startroutes =
                startData.Routes.FindAll(
                    r =>
                    r.Opened <= GameObject.GetInstance().GameTime.Year
                    && r.Closed >= GameObject.GetInstance().GameTime.Year);

            Terminal.TerminalType terminaltype = airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger;
            //creates the routes
            List<StartDataRoute> sRoutes = startroutes.GetRange(0, startroutes.Count/startDataFactor);
            Parallel.ForEach(
                sRoutes,
                startRoute =>
                    {
                        Airport dest1 = Airports.GetAirport(startRoute.Destination1);
                        Airport dest2 = Airports.GetAirport(startRoute.Destination2);

                        if (dest1 != null && dest2 != null)
                        {
                            if (dest1.GetAirportFacility(airline, AirportFacility.FacilityType.Cargo).TypeLevel == 0
                                && dest1.GetAirportFacility(null, AirportFacility.FacilityType.Cargo).TypeLevel == 0
                                && airline.AirlineRouteFocus == Route.RouteType.Cargo)
                            {
                                dest1.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
                            }

                            if (dest2.GetAirportFacility(airline, AirportFacility.FacilityType.Cargo).TypeLevel == 0
                                && dest2.GetAirportFacility(null, AirportFacility.FacilityType.Cargo).TypeLevel == 0
                                && airline.AirlineRouteFocus == Route.RouteType.Cargo)
                            {
                                dest2.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
                            }

                            if (!AirportHelpers.HasFreeGates(dest1, airline, terminaltype))
                            {
                                AirportHelpers.RentGates(dest1, airline, AirportContract.ContractType.LowService, terminaltype);
                            }

                            if (!AirportHelpers.HasFreeGates(dest2, airline, terminaltype))
                            {
                                AirportHelpers.RentGates(dest2, airline, AirportContract.ContractType.LowService, terminaltype);
                            }

                            Guid id = Guid.NewGuid();

                            Route route = null;

                            double price = PassengerHelpers.GetPassengerPrice(dest1, dest2);

                            if (startRoute.RouteType == Route.RouteType.Mixed
                                || startRoute.RouteType == Route.RouteType.Passenger)
                            {
                                route = new PassengerRoute(
                                    id.ToString(),
                                    dest1,
                                    dest2,
                                    GameObject.GetInstance().GameTime,
                                    price);
                            }

                            if (startRoute.RouteType == Route.RouteType.Cargo)
                            {
                                route = new CargoRoute(
                                    id.ToString(),
                                    dest1,
                                    dest2,
                                    GameObject.GetInstance().GameTime,
                                    PassengerHelpers.GetCargoPrice(dest1, dest2));
                            }

                            KeyValuePair<Airliner, bool>? airliner = null;
                            if (startRoute.Type != null)
                            {
                                double distance = MathHelpers.GetDistance(dest1, dest2);

                                if (startRoute.Type.Range > distance)
                                {
                                    airliner =
                                        new KeyValuePair<Airliner, bool>(
                                            Airliners.GetAirlinersForSale(a => a.Type == startRoute.Type).FirstOrDefault(),
                                            true);

                                    if (airliner.Value.Key == null)
                                    {
                                        id = Guid.NewGuid();
                                        var nAirliner = new Airliner(
                                            id.ToString(),
                                            startRoute.Type,
                                            airline.Profile.Country.TailNumbers.GetNextTailNumber(),
                                            GameObject.GetInstance().GameTime);
                                        Airliners.AddAirliner(nAirliner);

                                        nAirliner.ClearAirlinerClasses();

                                        AirlinerHelpers.CreateAirlinerClasses(nAirliner);

                                        airliner = new KeyValuePair<Airliner, bool>(nAirliner, true);
                                    }
                                }
                            }

                            bool leaseAircraft = airline.Profile.PrimaryPurchasing
                                                    == AirlineProfile.PreferedPurchasing.Leasing;

                            if (airliner == null)
                            {
                                airliner = AIHelpers.GetAirlinerForRoute(
                                    airline,
                                    dest2,
                                    dest1,
                                    leaseAircraft,
                                    startRoute.RouteType,
                                    true);

                                if (airliner == null
                                    && airline.Profile.PrimaryPurchasing == AirlineProfile.PreferedPurchasing.Random)
                                {
                                    AIHelpers.GetAirlinerForRoute(
                                        airline,
                                        dest2,
                                        dest1,
                                        true,
                                        startRoute.RouteType,
                                        true);
                                }
                            }

                            if (airliner != null)
                            {
                                FleetAirliner fAirliner = AirlineHelpers.AddAirliner(
                                    airline,
                                    airliner.Value.Key,
                                    airline.Airports[0],
                                    leaseAircraft);
                                fAirliner.AddRoute(route);
                                fAirliner.Status = FleetAirliner.AirlinerStatus.ToRouteStart;
                                AirlineHelpers.HireAirlinerPilots(fAirliner);

                                if (route != null)
                                {
                                    route.LastUpdated = GameObject.GetInstance().GameTime;

                                    if (startRoute.RouteType == Route.RouteType.Mixed
                                        || startRoute.RouteType == Route.RouteType.Passenger)
                                    {
                                        AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);

                                        RouteClassesConfiguration configuration =
                                            AIHelpers.GetRouteConfiguration((PassengerRoute) route);

                                        foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                                        {
                                            ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice =
                                                price*GeneralHelpers.ClassToPriceFactor(classConfiguration.Type);

                                            foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                                            {
                                                ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                                        .AddFacility(rFacility);
                                            }
                                        }

                                        AIHelpers.CreateRouteTimeTable(route, fAirliner);
                                    }
                                    if (startRoute.RouteType == Route.RouteType.Cargo)
                                    {
                                        AIHelpers.CreateCargoRouteTimeTable(route, fAirliner);
                                    }
                                }
                            }
                            airline.AddRoute(route);
                        }
                    });
            //adds the airliners
            Parallel.ForEach(
                startData.Airliners,
                airliners =>
                    {
                        AirlinerType type = AirlinerTypes.GetType(airliners.Type); //B747-200

                        const int totalSpan = 2010 - 1960;
                        int yearSpan = GameObject.GetInstance().GameTime.Year - 1960;
                        double valueSpan = Convert.ToDouble(airliners.AirlinersLate - airliners.AirlinersEarly);
                        double span = valueSpan/Convert.ToDouble(totalSpan);

                        int numbers = Math.Max(1, Convert.ToInt16(span*yearSpan)/startDataFactor);

                        if (type == null)
                        {
                            string tAirline = airline.Profile.Name;
                            string typeNull = airliners.Type;

                            Console.WriteLine(tAirline + @" " + typeNull);
                        }
                        if (type != null && type.Produced.From <= GameObject.GetInstance().GameTime)
                        {
                            for (int i = 0; i < Math.Max(numbers, airliners.AirlinersEarly); i++)
                            {
                                Guid id = Guid.NewGuid();

                                int countryNumber = Rnd.Next(Countries.GetCountries().Count() - 1);
                                Country country = Countries.GetCountries()[countryNumber];

                                int builtYear = Rnd.Next(
                                    type.Produced.From.Year,
                                    Math.Min(GameObject.GetInstance().GameTime.Year - 1, type.Produced.To.Year));

                                var airliner = new Airliner(
                                    id.ToString(),
                                    type,
                                    country.TailNumbers.GetNextTailNumber(),
                                    new DateTime(builtYear, 1, 1));

                                int age = MathHelpers.CalculateAge(airliner.BuiltDate, GameObject.GetInstance().GameTime);

                                long kmPerYear = Rnd.Next(100000, 1000000);
                                long km = kmPerYear*age;

                                airliner.Flown = km;

                                airliner.EngineType = EngineTypes.GetStandardEngineType(airliner.Type, airliner.BuiltDate.Year);

                                Airliners.AddAirliner(airliner);

                                bool leaseAircraft = airline.Profile.PrimaryPurchasing
                                                        == AirlineProfile.PreferedPurchasing.Leasing;

                                FleetAirliner fAirliner = AirlineHelpers.AddAirliner(
                                    airline,
                                    airliner,
                                    airline.Airports[0],
                                    leaseAircraft);
                                fAirliner.Status = FleetAirliner.AirlinerStatus.Stopped;
                                AirlineHelpers.HireAirlinerPilots(fAirliner);

                                AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);
                            }
                        }
                    });

            //the origin routes
            Parallel.ForEach(
                startData.OriginRoutes,
                routes =>
                    {
                        Airport origin = Airports.GetAirport(routes.Origin);

                        if (origin != null)
                        {
                            Terminal.TerminalType terminalType = airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger;

                            for (int i = 0;
                                 i < Math.Min(routes.Destinations/startDataFactor, origin.Terminals.GetFreeGates(terminalType));
                                 i++)
                            {
                                //if (origin.getAirportFacility(airline, AirportFacility.FacilityType.CheckIn).TypeLevel == 0)
                                //origin.addAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

                                if (!AirportHelpers.HasFreeGates(origin, airline, terminalType))
                                {
                                    AirportHelpers.RentGates(origin, airline, AirportContract.ContractType.LowService, terminalType);
                                }

                                Airport destination = GetStartDataRoutesDestination(routes);

                                //if (destination.getAirportFacility(airline, AirportFacility.FacilityType.CheckIn).TypeLevel == 0)
                                //destination.addAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

                                if (!AirportHelpers.HasFreeGates(destination, airline, terminalType))
                                {
                                    AirportHelpers.RentGates(destination, airline, AirportContract.ContractType.LowService, terminalType);
                                }

                                Guid id = Guid.NewGuid();

                                Route route = null;

                                double price = PassengerHelpers.GetPassengerPrice(origin, destination);

                                if (routes.RouteType == Route.RouteType.Mixed
                                    || routes.RouteType == Route.RouteType.Passenger)
                                {
                                    route = new PassengerRoute(
                                        id.ToString(),
                                        origin,
                                        destination,
                                        GameObject.GetInstance().GameTime,
                                        price);
                                }

                                if (routes.RouteType == Route.RouteType.Cargo)
                                {
                                    route = new CargoRoute(
                                        id.ToString(),
                                        origin,
                                        destination,
                                        GameObject.GetInstance().GameTime,
                                        PassengerHelpers.GetCargoPrice(origin, destination));
                                }

                                bool leaseAircraft = airline.Profile.PrimaryPurchasing
                                                        == AirlineProfile.PreferedPurchasing.Leasing;

                                KeyValuePair<Airliner, bool>? airliner = AIHelpers.GetAirlinerForRoute(
                                    airline,
                                    origin,
                                    destination,
                                    leaseAircraft,
                                    routes.RouteType,
                                    true);

                                if (airliner == null
                                    && airline.Profile.PrimaryPurchasing == AirlineProfile.PreferedPurchasing.Random)
                                {
                                    airliner = AIHelpers.GetAirlinerForRoute(
                                        airline,
                                        origin,
                                        destination,
                                        true,
                                        routes.RouteType,
                                        true);
                                }

                                double distance = MathHelpers.GetDistance(origin, destination);

                                if (airliner != null)
                                {
                                    FleetAirliner fAirliner = AirlineHelpers.AddAirliner(
                                        airline,
                                        airliner.Value.Key,
                                        airline.Airports[0],
                                        leaseAircraft);
                                    fAirliner.AddRoute(route);
                                    fAirliner.Status = FleetAirliner.AirlinerStatus.ToRouteStart;
                                    AirlineHelpers.HireAirlinerPilots(fAirliner);

                                    if (route != null)
                                    {
                                        route.LastUpdated = GameObject.GetInstance().GameTime;

                                        if (routes.RouteType == Route.RouteType.Passenger
                                            || routes.RouteType == Route.RouteType.Mixed)
                                        {
                                            AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);

                                            RouteClassesConfiguration configuration =
                                                AIHelpers.GetRouteConfiguration((PassengerRoute) route);

                                            foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                                            {
                                                ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice
                                                    = price*GeneralHelpers.ClassToPriceFactor(classConfiguration.Type);

                                                foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                                                {
                                                    ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                                            .AddFacility(rFacility);
                                                }
                                            }

                                            AIHelpers.CreateRouteTimeTable(route, fAirliner);
                                        }
                                        if (routes.RouteType == Route.RouteType.Cargo)
                                        {
                                            AIHelpers.CreateCargoRouteTimeTable(route, fAirliner);
                                        }

                                        airline.AddRoute(route);
                                    }
                                }
                            }
                        }
                    });
        }
Example #2
0
        private static void CreateComputerRoutes(Airline airline)
        {
            bool leaseAircraft = airline.Profile.PrimaryPurchasing == AirlineProfile.PreferedPurchasing.Leasing;

            Airport airportHomeBase = FindComputerHomeBase(airline);

            AirportFacility serviceFacility =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.Service).Find(f => f.TypeLevel == 1);
            AirportFacility checkinFacility =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.CheckIn).Find(f => f.TypeLevel == 1);
            AirportFacility cargoTerminal =
                AirportFacilities.GetFacilities(AirportFacility.FacilityType.Cargo).Find(f => f.TypeLevel > 0);

            airportHomeBase.AddAirportFacility(airline, serviceFacility, GameObject.GetInstance().GameTime);
            airportHomeBase.AddAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

            if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
            {
                airportHomeBase.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
            }

            AirlineStartData startData = AirlineStartDatas.GetAirlineStartData(airline);

            //creates the start data for an airline
            if (startData != null)
            {
                AirportHelpers.RentGates(airportHomeBase, airline, AirportContract.ContractType.Full);

                CreateAirlineStartData(airline, startData);
            }
            else
            {
                List<Airport> airportDestinations = AIHelpers.GetDestinationAirports(airline, airportHomeBase);

                if (airportDestinations.Count == 0)
                {
                    airportDestinations =
                        Airports.GetAirports(
                            a =>
                            a.Profile.Country.Region == airportHomeBase.Profile.Country.Region
                            && a != airportHomeBase);
                }

                KeyValuePair<Airliner, bool>? airliner = null;
                Airport airportDestination = null;

                int counter = 0;

                while ((airportDestination == null || airliner == null || !airliner.HasValue)
                       && airportDestinations.Count > counter)
                {
                    airportDestination = airportDestinations[counter];

                    airliner = AIHelpers.GetAirlinerForRoute(
                        airline,
                        airportHomeBase,
                        airportDestination,
                        leaseAircraft,
                        airline.AirlineRouteFocus,
                        true);

                    counter++;
                }

                if (airportDestination == null || !airliner.HasValue)
                {
                    CreateComputerRoutes(airline);
                }
                else
                {
                    AirportHelpers.AddAirlineContract(
                        new AirportContract(
                            airline,
                            airportHomeBase,
                            AirportContract.ContractType.Full,
                            airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger,
                            GameObject.GetInstance().GameTime,
                            2,
                            25,
                            0,
                            true));

                    AirportHelpers.RentGates(airportDestination, airline, AirportContract.ContractType.LowService);
                    //airportDestination.addAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);

                    Guid id = Guid.NewGuid();

                    double price = PassengerHelpers.GetPassengerPrice(airportDestination, airline.Airports[0]);

                    Route route = null;
                    if (airline.AirlineRouteFocus == Route.RouteType.Passenger)
                    {
                        route = new PassengerRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            price);

                        RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((PassengerRoute) route);

                        foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                        {
                            ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
                                                                                                                *GeneralHelpers
                                                                                                                     .ClassToPriceFactor
                                                                                                                     (
                                                                                                                         classConfiguration
                                                                                                                             .Type);

                            foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                            {
                                ((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                        .AddFacility(rFacility);
                            }
                        }
                    }
                    if (airline.AirlineRouteFocus == Route.RouteType.Helicopter)
                    {
                        route = new HelicopterRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            price);

                        RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((HelicopterRoute) route);

                        foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                        {
                            ((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
                                                                                                                 *GeneralHelpers
                                                                                                                      .ClassToPriceFactor
                                                                                                                      (
                                                                                                                          classConfiguration
                                                                                                                              .Type);

                            foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
                            {
                                ((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
                                                         .AddFacility(rFacility);
                            }
                        }
                    }
                    if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
                    {
                        route = new CargoRoute(
                            id.ToString(),
                            airportDestination,
                            airline.Airports[0],
                            GameObject.GetInstance().GameTime,
                            PassengerHelpers.GetCargoPrice(airportDestination, airline.Airports[0]));

                        airportDestination.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
                    }
                    if (leaseAircraft)
                    {
                        AirlineHelpers.AddAirlineInvoice(
                            airline,
                            GameObject.GetInstance().GameTime,
                            Invoice.InvoiceType.Rents,
                            -airliner.Value.Key.LeasingPrice*2);
                    }
                    else
                    {
                        AirlineHelpers.AddAirlineInvoice(
                            airline,
                            GameObject.GetInstance().GameTime,
                            Invoice.InvoiceType.Purchases,
                            -airliner.Value.Key.GetPrice());
                    }

                    var fAirliner =
                        new FleetAirliner(
                            leaseAircraft ? FleetAirliner.PurchasedType.Leased : FleetAirliner.PurchasedType.Bought,
                            GameObject.GetInstance().GameTime,
                            airline,
                            airliner.Value.Key,
                            airportHomeBase) {Status = FleetAirliner.AirlinerStatus.ToRouteStart};
                    fAirliner.AddRoute(route);
                    AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);
                    AirlineHelpers.HireAirlinerPilots(fAirliner);

                    airline.AddAirliner(fAirliner);

                    airline.AddRoute(route);
                    if (route != null)
                    {
                        route.LastUpdated = GameObject.GetInstance().GameTime;

                        if (route.Type == Route.RouteType.Passenger || route.Type == Route.RouteType.Mixed)
                        {
                            AIHelpers.CreateRouteTimeTable(route, fAirliner);
                        }
                        if (route.Type == Route.RouteType.Cargo)
                        {
                            AIHelpers.CreateCargoRouteTimeTable(route, fAirliner);
                        }
                    }
                }
            }
        }
        //creates the stop over route based on the main route
        public static StopoverRoute CreateStopoverRoute(Airport dest1, Airport stopover, Airport dest2, Route mainroute, bool oneLegged, Route.RouteType type)
        {
            var stopoverRoute = new StopoverRoute(stopover);

            Guid id = Guid.NewGuid();

            if (!oneLegged)
            {
                if (mainroute.Type == Route.RouteType.Passenger || mainroute.Type == Route.RouteType.Mixed)
                {
                    var routeLegTwo = new PassengerRoute(id.ToString(), dest1, stopover, GameObject.GetInstance().GameTime, 0);

                    foreach (RouteAirlinerClass aClass in ((PassengerRoute) mainroute).Classes)
                    {
                        //routeLegTwo.getRouteAirlinerClass(aClass.Type).FarePrice = aClass.FarePrice;
                        routeLegTwo.GetRouteAirlinerClass(aClass.Type).FarePrice = PassengerHelpers.GetPassengerPrice(dest1, stopover)*GeneralHelpers.ClassToPriceFactor(aClass.Type);

                        foreach (RouteFacility facility in aClass.GetFacilities())
                            routeLegTwo.GetRouteAirlinerClass(aClass.Type).AddFacility(facility);

                        routeLegTwo.GetRouteAirlinerClass(aClass.Type).Seating = aClass.Seating;
                    }


                    stopoverRoute.AddLeg(routeLegTwo);
                }
                if (mainroute.Type == Route.RouteType.Cargo || mainroute.Type == Route.RouteType.Mixed)
                {
                    var routeLegTwo = new CargoRoute(id.ToString(), dest1, stopover, GameObject.GetInstance().GameTime, ((CargoRoute) mainroute).PricePerUnit);

                    stopoverRoute.AddLeg(routeLegTwo);
                }
            }

            if (mainroute.Type == Route.RouteType.Mixed || mainroute.Type == Route.RouteType.Passenger)
            {
                id = Guid.NewGuid();

                var routeLegOne = new PassengerRoute(id.ToString(), stopover, dest2, GameObject.GetInstance().GameTime, 0);

                foreach (RouteAirlinerClass aClass in ((PassengerRoute) mainroute).Classes)
                {
                    //routeLegOne.getRouteAirlinerClass(aClass.Type).FarePrice = aClass.FarePrice;

                    routeLegOne.GetRouteAirlinerClass(aClass.Type).FarePrice = PassengerHelpers.GetPassengerPrice(stopover, dest2)*GeneralHelpers.ClassToPriceFactor(aClass.Type);


                    foreach (RouteFacility facility in aClass.GetFacilities())
                        routeLegOne.GetRouteAirlinerClass(aClass.Type).AddFacility(facility);

                    routeLegOne.GetRouteAirlinerClass(aClass.Type).Seating = aClass.Seating;
                }

                stopoverRoute.AddLeg(routeLegOne);
            }
            if (mainroute.Type == Route.RouteType.Cargo || mainroute.Type == Route.RouteType.Mixed)
            {
                var routeLegOne = new CargoRoute(id.ToString(), stopover, dest2, GameObject.GetInstance().GameTime, ((CargoRoute) mainroute).PricePerUnit);

                stopoverRoute.AddLeg(routeLegOne);
            }


            return stopoverRoute;
        }
        private static void SetupScenarioRoute(ScenarioAirlineRoute saroute, Airline airline)
        {
            SetupScenarioAirport(airline, saroute.Destination1, saroute.Quantity);
            SetupScenarioAirport(airline, saroute.Destination2, saroute.Quantity);

            double price = PassengerHelpers.GetPassengerPrice(saroute.Destination1, saroute.Destination2);

            for (int i = 0; i < saroute.Quantity; i++)
            {
                Guid id = Guid.NewGuid();

                var route = new PassengerRoute(
                    id.ToString(),
                    saroute.Destination1,
                    saroute.Destination2,
                    GameObject.GetInstance().GameTime,
                    price);

                RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration(route);

                foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
                {
                    route.GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
                                                                                     *GeneralHelpers.ClassToPriceFactor
                                                                                          (classConfiguration.Type);

                    foreach (RouteFacility rfacility in classConfiguration.GetFacilities())
                    {
                        route.GetRouteAirlinerClass(classConfiguration.Type).AddFacility(rfacility);
                    }
                }

                airline.AddRoute(route);

                FleetAirliner fAirliner = AirlineHelpers.CreateAirliner(airline, saroute.AirlinerType);
                airline.AddAirliner(fAirliner);

                fAirliner.AddRoute(route);

                AIHelpers.CreateRouteTimeTable(route, fAirliner);

                fAirliner.Status = FleetAirliner.AirlinerStatus.ToRouteStart;
                AirlineHelpers.HireAirlinerPilots(fAirliner);

                route.LastUpdated = GameObject.GetInstance().GameTime;
            }
        }
        //loads a route
        private static Route LoadRoute(
            XmlElement routeNode,
            Airline airline,
            Route.RouteType routetype = Route.RouteType.Passenger)
        {
            string id = routeNode.Attributes["id"].Value;
            Airport dest1 = Airports.GetAirport(routeNode.Attributes["destination1"].Value);
            Airport dest2 = Airports.GetAirport(routeNode.Attributes["destination2"].Value);
            Boolean isBanned = Convert.ToBoolean(routeNode.Attributes["isbanned"].Value);

            if (routeNode.HasAttribute("type"))
            {
                routetype = (Route.RouteType) Enum.Parse(typeof (Route.RouteType), routeNode.Attributes["type"].Value);
            }

            Route route;

            if (routetype == Route.RouteType.Passenger || routetype == Route.RouteType.Mixed)
            {
                route = new PassengerRoute(id, dest1, dest2, DateTime.Now, 0);
            }
            else
            {
                route = new CargoRoute(id, dest1, dest2, DateTime.Now, 0);
            }

            route.Banned = isBanned;

            /* foreach (StopoverRoute stopover in route.Stopovers)
            {
                XmlElement routeStopoverNode = xmlDoc.CreateElement("stopover");
                routeStopoverNode.SetAttribute("airport", stopover.Stopover.Profile.ID);

                XmlElement stopoverLegsNode = xmlDoc.CreateElement("legs");
                foreach (Route leg in stopover.Legs)
                {
                    XmlElement stopoverLegNode = xmlDoc.CreateElement("leg");

                    stopoverLegNode.AppendChild(SaveRoute(xmlDoc, leg));

                    stopoverLegsNode.AppendChild(stopoverLegNode);
                }
                routeStopoverNode.AppendChild(stopoverLegsNode);
                routeStopoversNode.AppendChild(routeStopoverNode);*/

            XmlNodeList routeStopoverList = routeNode.SelectNodes("stopovers/stopover");

            if (routeStopoverList != null)
                foreach (XmlElement routeStopoverNode in routeStopoverList)
                {
                    Airport stopoverAirport = Airports.GetAirportFromID(routeStopoverNode.Attributes["airport"].Value);

                    var stopoverRoute = new StopoverRoute(stopoverAirport);

                    XmlNodeList legsList = routeStopoverNode.SelectNodes("legs/leg");

                    if (legsList != null)
                        foreach (XmlElement legNode in legsList)
                        {
                            stopoverRoute.AddLeg(LoadRoute((XmlElement) legNode.SelectSingleNode("route"), airline, routetype));
                        }

                    route.AddStopover(stopoverRoute);
                }

            if (routetype == Route.RouteType.Passenger || routetype == Route.RouteType.Mixed)
            {
                ((PassengerRoute) route).Classes.Clear();

                XmlNodeList routeClassList = routeNode.SelectNodes("routeclasses/routeclass");

                if (routeClassList != null)
                    foreach (XmlElement routeClassNode in routeClassList)
                    {
                        var airlinerClassType =
                            (AirlinerClass.ClassType)
                            Enum.Parse(typeof (AirlinerClass.ClassType), routeClassNode.Attributes["type"].Value);
                        double fareprice = Convert.ToDouble(
                            routeClassNode.Attributes["fareprice"].Value,
                            new CultureInfo("de-DE", false));
                        var seatingType =
                            (RouteAirlinerClass.SeatingType)
                            Enum.Parse(
                                typeof (RouteAirlinerClass.SeatingType),
                                routeClassNode.Attributes["seating"].Value);

                        var rClass = new RouteAirlinerClass(
                            airlinerClassType,
                            RouteAirlinerClass.SeatingType.ReservedSeating,
                            fareprice) {Seating = seatingType};

                        foreach (RouteFacility.FacilityType ftype in Enum.GetValues(typeof (RouteFacility.FacilityType)))
                        {
                            if (routeClassNode.HasAttribute(ftype.ToString()))
                            {
                                RouteFacility facility =
                                    RouteFacilities.GetFacility(routeClassNode.Attributes[ftype.ToString()].Value);
                                rClass.AddFacility(facility);
                            }
                        }

                        ((PassengerRoute) route).AddRouteAirlinerClass(rClass);
                    }
            }
            if (routetype == Route.RouteType.Mixed || routetype == Route.RouteType.Cargo)
            {
                var routeCargoNode = (XmlElement) routeNode.SelectSingleNode("cargo");
                if (routeCargoNode != null)
                {
                    double unitPrice = Convert.ToDouble(
                        routeCargoNode.Attributes["priceperunit"].Value,
                        new CultureInfo("de-DE", false));

                    ((CargoRoute) route).PricePerUnit = unitPrice;
                }
            }

            var timeTable = new RouteTimeTable(route);

            XmlNodeList timetableList = routeNode.SelectNodes("timetable/timetableentry");

            if (timetableList != null)
                foreach (XmlElement entryNode in timetableList)
                {
                    Airport entryDest = Airports.GetAirport(entryNode.Attributes["destination"].Value);
                    string flightCode = entryNode.Attributes["flightcode"].Value;
                    var day = (DayOfWeek) Enum.Parse(typeof (DayOfWeek), entryNode.Attributes["day"].Value);
                    TimeSpan time = TimeSpan.Parse(entryNode.Attributes["time"].Value);
                    FleetAirliner airliner = entryNode.Attributes["airliner"].Value == "-"
                                                 ? null
                                                 : airline.Fleet.Find(a => a.Airliner.ID == entryNode.Attributes["airliner"].Value);

                    var entry = new RouteTimeTableEntry(
                        timeTable,
                        day,
                        time,
                        new RouteEntryDestination(entryDest, flightCode, null),
                        null);

                    if (entryNode.HasAttribute("id"))
                    {
                        entry.ID = entryNode.Attributes["id"].Value;
                    }

                    if (entryNode.HasAttribute("mainentry"))
                    {
                        entry.MainEntry =
                            airline.Routes.SelectMany(r => r.TimeTable.Entries)
                                   .ToList()
                                   .Find(e => e.ID == entryNode.Attributes["mainentry"].Value);
                    }

                    entry.Airliner = airliner;

                    if (airliner != null && !airliner.Routes.Contains(route))
                    {
                        airliner.Routes.Add(route);
                    }

                    timeTable.AddEntry(entry);
                }
            route.TimeTable = timeTable;

            XmlNodeList routeInvoiceList = routeNode.SelectNodes("invoices/invoice");

            if (routeInvoiceList != null)
                foreach (XmlElement routeInvoiceNode in routeInvoiceList)
                {
                    var type =
                        (Invoice.InvoiceType)
                        Enum.Parse(typeof (Invoice.InvoiceType), routeInvoiceNode.Attributes["type"].Value);
                    int invoiceYear = Convert.ToInt16(routeInvoiceNode.Attributes["year"].Value);
                    int invoiceMonth = Convert.ToInt16(routeInvoiceNode.Attributes["month"].Value);
                    double invoiceAmount = Convert.ToDouble(
                        routeInvoiceNode.Attributes["amount"].Value,
                        new CultureInfo("de-DE", false));

                    route.SetRouteInvoice(type, invoiceYear, invoiceMonth, 1, invoiceAmount);
                }

            return route;
        }
        private Boolean createRoute()
        {
            SpecialContract contract = null;

            if (Contracts.Count > 0 && cbContract.SelectedItem != null)
            {
                contract = (SpecialContract)cbContract.SelectedItem;
            }
            Route route = null;
            var destination1 = (Airport)cbDestination1.SelectedItem;
            var destination2 = (Airport)cbDestination2.SelectedItem;
            var stopover1 = (Airport)cbStopover1.SelectedItem;
            Airport stopover2 = cbStopover2.Visibility == Visibility.Visible
                ? (Airport)cbStopover2.SelectedItem
                : null;
            DateTime startDate = dpStartDate.IsEnabled && dpStartDate.SelectedDate.HasValue
                ? dpStartDate.SelectedDate.Value
                : GameObject.GetInstance().GameTime;

            Weather.Season season = rbSeasonAll.IsChecked.Value ? Weather.Season.AllYear : Weather.Season.Winter;
            season = rbSeasonSummer.IsChecked.Value ? Weather.Season.Summer : season;
            season = rbSeasonWinter.IsChecked.Value ? Weather.Season.Winter : season;

            Boolean routeExists = GameObject.GetInstance().HumanAirline.Routes.Exists(r => r.Destination1 == destination1 && r.Destination2 == destination2);

            if (routeExists)
            {
                WPFMessageBox.Show(
                                  Translator.GetInstance().GetString("MessageBox", "3006"),
                                  string.Format(Translator.GetInstance().GetString("MessageBox", "3006", "message"), destination1.Profile.Name, destination2.Profile.Name),
                                  WPFMessageBoxButtons.Ok);
                return false;
            }

            try
            {
                if (AirlineHelpers.IsRouteDestinationsOk(
                    GameObject.GetInstance().HumanAirline,
                    destination1,
                    destination2,
                    RouteType,
                    stopover1,
                    stopover2))
                {
                    Guid id = Guid.NewGuid();

                    //passenger route
                    if (RouteType == Route.RouteType.Passenger)
                    {
                        route = new PassengerRoute(id.ToString(), destination1, destination2, startDate, 0);

                        foreach (MVVMRouteClass rac in Classes.Where(c => c.IsUseable))
                        {
                            ((PassengerRoute)route).GetRouteAirlinerClass(rac.Type).FarePrice = rac.FarePrice;

                            foreach (MVVMRouteFacility facility in rac.Facilities)
                            {
                                ((PassengerRoute)route).GetRouteAirlinerClass(rac.Type)
                                    .AddFacility(facility.SelectedFacility);
                            }
                        }
                    }
                    //cargo route
                    else if (RouteType == Route.RouteType.Cargo)
                    {
                        double cargoPrice = Convert.ToDouble(txtCargoPrice.Text);
                        route = new CargoRoute(id.ToString(), destination1, destination2, startDate, cargoPrice);
                    }
                    else if (RouteType == Route.RouteType.Helicopter)
                    {
                        route = new HelicopterRoute(id.ToString(), destination1, destination2, startDate, 0);

                        foreach (MVVMRouteClass rac in Classes.Where(c => c.IsUseable))
                        {
                            ((HelicopterRoute)route).GetRouteAirlinerClass(rac.Type).FarePrice = rac.FarePrice;

                            foreach (MVVMRouteFacility facility in rac.Facilities)
                            {
                                ((HelicopterRoute)route).GetRouteAirlinerClass(rac.Type)
                                    .AddFacility(facility.SelectedFacility);
                            }
                        }

                    }
                    else if (RouteType == Route.RouteType.Mixed)
                    {
                        double cargoPrice = Convert.ToDouble(txtCargoPrice.Text);

                        route = new CombiRoute(id.ToString(), destination1, destination2, startDate, 0, cargoPrice);

                        foreach (MVVMRouteClass rac in Classes.Where(c => c.IsUseable))
                        {
                            ((PassengerRoute)route).GetRouteAirlinerClass(rac.Type).FarePrice = rac.FarePrice;

                            foreach (MVVMRouteFacility facility in rac.Facilities)
                            {
                                ((PassengerRoute)route).GetRouteAirlinerClass(rac.Type)
                                    .AddFacility(facility.SelectedFacility);
                            }
                        }
                    }

                    FleetAirlinerHelpers.CreateStopoverRoute(route, stopover1, stopover2);

                    route.Season = season;

                    GameObject.GetInstance().HumanAirline.AddRoute(route);

                    if (contract != null)
                        contract.Routes.Add(route);

                    return true;
                }
            }
            catch (Exception ex)
            {
                WPFMessageBox.Show(
                    Translator.GetInstance().GetString("MessageBox", ex.Message),
                    Translator.GetInstance().GetString("MessageBox", ex.Message, "message"),
                    WPFMessageBoxButtons.Ok);

                return false;
            }

            return false;
        }