TheAirline.Models.Airports.Airport.GetDestinationPassengersRate C# (CSharp) Method

        public ushort GetDestinationPassengersRate(Airport destination, AirlinerClass.ClassType type)
        {
            DestinationDemand pax = DestinationPassengers.Find(a => a.Destination == destination.Profile.IATACode);

            Array values = Enum.GetValues(typeof (AirlinerClass.ClassType));

            int classFactor = 0;

            int i = 1;

            foreach (AirlinerClass.ClassType value in values)
            {
                if (value == type)
                {
                    classFactor = i;
                }
                i++;
            }

            if (pax == null)
            {
                return Statics.GetDestinationPassengersRate(destination, type);
            }
            return
                (ushort)
                (Statics.GetDestinationPassengersRate(destination, type) + (ushort) (pax.Rate/classFactor));
        }

        public static int GetFlightPassengers(
            Airport airportCurrent,
            Airport airportDestination,
            FleetAirliner airliner,
            AirlinerClass.ClassType type)
        {
            double distance = MathHelpers.GetDistance(airportCurrent, airportDestination);

            Route currentRoute =
                airliner.Routes.Find(
                    r =>
                    r.Stopovers.SelectMany(s => s.Legs)
                     .ToList()
                     .Exists(
                         l =>
                         (l.Destination1 == airportCurrent || l.Destination1 == airportDestination)
                         && (l.Destination2 == airportDestination || l.Destination2 == airportCurrent))
                    || (r.Destination1 == airportCurrent || r.Destination1 == airportDestination)
                    && (r.Destination2 == airportDestination || r.Destination2 == airportCurrent));

            if (currentRoute == null)
            {
                return 0;
            }

            //double basicPrice = GetPassengerPrice(currentRoute.Destination1, currentRoute.Destination2, type);
            //double routePrice = ((PassengerRoute)currentRoute).getFarePrice(type);

            //double priceDiff = basicPrice / routePrice;

            double routeScoreFactor = RouteHelpers.GetRouteTotalScore(currentRoute)/5;

            double demand = airportCurrent.GetDestinationPassengersRate(airportDestination, type);

            double passengerDemand = (demand
                                      + GetFlightConnectionPassengers(
                                          airportCurrent,
                                          airportDestination,
                                          airliner,
                                          type)
                                      + GetNearbyPassengerDemand(airportCurrent, airportDestination, airliner, type))
                                     *GetSeasonFactor(airportDestination)*GetHolidayFactor(airportDestination)
                                     *GetHolidayFactor(airportCurrent);

            passengerDemand *= GameObject.GetInstance().Difficulty.PassengersLevel;
            passengerDemand *= routeScoreFactor;

            if (airliner.Airliner.Airline.MarketFocus == AirlineFocus.Global && distance > 3000
                && airportCurrent.Profile.Country != airportDestination.Profile.Country)
            {
                passengerDemand = passengerDemand*(115/100);
            }

            if (airliner.Airliner.Airline.MarketFocus == AirlineFocus.Regional && distance < 1500)
            {
                passengerDemand = passengerDemand*(115/100);
            }

            if (airliner.Airliner.Airline.MarketFocus == AirlineFocus.Domestic && distance < 1500
                && airportDestination.Profile.Country == airportCurrent.Profile.Country)
            {
                passengerDemand = passengerDemand*(115/100);
            }

            if (airliner.Airliner.Airline.MarketFocus == AirlineFocus.Local && distance < 1000)
            {
                passengerDemand = passengerDemand*(115/100);
            }

            Hub hub = airportDestination.GetHubs().Find(h => h.Airline == airliner.Airliner.Airline);

            if (hub != null)
            {
                switch (hub.Type.Type)
                {
                    case HubType.TypeOfHub.FocusCity:
                        if (airportDestination.Profile.Country == airportCurrent.Profile.Country)
                        {
                            passengerDemand = passengerDemand*1.15;
                        }
                        break;

                    case HubType.TypeOfHub.RegionalHub:
                        if (airportDestination.Profile.Country.Region == airportCurrent.Profile.Country.Region)
                        {
                            passengerDemand = passengerDemand*1.20;
                        }
                        break;

                    case HubType.TypeOfHub.Hub:
                        passengerDemand = passengerDemand*1.20;
                        break;

                    case HubType.TypeOfHub.FortressHub:
                        passengerDemand = passengerDemand*1.30;
                        break;
                }
            }

            var routes = new List<Route>();

            foreach (Airline airline in Airlines.GetAllAirlines())
            {
                var aRoutes = new List<Route>(airline.Routes);

                routes.AddRange(
                    aRoutes.Where(r => r.Type == Route.RouteType.Passenger || r.Type == Route.RouteType.Mixed)
                           .Where(
                               r =>
                               (r.HasAirliner)
                               && (r.Destination1 == airportCurrent || r.Destination1 == airportDestination)
                               && (r.Destination2 == airportDestination || r.Destination2 == airportCurrent)));
                routes.AddRange(
                    aRoutes.Where(r => r.Type == Route.RouteType.Mixed || r.Type == Route.RouteType.Passenger)
                           .Where(
                               r =>
                               r.Stopovers.SelectMany(
                                   s =>
                                   s.Legs.Where(
                                       l =>
                                       r.HasAirliner
                                       && (l.Destination1 == airportCurrent
                                           || l.Destination1 == airportDestination)
                                       && (l.Destination2 == airportDestination
                                           || l.Destination2 == airportCurrent))).Any()));
            }

            double flightsPerDay = Convert.ToDouble(routes.Sum(r => r.TimeTable.Entries.Count))/7;

            passengerDemand = passengerDemand/flightsPerDay;

            double totalCapacity;
            if (routes.Count > 0 && routes.Count(r => r.HasAirliner) > 0)
            {
                totalCapacity =
                    routes.Where(r => r.HasAirliner)
                          .Sum(r => r.GetAirliners().Max(a => a.Airliner.GetTotalSeatCapacity()));
                //SelectMany(r => r.Stopovers.Where(s=>s.Legs.Count >0))).Sum(s=>s.;//a => a.Routes.SelectMany(r=>r.Stopovers.SelectMany(s=>s.Legs.Where(l=>r.HasAirliner && (l.Destination1 == airportCurrent || l.Destination1 == airportDestination) && (l.Destination2 == airportDestination || l.Destination2 == airportCurrent))).Sum(r=>r.getAirliners().Max(a=>a.Airliner.getTotalSeatCapacity()));
            }
            else
            {
                totalCapacity = 0;
                // routes.Where(r => r.HasAirliner).Sum(r => r.getAirliners().Max(a => a.Airliner.getTotalSeatCapacity()));
            }

            double capacityPercent = passengerDemand > totalCapacity ? 1 : passengerDemand/totalCapacity;

            var rations = new Dictionary<Route, double>();

            foreach (Route route in routes)
            {
                double level = ((PassengerRoute) route).GetServiceLevel(type)
                               /((PassengerRoute) route).GetFarePrice(type);

                rations.Add(route, level);
            }

            double totalRatio = rations.Values.Sum();

            double routeRatioPercent = 1;

            if (rations.ContainsKey(currentRoute))
            {
                routeRatioPercent = Math.Max(1, rations[currentRoute]/Math.Max(1, totalRatio));
            }

            IDictionary<Airline, double> airlineScores = new Dictionary<Airline, double>();

            foreach (Airline airline in Airlines.GetAllAirlines())
            {
                airlineScores.Add(airline, airportCurrent.GetAirlineReputation(airline));
            }

            double reputation = StatisticsHelpers.GetRatingScale(airlineScores)[airliner.Airliner.Airline];

            if (reputation < 76)
            {
                reputation = 75;
            }

            double reputationPercent = reputation/100;

            double routePriceDiff = 1; // priceDiff < 0.75 ? priceDiff : 1;

            routePriceDiff *= GameObject.GetInstance().Difficulty.PriceLevel;

            double randomPax = Convert.ToDouble(Rnd.Next(97, 103))/100;

            var pax =
                (int)
                Math.Min(
                    airliner.Airliner.GetAirlinerClass(type).SeatingCapacity,
                    (airliner.Airliner.GetAirlinerClass(type).SeatingCapacity*routeRatioPercent
                     *reputationPercent*capacityPercent*routePriceDiff*randomPax));

            if (pax < 0)
            {
                pax = 0;
            }

            return pax;
        }