Наследование: BaseModel
        public PopUpCompareAirliners(Airliner airliner1, Airliner airliner2)
        {
            this.Airliner1 = airliner1;
            this.Airliner2 = airliner2;

            InitializeComponent();
        }
        public FleetAirliner(
            PurchasedType purchased,
            DateTime purchasedDate,
            Airline airline,
            Airliner airliner,
            Airport homebase)
        {
            Airliner = airliner;
            Purchased = purchased;
            PurchasedDate = purchasedDate;
            Airliner.Airline = airline;
            Homebase = homebase;
            Name = airliner.TailNumber;
            Statistics = new AirlinerStatistics(this);
            LastCMaintenance = Airliner.BuiltDate;
            LastAMaintenance = Airliner.BuiltDate;
            LastBMaintenance = Airliner.BuiltDate;
            LastDMaintenance = Airliner.BuiltDate;
            Status = AirlinerStatus.Stopped;
            MaintRoutes = new List<Route>();

            CurrentPosition = Homebase;
            //new GeoCoordinate(this.Homebase.Profile.Coordinates.Latitude,this.Homebase.Profile.Coordinates.Longitude);

            Routes = new List<Route>();
            Pilots = new List<Pilot>();
            InsurancePolicies = new List<AirlinerInsurance>();
            MaintenanceHistory = new Dictionary<Invoice, string>();

            Data = new OperatingData();

            if (Purchased == PurchasedType.Bought || Purchased == PurchasedType.BoughtDownPayment)
                Airliner.Owner = Airliner.Airline;
        }
        public static void CreateAirlinerClasses(Airliner airliner)
        {
            airliner.ClearAirlinerClasses();

            List<AirlinerClass> classes = GetAirlinerClasses(airliner.Type);

            foreach (AirlinerClass aClass in classes)
            {
                airliner.AddAirlinerClass(aClass);
            }
        }
        public void TestInitialize()
        {
            Setup.LoadAirlinerFacilities();
            Setup.CreateAdvertisementTypes();
            Setup.LoadInflationYears();

            this.combiAirliner = new Airliner(
                "0",
                Fakes.GetNewDummyCombiAirliner(),
                "AM-REG",
                new DateTime(2000, 8, 25)) { Airline = Fakes.CreateNewDummyAirline() };
        }
        public PageUsedAirliner(Airliner airliner)
        {
            this.Airliner = airliner;

            long minRunway = this.Airliner.MinRunwaylength;

            List<Airport> homebases = AirlineHelpers.GetHomebases(GameObject.GetInstance().HumanAirline, minRunway);

            this.Homebases = homebases;

            this.DataContext = this.Airliner;

            this.InitializeComponent();
        }
        public static Airliner CreateAirlinerFromYear(int year)
        {
            Guid id = Guid.NewGuid();

            List<AirlinerType> types =
                AirlinerTypes.GetTypes(t => t.Produced.From.Year < year && t.Produced.To.Year > year);

            int typeNumber = Rnd.Next(types.Count);
            AirlinerType type = types[typeNumber];

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

            int builtYear = 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(1000, 100000);
            long km = kmPerYear*age;

            airliner.Flown = km;

            List<EngineType> engines = EngineTypes.GetEngineTypes(airliner.Type, GameObject.GetInstance().GameTime.Year);

            if (engines.Count > 0)
            {
                int engineNumber = Rnd.Next(engines.Count);

                airliner.EngineType = engines[engineNumber];
            }

            CreateAirlinerClasses(airliner);

            return airliner;
        }
        private static Airliner CreateAirliner(double minRange)
        {
            Guid id = Guid.NewGuid();

            List<AirlinerType> types =
                AirlinerTypes.GetTypes(
                    t => t.Range >= minRange && t.Produced.From.Year < GameObject.GetInstance().GameTime.AddYears(-5).Year
                         && t.Produced.To > GameObject.GetInstance().GameTime.AddYears(-35));

            int typeNumber = Rnd.Next(types.Count);
            AirlinerType type = types[typeNumber];

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

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

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

            if (airliner.TailNumber.Length < 2)
            {
                typeNumber = 0;
            }

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

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

            airliner.Flown = km;

            CreateAirlinerClasses(airliner);

            List<EngineType> engines = EngineTypes.GetEngineTypes(airliner.Type, GameObject.GetInstance().GameTime.Year);

            if (engines.Count > 0)
            {
                int engineNumber = Rnd.Next(engines.Count);

                airliner.EngineType = engines[engineNumber];
            }

            return airliner;
        }
 public AirlinerMVVM(Airliner airliner)
 {
     this.Airliner = airliner;
     this.IsSelected = false;
 }
 //returns the landing fee for an airliner at an airport
 public static double GetLandingFee(Airport airport, Airliner airliner)
 {
     return (airliner.Type.Weight/1000)*GeneralHelpers.GetInflationPrice(airport.LandingFee);
 }
Пример #10
0
 //removes an airliner from the list
 public static void RemoveAirliner(Airliner airliner)
 {
     _airliners.Remove(airliner);
 }
        public PopUpAirlinerConfiguration(Airliner airliner)
        {
            this.Classes = new List<AirlinerClass>();

            foreach (AirlinerClass aClass in airliner.Classes)
            {
                this.Classes.Add(aClass);
            }

            this.Type = airliner.Type;

            createPopUp();
        }
        //creates an airliner for an airline
        public static FleetAirliner CreateAirliner(Airline airline, AirlinerType type)
        {
            Guid id = Guid.NewGuid();

            var airliner = new Airliner(id.ToString(), type, airline.Profile.Country.TailNumbers.GetNextTailNumber(), GameObject.GetInstance().GameTime);
            Airliners.AddAirliner(airliner);

            var fAirliner = new FleetAirliner(FleetAirliner.PurchasedType.Bought, GameObject.GetInstance().GameTime, airline, airliner, airline.Airports[0]);

            airliner.ClearAirlinerClasses();

            AirlinerHelpers.CreateAirlinerClasses(airliner);

            return fAirliner;
        }
        private void orderAirliners(double discount = 0)
        {
            DateTime deliveryDate = this.dpDeliveryDate.SelectedDate.HasValue
                ? this.dpDeliveryDate.SelectedDate.Value
                : this.Orders.DeliveryDate;

            Guid id = Guid.NewGuid();

            foreach (AirlinerOrderMVVM order in this.Orders.Orders)
            {
                for (int i = 0; i < order.Amount; i++)
                {
                    var airliner = new Airliner(
                        id.ToString(),
                        order.Type,
                        GameObject.GetInstance().HumanAirline.Profile.Country.TailNumbers.GetNextTailNumber(),
                        deliveryDate);
                    Models.Airliners.Airliners.AddAirliner(airliner);

                    var pType = FleetAirliner.PurchasedType.Bought;
                    GameObject.GetInstance().HumanAirline.AddAirliner(pType, airliner, order.Homebase);

                    airliner.ClearAirlinerClasses();

                    foreach (AirlinerClass aClass in order.Classes)
                    {
                        var tClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity);
                        tClass.RegularSeatingCapacity = aClass.RegularSeatingCapacity;

                        foreach (AirlinerFacility facility in aClass.GetFacilities())
                        {
                            tClass.SetFacility(GameObject.GetInstance().HumanAirline, facility);
                        }

                        airliner.AddAirlinerClass(tClass);
                    }

                    airliner.EngineType = order.Engine;

                }
            }

            int totalAmount = this.Orders.Orders.Sum(o => o.Amount);
            double price = this.Orders.Orders.Sum(o => o.getOrderPrice());

            double totalPrice = price * ((1 - GeneralHelpers.GetAirlinerOrderDiscount(totalAmount)))
                                * ((100 - discount) / 100);

            AirlineHelpers.AddAirlineInvoice(
                GameObject.GetInstance().HumanAirline,
                GameObject.GetInstance().GameTime,
                Invoice.InvoiceType.Purchases,
                -totalPrice);
        }
        private void btnOrder_Click(object sender, RoutedEventArgs e)
        {
            Boolean hasHomebases = true;
            foreach (AirlinerOrderMVVM order in this.Orders.Orders)
            {
                if (order.Homebase == null)
                {
                    hasHomebases = false;
                }
            }
            Boolean contractedOrder = false;
            Boolean tryOrder = true;
             DateTime deliveryDate = this.dpDeliveryDate.SelectedDate.HasValue
                ? this.dpDeliveryDate.SelectedDate.Value
                : this.Orders.DeliveryDate;

            if (!hasHomebases)
            {
                WPFMessageBox.Show(
                    Translator.GetInstance().GetString("MessageBox", "2002"),
                    Translator.GetInstance().GetString("MessageBox", "2002", "message"),
                    WPFMessageBoxButtons.Ok);
            }
            else
            {
                if (GameObject.GetInstance().HumanAirline.Contract != null)
                {
                    if (GameObject.GetInstance().HumanAirline.Contract.Manufacturer == this.Manufacturer)
                    {
                        contractedOrder = true;
                    }
                    else
                    {
                        double terminationFee = GameObject.GetInstance().HumanAirline.Contract.GetTerminationFee();
                        WPFMessageBoxResult result =
                            WPFMessageBox.Show(
                                Translator.GetInstance().GetString("MessageBox", "2010"),
                                string.Format(
                                    Translator.GetInstance().GetString("MessageBox", "2010", "message"),
                                    GameObject.GetInstance().HumanAirline.Contract.Manufacturer.Name,
                                    terminationFee),
                                WPFMessageBoxButtons.YesNo);

                        if (result == WPFMessageBoxResult.Yes)
                        {
                            AirlineHelpers.AddAirlineInvoice(
                                GameObject.GetInstance().HumanAirline,
                                GameObject.GetInstance().GameTime,
                                Invoice.InvoiceType.Purchases,
                                -terminationFee);
                            GameObject.GetInstance().HumanAirline.Contract = null;

                            this.Contract.Contracted = null;
                        }
                        tryOrder = result == WPFMessageBoxResult.Yes;
                    }
                }

                if (tryOrder)
                {
                    int totalAmount = this.Orders.Orders.Sum(o => o.Amount);
                    double price = this.Orders.Orders.Sum(o => o.getOrderPrice());

                    double totalPrice = price * ((1 - GeneralHelpers.GetAirlinerOrderDiscount(totalAmount)));

                    if (contractedOrder)
                    {
                        totalPrice = totalPrice
                                     * ((100 - GameObject.GetInstance().HumanAirline.Contract.Discount) / 100);
                    }

                    double downpaymentPrice = 0;

                    downpaymentPrice = totalPrice * (GameObject.GetInstance().Difficulty.PriceLevel / 10);

                    if (this.cbDownPayment.IsChecked.Value)
                    {
                        if (downpaymentPrice > GameObject.GetInstance().HumanAirline.Money)
                        {
                            WPFMessageBox.Show(
                                Translator.GetInstance().GetString("MessageBox", "2001"),
                                Translator.GetInstance().GetString("MessageBox", "2001", "message"),
                                WPFMessageBoxButtons.Ok);
                        }
                        else
                        {
                            WPFMessageBoxResult result =
                                WPFMessageBox.Show(
                                    Translator.GetInstance().GetString("MessageBox", "2009"),
                                    string.Format(
                                        Translator.GetInstance().GetString("MessageBox", "2009", "message"),
                                        totalPrice,
                                        downpaymentPrice),
                                    WPFMessageBoxButtons.YesNo);

                            if (result == WPFMessageBoxResult.Yes)
                            {
                                foreach (AirlinerOrderMVVM order in this.Orders.Orders)
                                {
                                    for (int i = 0; i < order.Amount; i++)
                                    {
                                        Guid id = Guid.NewGuid();

                                        var airliner = new Airliner(
                                            id.ToString(),
                                            order.Type,
                                            GameObject.GetInstance()
                                                .HumanAirline.Profile.Country.TailNumbers.GetNextTailNumber(),
                                            deliveryDate);

                                        airliner.ClearAirlinerClasses();

                                        foreach (AirlinerClass aClass in order.Classes)
                                        {
                                            var tClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity);
                                            tClass.RegularSeatingCapacity = aClass.RegularSeatingCapacity;

                                            foreach (AirlinerFacility facility in aClass.GetFacilities())
                                            {
                                                tClass.SetFacility(GameObject.GetInstance().HumanAirline, facility);
                                            }

                                            airliner.AddAirlinerClass(tClass);
                                        }

                                        airliner.EngineType = order.Engine;

                                        Models.Airliners.Airliners.AddAirliner(airliner);

                                        var pType = FleetAirliner.PurchasedType.BoughtDownPayment;
                                        GameObject.GetInstance()
                                            .HumanAirline.AddAirliner(pType, airliner, order.Homebase);

                                    }
                                }
                                if (contractedOrder)
                                {
                                    GameObject.GetInstance().HumanAirline.Contract.PurchasedAirliners +=
                                        this.Orders.Orders.Sum(o => o.Amount);
                                }

                                AirlineHelpers.AddAirlineInvoice(
                                    GameObject.GetInstance().HumanAirline,
                                    GameObject.GetInstance().GameTime,
                                    Invoice.InvoiceType.Purchases,
                                    -downpaymentPrice);

                                var tab_main = UIHelpers.FindChild<TabControl>(this.Tag as Page, "tabMenu");

                                if (tab_main != null)
                                {
                                    TabItem matchingItem =
                                        tab_main.Items.Cast<TabItem>()
                                            .Where(item => item.Tag.ToString() == "Order")
                                            .FirstOrDefault();

                                    tab_main.SelectedItem = matchingItem;
                                }
                            }
                        }
                    }
                    else
                    {
                        if (totalPrice > GameObject.GetInstance().HumanAirline.Money)
                        {
                            WPFMessageBox.Show(
                                Translator.GetInstance().GetString("MessageBox", "2001"),
                                Translator.GetInstance().GetString("MessageBox", "2001", "message"),
                                WPFMessageBoxButtons.Ok);
                        }
                        else
                        {
                            if (this.Orders.Orders.Sum(o => o.Amount) > 0)
                            {
                                WPFMessageBoxResult result =
                                    WPFMessageBox.Show(
                                        Translator.GetInstance().GetString("MessageBox", "2008"),
                                        string.Format(
                                            Translator.GetInstance().GetString("MessageBox", "2008", "message"),
                                            totalPrice),
                                        WPFMessageBoxButtons.YesNo);

                                if (result == WPFMessageBoxResult.Yes)
                                {
                                    this.orderAirliners(
                                        contractedOrder ? GameObject.GetInstance().HumanAirline.Contract.Discount : 0);

                                    var tab_main = UIHelpers.FindChild<TabControl>(this.Tag as Page, "tabMenu");

                                    if (tab_main != null)
                                    {
                                        TabItem matchingItem =
                                            tab_main.Items.Cast<TabItem>()
                                                .Where(item => item.Tag.ToString() == "Order")
                                                .FirstOrDefault();

                                        tab_main.SelectedItem = matchingItem;
                                    }
                                }

                                if (contractedOrder)
                                {
                                    GameObject.GetInstance().HumanAirline.Contract.PurchasedAirliners +=
                                        this.Orders.Orders.Sum(o => o.Amount);
                                }
                            }
                        }
                    }
                }
            }
        }
 public static void ShowPopUp(Airliner airliner1, Airliner airliner2)
 {
     PopUpWindow window = new PopUpCompareAirliners(airliner1,airliner2);
     window.ShowDialog();
 }
 public void TestCleanup()
 {
     this.passengerAirliner = null;
     Setup.ClearLists();
 }
        public static object ShowPopUp(Airliner airliner)
        {
            PopUpWindow window = new PopUpAirlinerConfiguration(airliner);
            window.ShowDialog();

            return window.Selected;
        }
 //buys an airliner to an airline
 public static FleetAirliner BuyAirliner(Airline airline, Airliner airliner, Airport airport)
 {
     return BuyAirliner(airline, airliner, airport, 0);
 }
Пример #19
0
        public static void AddAirliner(Airliner airliner)
        {
            lock (_airliners)
            {
                //if (airliners.Exists(a => a.ID == airliner.ID))
                //  throw new Exception("Airliner element already exists exception");

                _airliners.Add(airliner);
            }
        }
        public static FleetAirliner BuyAirliner(Airline airline, Airliner airliner, Airport airport, double discount)
        {
            FleetAirliner fAirliner = AddAirliner(airline, airliner, airport, false);

            double price = airliner.GetPrice()*((100 - discount)/100);

            AddAirlineInvoice(airline, GameObject.GetInstance().GameTime, Invoice.InvoiceType.Purchases, -price);

            return fAirliner;
        }
        public static void LoadGame(string name)
        {
            if (string.IsNullOrEmpty(name))
            {
                WPFMessageBoxResult result = WPFMessageBox.Show(
                    Translator.GetInstance().GetString("MessageBox", "101"),
                    Translator.GetInstance().GetString("MessageBox", "101", "message"),
                    WPFMessageBoxButtons.Ok);
                return;
            }
            string fileName = AppSettings.GetCommonApplicationDataPath() + "\\saves\\" + name + ".sav";

            var doc = new XmlDocument();

            using (var fs = new FileStream(fileName, FileMode.Open))
            {
                Stream s = new GZipStream(fs, CompressionMode.Decompress);
                doc.Load(s);
                s.Close();
            }
            //doc.Load(AppSettings.getDataPath() + "\\saves\\" + name + ".xml");
            XmlElement root = doc.DocumentElement;

            if (root != null)
            {
                DateTime gameTime = DateTime.Parse(root.Attributes["time"].Value, new CultureInfo("de-DE"));
                GameObject.GetInstance().GameTime = gameTime;
            }

            if (root != null)
            {
                XmlNodeList tailnumbersList = root.SelectNodes("//tailnumbers/tailnumber");

                if (tailnumbersList != null)
                    foreach (XmlElement tailnumberNode in tailnumbersList)
                    {
                        Country country = Countries.GetCountry(tailnumberNode.Attributes["country"].Value);

                        if (country != null)
                        {
                            country.TailNumbers.LastTailNumber = tailnumberNode.Attributes["value"].Value;
                        }
                    }
            }

            if (root != null)
            {
                XmlNodeList airlinerTypesList = root.SelectNodes("//airlinertypes/airlinertype");

                if (airlinerTypesList != null)
                    foreach (XmlElement airlinerTypeNode in airlinerTypesList)
                    {
                        var airlinerType =
                            (AirlinerType.TypeOfAirliner)
                            Enum.Parse(typeof (AirlinerType.TypeOfAirliner), airlinerTypeNode.Attributes["type"].Value);
                        AirlinerType baseType = AirlinerTypes.GetType(airlinerTypeNode.Attributes["basetype"].Value);
                        string airlinerTypeName = airlinerTypeNode.Attributes["name"].Value;

                        AirlinerType type = null;

                        if (airlinerType == AirlinerType.TypeOfAirliner.Passenger)
                        {
                            int cabincrew = Convert.ToInt16(airlinerTypeNode.Attributes["cabincrew"].Value);
                            int passengers = Convert.ToInt16(airlinerTypeNode.Attributes["passengers"].Value);
                            int maxclasses = Convert.ToInt16(airlinerTypeNode.Attributes["maxclasses"].Value);

                            type = new AirlinerPassengerType(
                                baseType.Manufacturer,
                                airlinerTypeName,
                                "",
                                passengers,
                                baseType.CockpitCrew,
                                cabincrew,
                                0,
                                0,
                                baseType.Wingspan,
                                baseType.Length,
                                baseType.Weight,
                                0,
                                baseType.Price,
                                maxclasses,
                                0,
                                baseType.FuelCapacity,
                                baseType.Body,
                                baseType.RangeType,
                                baseType.Engine,
                                baseType.Produced,
                                baseType.ProductionRate,
                                false,
                                false);
                        }
                        if (airlinerType == AirlinerType.TypeOfAirliner.Cargo)
                        {
                            double cargo = Convert.ToDouble(
                                airlinerTypeNode.Attributes["cargo"].Value,
                                new CultureInfo("de-DE", false));
                            type = new AirlinerCargoType(
                                baseType.Manufacturer,
                                airlinerTypeName,
                                "",
                                baseType.CockpitCrew,
                                cargo,
                                0,
                                0,
                                baseType.Wingspan,
                                baseType.Length,
                                baseType.Weight,
                                0,
                                baseType.Price,
                                0,
                                baseType.FuelCapacity,
                                baseType.Body,
                                baseType.RangeType,
                                baseType.Engine,
                                baseType.Produced,
                                baseType.ProductionRate,
                                false,
                                false);
                        }
                        if (type != null)
                        {
                            type.BaseType = baseType;

                            AirlinerTypes.AddType(type);
                        }
                    }
            }

            Airliners.Clear();

            if (root != null)
            {
                XmlNodeList airlinersList = root.SelectNodes("//airliners/airliner");

                if (airlinersList != null)
                    Parallel.For(
                        0,
                        airlinersList.Count,
                        i => //foreach (XmlElement airlinerNode in airlinersList)
                            {
                                var airlinerNode = (XmlElement) airlinersList[i];
                                AirlinerType type = AirlinerTypes.GetType(airlinerNode.Attributes["type"].Value);

                                if (type != null)
                                {
                                    string tailnumber = airlinerNode.Attributes["tailnumber"].Value;
                                    string id = airlinerNode.HasAttribute("id") ? airlinerNode.Attributes["id"].Value : tailnumber;

                                    string last_service = airlinerNode.Attributes["last_service"].Value;
                                    DateTime built = DateTime.Parse(
                                        airlinerNode.Attributes["built"].Value,
                                        new CultureInfo("de-DE", false));
                                    double flown = Convert.ToDouble(
                                        airlinerNode.Attributes["flown"].Value,
                                        new CultureInfo("de-DE", false));
                                    double damaged = Convert.ToDouble(
                                        airlinerNode.Attributes["damaged"].Value,
                                        new CultureInfo("de-DE", false));

                                    var airliner = new Airliner(id, type, tailnumber, built) {Condition = damaged, Flown = flown};
                                    airliner.ClearAirlinerClasses();

                                    XmlNodeList airlinerClassList = airlinerNode.SelectNodes("classes/class");

                                    if (airlinerClassList != null)
                                        foreach (XmlElement airlinerClassNode in airlinerClassList)
                                        {
                                            var airlinerClassType =
                                                (AirlinerClass.ClassType)
                                                Enum.Parse(
                                                    typeof (AirlinerClass.ClassType),
                                                    airlinerClassNode.Attributes["type"].Value);
                                            int airlinerClassSeating = Convert.ToInt16(airlinerClassNode.Attributes["seating"].Value);

                                            var aClass = new AirlinerClass(airlinerClassType, airlinerClassSeating);
                                            // chs, 2011-13-10 added for loading of airliner facilities
                                            XmlNodeList airlinerClassFacilitiesList =
                                                airlinerClassNode.SelectNodes("facilities/facility");
                                            if (airlinerClassFacilitiesList != null)
                                                foreach (XmlElement airlinerClassFacilityNode in airlinerClassFacilitiesList)
                                                {
                                                    var airlinerFacilityType =
                                                        (AirlinerFacility.FacilityType)
                                                        Enum.Parse(
                                                            typeof (AirlinerFacility.FacilityType),
                                                            airlinerClassFacilityNode.Attributes["type"].Value);

                                                    AirlinerFacility aFacility = AirlinerFacilities.GetFacility(
                                                        airlinerFacilityType,
                                                        airlinerClassFacilityNode.Attributes["uid"].Value);
                                                    aClass.ForceSetFacility(aFacility);
                                                }

                                            airliner.AddAirlinerClass(aClass);
                                        }

                                    Airliners.AddAirliner(airliner);
                                }
                            });
            }

            Airlines.Clear();

            if (root != null)
            {
                XmlNodeList airlinesList = root.SelectNodes("//airlines/airline[@subsidiary='False']");

                if (airlinesList != null)
                    foreach (XmlElement airlineNode in airlinesList)
                    {
                        LoadAirline(airlineNode);
                    }
            }

            if (root != null)
            {
                XmlNodeList subsidiaryList = root.SelectNodes("//airlines/airline[@subsidiary='True']");

                if (subsidiaryList != null)
                    foreach (XmlElement airlineNode in subsidiaryList)
                    {
                        LoadAirline(airlineNode);
                    }
            }

            if (root != null)
            {
                XmlNodeList airportsList = root.SelectNodes("//airports/airport");

                var airportsToKeep = new List<Airport>();

                if (airportsList != null)
                    foreach (XmlElement airportNode in airportsList)
                    {
                        Airport airport = Airports.GetAirportFromID(airportNode.Attributes["id"].Value);
                        airportsToKeep.Add(airport);

                        /*
                  *   XmlElement airportPaxNode = xmlDoc.CreateElement("paxvalue");
                    airportPaxNode.SetAttribute("from", paxValue.FromYear.ToString());
                    airportPaxNode.SetAttribute("to", paxValue.ToYear.ToString());
                    airportPaxNode.SetAttribute("size", paxValue.Size.ToString());
                    airportPaxNode.SetAttribute("pax", paxValue.Pax.ToString());
                    airportPaxNode.SetAttribute("inflationbefore", paxValue.InflationBeforeYear.ToString());
                    airportPaxNode.SetAttribute("inflationafter", paxValue.InflationAfterYear.ToString());
            */

                        airport.Income = Convert.ToInt64(airportNode.Attributes["income"].Value);

                        airport.Profile.PaxValues.Clear();

                        XmlNodeList paxvaluesList = airportNode.SelectNodes("paxvalues/paxvalue");

                        foreach (XmlElement paxElement in paxvaluesList)
                        {
                            int fromYear = Convert.ToInt16(paxElement.Attributes["from"].Value);
                            int toYear = Convert.ToInt16(paxElement.Attributes["to"].Value);
                            var airportSize =
                                (GeneralHelpers.Size)
                                Enum.Parse(typeof (GeneralHelpers.Size), paxElement.Attributes["size"].Value);
                            double pax = Convert.ToDouble(paxElement.Attributes["pax"].Value);
                            double inflationBefore = Convert.ToDouble(paxElement.Attributes["inflationbefore"].Value);
                            double inflationAfter = Convert.ToDouble(paxElement.Attributes["inflationafter"].Value);

                            var paxValue = new PaxValue(fromYear, toYear, airportSize, pax) {InflationAfterYear = inflationAfter, InflationBeforeYear = inflationBefore};

                            airport.Profile.PaxValues.Add(paxValue);
                        }

                        XmlNodeList runwaysList = airportNode.SelectNodes("runways/runway");

                        foreach (XmlElement runwayElement in runwaysList)
                        {
                            string runwayName = runwayElement.Attributes["name"].Value;
                            long runwayLenght = Convert.ToInt64(runwayElement.Attributes["lenght"].Value);
                            var runwaySurface =
                                (Runway.SurfaceType)
                                Enum.Parse(typeof (Runway.SurfaceType), runwayElement.Attributes["surface"].Value);
                            DateTime runwayDate = DateTime.Parse(
                                runwayElement.Attributes["date"].Value,
                                new CultureInfo("de-DE", false));

                            airport.Runways.Add(new Runway(runwayName, runwayLenght, Runway.RunwayType.Regular, runwaySurface, runwayDate, false));
                        }

                        XmlNodeList airportHubsList = airportNode.SelectNodes("hubs/hub");
                        // airport.Hubs.Clear();

                        foreach (XmlElement airportHubElement in airportHubsList)
                        {
                            Airline airline = Airlines.GetAirline(airportHubElement.Attributes["airline"].Value);
                            // airport.Hubs.Add(new Hub(airline,null));
                        }

                        XmlNodeList airportWeatherList = airportNode.SelectNodes("weathers/weather");

                        for (int i = 0; i < airportWeatherList.Count; i++)
                        {
                            var airportWeatherElement = airportWeatherList[i] as XmlElement;

                            DateTime weatherDate = DateTime.Parse(
                                airportWeatherElement.Attributes["date"].Value,
                                new CultureInfo("de-DE", false));
                            var windDirection =
                                (Weather.WindDirection)
                                Enum.Parse(
                                    typeof (Weather.WindDirection),
                                    airportWeatherElement.Attributes["direction"].Value);
                            var windSpeed =
                                (Weather.eWindSpeed)
                                Enum.Parse(typeof (Weather.eWindSpeed), airportWeatherElement.Attributes["windspeed"].Value);
                            Weather.CloudCover cover = airportWeatherElement.HasAttribute("cover")
                                                           ? (Weather.CloudCover)
                                                             Enum.Parse(typeof (Weather.CloudCover), airportWeatherElement.Attributes["cover"].Value)
                                                           : Weather.CloudCover.Clear;
                            Weather.Precipitation precip = airportWeatherElement.HasAttribute("precip")
                                                               ? (Weather.Precipitation)
                                                                 Enum.Parse(typeof (Weather.Precipitation), airportWeatherElement.Attributes["precip"].Value)
                                                               : Weather.Precipitation.None;
                            double temperatureLow = airportWeatherElement.HasAttribute("temperatureLow")
                                                        ? Convert.ToDouble(
                                                            airportWeatherElement.Attributes["temperaturelow"].Value,
                                                            new CultureInfo("de-DE", false))
                                                        : 0;
                            double temperatureHigh = airportWeatherElement.HasAttribute("temperatureHigh")
                                                         ? Convert.ToDouble(
                                                             airportWeatherElement.Attributes["temperaturehigh"].Value,
                                                             new CultureInfo("de-DE", false))
                                                         : 20;

                            XmlNodeList airportTemperatureList = airportWeatherElement.SelectNodes("temperatures/temperature");
                            var temperatures = new HourlyWeather[airportTemperatureList.Count];

                            int t = 0;
                            foreach (XmlElement airportTemperatureNode in airportTemperatureList)
                            {
                                double hourlyTemperature = Convert.ToDouble(
                                    airportTemperatureNode.Attributes["temp"].Value,
                                    new CultureInfo("de-DE", false));
                                var hourlyCover =
                                    (Weather.CloudCover)
                                    Enum.Parse(typeof (Weather.CloudCover), airportTemperatureNode.Attributes["cover"].Value);
                                var hourlyPrecip =
                                    (Weather.Precipitation)
                                    Enum.Parse(
                                        typeof (Weather.Precipitation),
                                        airportTemperatureNode.Attributes["precip"].Value);
                                var hourlyWindspeed =
                                    (Weather.eWindSpeed)
                                    Enum.Parse(
                                        typeof (Weather.eWindSpeed),
                                        airportTemperatureNode.Attributes["windspeed"].Value);
                                var hourlyDirection =
                                    (Weather.WindDirection)
                                    Enum.Parse(
                                        typeof (Weather.WindDirection),
                                        airportTemperatureNode.Attributes["direction"].Value);

                                temperatures[t] = new HourlyWeather(
                                    hourlyTemperature,
                                    hourlyCover,
                                    hourlyPrecip,
                                    hourlyWindspeed,
                                    hourlyDirection);
                                t++;
                            }

                            airport.Weather[i] = new Weather(
                                weatherDate,
                                windSpeed,
                                windDirection,
                                cover,
                                precip,
                                temperatures,
                                temperatureLow,
                                temperatureHigh);
                        }

                        XmlNodeList airportStatList = airportNode.SelectNodes("stats/stat");

                        foreach (XmlElement airportStatNode in airportStatList)
                        {
                            int year = Convert.ToInt32(airportStatNode.Attributes["year"].Value);
                            Airline airline = Airlines.GetAirline(airportStatNode.Attributes["airline"].Value);
                            string statType = airportStatNode.Attributes["type"].Value;
                            int statValue = Convert.ToInt32(airportStatNode.Attributes["value"].Value);
                            airport.Statistics.SetStatisticsValue(
                                year,
                                airline,
                                StatisticsTypes.GetStatisticsType(statType),
                                statValue);
                        }

                        XmlNodeList airportFacilitiesList = airportNode.SelectNodes("facilities/facility");
                        airport.ClearFacilities();

                        foreach (XmlElement airportFacilityNode in airportFacilitiesList)
                        {
                            Airline airline = Airlines.GetAirline(airportFacilityNode.Attributes["airline"].Value);
                            AirportFacility airportFacility =
                                AirportFacilities.GetFacility(airportFacilityNode.Attributes["name"].Value);
                            DateTime finishedDate = DateTime.Parse(
                                airportFacilityNode.Attributes["finished"].Value,
                                new CultureInfo("de-DE", false));

                            airport.AddAirportFacility(airline, airportFacility, finishedDate);
                        }
                        airport.Terminals.Clear();

                        XmlNodeList terminalsList = airportNode.SelectNodes("terminals/terminal");

                        foreach (XmlElement terminalNode in terminalsList)
                        {
                            DateTime deliveryDate = DateTime.Parse(
                                terminalNode.Attributes["delivery"].Value,
                                new CultureInfo("de-DE", false));
                            Airline owner = Airlines.GetAirline(terminalNode.Attributes["owner"].Value);
                            string terminalName = terminalNode.Attributes["name"].Value;
                            int gates = Convert.ToInt32(terminalNode.Attributes["totalgates"].Value);

                            var terminal = new Terminal(airport, owner, terminalName, gates, deliveryDate, Terminal.TerminalType.Passenger);
                            terminal.Gates.Clear();

                            XmlNodeList airportGatesList = terminalNode.SelectNodes("gates/gate");

                            foreach (XmlElement airportGateNode in airportGatesList)
                            {
                                DateTime gateDeliveryDate = DateTime.Parse(
                                    airportGateNode.Attributes["delivery"].Value,
                                    new CultureInfo("de-DE", false));
                                var gate = new Gate(gateDeliveryDate);

                                terminal.Gates.AddGate(gate);
                            }

                            airport.AddTerminal(terminal);
                        }
                        airport.ClearAirlineContracts();

                        XmlNodeList contractsList = airportNode.SelectNodes("contracts/contract");

                        foreach (XmlElement contractNode in contractsList)
                        {
                            Airline contractAirline = Airlines.GetAirline(contractNode.Attributes["airline"].Value);
                            int contractLength = Convert.ToInt16(contractNode.Attributes["length"].Value);
                            DateTime contractDate = DateTime.Parse(
                                contractNode.Attributes["date"].Value,
                                new CultureInfo("de-DE", false));
                            int contractGates = Convert.ToInt16(contractNode.Attributes["gates"].Value);
                            double contractPayment = Convert.ToDouble(
                                contractNode.Attributes["payment"].Value,
                                new CultureInfo("de-DE", false));
                            Boolean contractExclusive = Convert.ToBoolean(contractNode.Attributes["exclusive"].Value);
                            Terminal contractTerminal = contractNode.HasAttribute("terminal")
                                                            ? airport.Terminals.AirportTerminals.Find(
                                                                t => t.Name == contractNode.Attributes["terminal"].Value)
                                                            : null;

                            var contract = new AirportContract(
                                contractAirline,
                                airport,
                                AirportContract.ContractType.Full,
                                Terminal.TerminalType.Passenger,
                                contractDate,
                                contractGates,
                                contractLength,
                                contractPayment,
                                true,
                                false,
                                contractExclusive,
                                contractTerminal);
                            AirportHelpers.AddAirlineContract(contract);
                        }
                    }

                Airports.RemoveAirports(a => !airportsToKeep.Contains(a));
            }

            XmlNodeList airportDestinationsList = root.SelectNodes("//airportdestinations/airportdestination");

            foreach (XmlElement airportDestinationElement in airportDestinationsList)
            {
                Airport targetAirport = Airports.GetAirport(airportDestinationElement.Attributes["id"].Value);

                if (targetAirport != null)
                {
                    targetAirport.ClearDestinationPassengers();

                    XmlNodeList destinationsList = airportDestinationElement.SelectNodes("destinations/destination");

                    Parallel.For(
                        0,
                        destinationsList.Count,
                        i => //foreach (XmlElement destinationElement in destinationsList)
                            {
                                var destinationElement = (XmlElement) destinationsList[i];
                                Airport destAirport = Airports.GetAirport(destinationElement.Attributes["id"].Value);

                                if (destAirport != null)
                                {
                                    ushort rate = ushort.Parse(destinationElement.Attributes["rate"].Value);
                                    long destPassengers = Convert.ToInt64(destinationElement.Attributes["passengers"].Value);

                                    targetAirport.AddPassengerDestinationStatistics(destAirport, destPassengers);
                                    targetAirport.AddDestinationPassengersRate(
                                        new DestinationDemand(destAirport.Profile.IATACode, rate));

                                    if (destinationElement.HasAttribute("cargo"))
                                    {
                                        targetAirport.AddDestinationCargoRate(
                                            new DestinationDemand(
                                                destAirport.Profile.IATACode,
                                                ushort.Parse(destinationElement.Attributes["cargo"].Value)));
                                        targetAirport.AddCargoDestinationStatistics(
                                            destAirport,
                                            Convert.ToDouble(
                                                destinationElement.Attributes["cargostats"].Value,
                                                new CultureInfo("de-DE", false)));
                                    }
                                }
                            });
                }
            }
            Instructors.Clear();

            XmlNodeList instructorsList = root.SelectNodes("//instructors/instructor");

            foreach (XmlElement instructorNode in instructorsList)
            {
                string firstname = instructorNode.Attributes["firstname"].Value;
                string lastname = instructorNode.Attributes["lastname"].Value;
                DateTime birthdate = DateTime.Parse(
                    instructorNode.Attributes["birthdate"].Value,
                    new CultureInfo("de-DE", false));
                Town town = Towns.GetTown(instructorNode.Attributes["town"].Value);
                //Pilot.PilotRating rating = (Pilot.PilotRating)Enum.Parse(typeof(Pilot.PilotRating), instructorNode.Attributes["rating"].Value);
                string id = instructorNode.Attributes["id"].Value;

                var instructor = new Instructor(
                    new PilotProfile(firstname, lastname, birthdate, town),
                    PilotRatings.GetRating("A"));

                if (id != "-")
                {
                    FlightSchool fs =
                        Airlines.GetAllAirlines()
                                .SelectMany(a => a.FlightSchools).FirstOrDefault(f => f.ID == id);
                    instructor.FlightSchool = fs;
                    fs.AddInstructor(instructor);
                }

                XmlNodeList studentsList = instructorNode.SelectNodes("students/student");

                foreach (XmlElement studentNode in studentsList)
                {
                    PilotStudent student =
                        instructor.FlightSchool.Students.Find(
                            s => s.Profile.Name == studentNode.Attributes["name"].Value);
                    student.Instructor = instructor;
                    instructor.AddStudent(student);
                }

                Instructors.AddInstructor(instructor);
            }

            if (Instructors.GetInstructors().Count == 0)
            {
                GeneralHelpers.CreateInstructors(75*Airlines.GetAllAirlines().Count);
            }

            Pilots.Clear();

            XmlNodeList pilotsList = root.SelectNodes("//pilots/pilot");

            foreach (XmlElement pilotNode in pilotsList)
            {
                string firstname = pilotNode.Attributes["firstname"].Value;
                string lastname = pilotNode.Attributes["lastname"].Value;
                DateTime birthdate = DateTime.Parse(
                    pilotNode.Attributes["birthdate"].Value,
                    new CultureInfo("de-DE", false));
                Town town = Towns.GetTown(pilotNode.Attributes["town"].Value);
                DateTime educationdate = DateTime.Parse(
                    pilotNode.Attributes["education"].Value,
                    new CultureInfo("de-DE", false));

                //Pilot.PilotRating rating = (Pilot.PilotRating)Enum.Parse(typeof(Pilot.PilotRating), pilotNode.Attributes["rating"].Value);

                var pilot = new Pilot(
                    new PilotProfile(firstname, lastname, birthdate, town),
                    educationdate,
                    PilotRatings.GetRating("B"));

                if (pilotNode.Attributes["airline"].Value != "-")
                {
                    Airline pilotAirline = Airlines.GetAirline(pilotNode.Attributes["airline"].Value);
                    DateTime airlinesigneddate = DateTime.Parse(
                        pilotNode.Attributes["airlinesigned"].Value,
                        new CultureInfo("de-DE", false));

                    pilotAirline.AddPilot(pilot);
                    pilot.AirlineSignedDate = airlinesigneddate;

                    if (pilotNode.Attributes["airliner"].Value != "-")
                    {
                        FleetAirliner airliner =
                            pilotAirline.Fleet.Find(f => f.Airliner.ID == pilotNode.Attributes["airliner"].Value);

                        if (airliner != null)
                        {
                            pilot.Airliner = airliner;
                            airliner.AddPilot(pilot);
                        }
                    }
                }

                Pilots.AddPilot(pilot);
            }

            if (Pilots.GetNumberOfPilots() == 0)
            {
                var rnd = new Random();

                GeneralHelpers.CreatePilots(100*Airlines.GetAllAirlines().Count);

                foreach (FleetAirliner airliner in Airlines.GetAllAirlines().SelectMany(a => a.Fleet))
                {
                    Pilot pilot = Pilots.GetPilots()[rnd.Next(Pilots.GetNumberOfPilots())];
                    airliner.Airliner.Airline.AddPilot(pilot);
                    pilot.Airliner = airliner;
                    airliner.AddPilot(pilot);
                }
            }

            Alliances.Clear();

            XmlNodeList alliancesList = root.SelectNodes("//alliances/alliance");

            foreach (XmlElement allianceNode in alliancesList)
            {
                string allianceName = allianceNode.Attributes["name"].Value;
                DateTime formationDate = DateTime.Parse(
                    allianceNode.Attributes["formation"].Value,
                    new CultureInfo("de-DE"));
                Airport allianceHeadquarter = Airports.GetAirport(allianceNode.Attributes["headquarter"].Value);

                var alliance = new Alliance(formationDate, allianceName, allianceHeadquarter);

                XmlNodeList membersList = allianceNode.SelectNodes("members/member");

                foreach (XmlElement memberNode in membersList)
                {
                    Airline allianceMember = Airlines.GetAirline(memberNode.Attributes["airline"].Value);
                    DateTime joinedDate = DateTime.Parse(
                        memberNode.Attributes["joined"].Value,
                        new CultureInfo("de-DE"));

                    if (allianceMember != null)
                    {
                        alliance.AddMember(new AllianceMember(allianceMember, joinedDate));
                    }
                }

                XmlNodeList pendingsList = allianceNode.SelectNodes("pendings/pending");

                foreach (XmlElement pendingNode in pendingsList)
                {
                    Airline pendingAirline = Airlines.GetAirline(pendingNode.Attributes["airline"].Value);
                    DateTime pendingDate = DateTime.Parse(
                        pendingNode.Attributes["date"].Value,
                        new CultureInfo("de-DE"));
                    var pendingType =
                        (PendingAllianceMember.AcceptType)
                        Enum.Parse(typeof (PendingAllianceMember.AcceptType), pendingNode.Attributes["type"].Value);

                    alliance.AddPendingMember(
                        new PendingAllianceMember(pendingDate, alliance, pendingAirline, pendingType));
                }

                Alliances.AddAlliance(alliance);
            }
            Configurations.Clear();

            XmlNodeList configurationsList = root.SelectNodes("//configurations/configuration");

            foreach (XmlElement confElement in configurationsList)
            {
                string confName = confElement.Attributes["name"].Value;
                string confid = confElement.Attributes["id"].Value;
                Boolean standard = Convert.ToBoolean(confElement.Attributes["standard"].Value);

                int minimumSeats = Convert.ToInt16(confElement.Attributes["minimumseats"].Value);

                var configuration = new AirlinerConfiguration(confName, minimumSeats, standard) {ID = confid};

                XmlNodeList classesList = confElement.SelectNodes("classes/class");

                foreach (XmlElement classElement in classesList)
                {
                    int seating = Convert.ToInt16(classElement.Attributes["seating"].Value);
                    int regularseating = Convert.ToInt16(classElement.Attributes["regularseating"].Value);
                    var classType =
                        (AirlinerClass.ClassType)
                        Enum.Parse(typeof (AirlinerClass.ClassType), classElement.Attributes["type"].Value);

                    var classConf = new AirlinerClassConfiguration(classType, seating, regularseating);
                    foreach (
                        AirlinerFacility.FacilityType facType in Enum.GetValues(typeof (AirlinerFacility.FacilityType)))
                    {
                        string facUid = classElement.Attributes[facType.ToString()].Value;

                        classConf.AddFacility(AirlinerFacilities.GetFacility(facType, facUid));
                    }

                    configuration.AddClassConfiguration(classConf);
                }
                Configurations.AddConfiguration(configuration);
            }

            XmlNodeList routeConfigurationsList =
                root.SelectNodes("//routeclassesconfigurations/routeclassesconfiguration");

            foreach (XmlElement confElement in routeConfigurationsList)
            {
                string routeConfName = confElement.Attributes["name"].Value;
                string confid = confElement.Attributes["id"].Value;
                Boolean standard = Convert.ToBoolean(confElement.Attributes["standard"].Value);

                XmlNodeList classesList = confElement.SelectNodes("classes/class");

                var classesConfiguration = new RouteClassesConfiguration(routeConfName, standard) {ID = confid};

                foreach (XmlElement classElement in classesList)
                {
                    var classType =
                        (AirlinerClass.ClassType)
                        Enum.Parse(typeof (AirlinerClass.ClassType), classElement.Attributes["type"].Value);

                    var classConf = new RouteClassConfiguration(classType);
                    foreach (RouteFacility.FacilityType facType in Enum.GetValues(typeof (RouteFacility.FacilityType)))
                    {
                        if (classElement.HasAttribute(facType.ToString()))
                        {
                            string facilityName = classElement.Attributes[facType.ToString()].Value;

                            classConf.AddFacility(
                                RouteFacilities.GetFacilities(facType).Find(f => f.Name == facilityName));
                        }
                    }

                    classesConfiguration.AddClass(classConf);
                }

                Configurations.AddConfiguration(classesConfiguration);
            }

            var difficultyNode = (XmlElement) root.SelectSingleNode("//difficulty");
            string difficultyName = difficultyNode.Attributes["name"].Value;
            double moneyLevel = Convert.ToDouble(
                difficultyNode.Attributes["money"].Value,
                new CultureInfo("de-DE", false));
            double priceLevel = Convert.ToDouble(
                difficultyNode.Attributes["price"].Value,
                new CultureInfo("de-DE", false));
            double loanLevel = Convert.ToDouble(
                difficultyNode.Attributes["loan"].Value,
                new CultureInfo("de-DE", false));
            double passengersLevel = Convert.ToDouble(
                difficultyNode.Attributes["passengers"].Value,
                new CultureInfo("de-DE", false));
            double aiLevel = Convert.ToDouble(difficultyNode.Attributes["ai"].Value, new CultureInfo("de-DE", false));

            GameObject.GetInstance().Difficulty = new DifficultyLevel(
                difficultyName,
                moneyLevel,
                loanLevel,
                passengersLevel,
                priceLevel,
                aiLevel,
                1);

            var scenarioNode = (XmlElement) root.SelectSingleNode("//scenario");

            if (scenarioNode != null)
            {
                Scenario scenario = Scenarios.GetScenario(scenarioNode.Attributes["name"].Value);

                var so = new ScenarioObject(scenario) {IsSuccess = Convert.ToBoolean(scenarioNode.Attributes["success"].Value)};

                if (scenarioNode.HasAttribute("failed"))
                {
                    so.ScenarioFailed = scenario.Failures.Find(f => f.ID == scenarioNode.Attributes["failed"].Value);
                }

                XmlNodeList failuresList = scenarioNode.SelectNodes("failures/failure");

                foreach (XmlElement failureNode in failuresList)
                {
                    ScenarioFailure failure = scenario.Failures.Find(f => f.ID == failureNode.Attributes["id"].Value);
                    int failureCount = Convert.ToInt16(failureNode.Attributes["count"].Value);
                    DateTime lastFailureTime = DateTime.Parse(
                        failureNode.Attributes["lastfailuretime"].Value,
                        new CultureInfo("de-DE", false));

                    so.GetScenarioFailure(failure).LastFailureTime = lastFailureTime;
                    so.GetScenarioFailure(failure).Failures = failureCount;
                }

                GameObject.GetInstance().Scenario = so;
            }

            var gameSettingsNode = (XmlElement) root.SelectSingleNode("//gamesettings");

            GameObject.GetInstance().Name = gameSettingsNode.Attributes["name"].Value;

            Airline humanAirline = Airlines.GetAirline(gameSettingsNode.Attributes["human"].Value);
            GameObject.GetInstance().SetHumanAirline(humanAirline);

            Airline mainAirline = Airlines.GetAirline(gameSettingsNode.Attributes["mainairline"].Value);
            GameObject.GetInstance().MainAirline = mainAirline;

            double fuelPrice = Convert.ToDouble(
                gameSettingsNode.Attributes["fuelprice"].Value,
                new CultureInfo("de-DE", false));

            GameTimeZone timezone =
                TimeZones.GetTimeZones()
                         .Find(
                             gtz => gtz.UTCOffset == TimeSpan.Parse(gameSettingsNode.Attributes["timezone"].Value));
            GameObject.GetInstance().TimeZone = timezone;

            Infrastructure.Settings.GetInstance().MailsOnLandings =
                Convert.ToBoolean(gameSettingsNode.Attributes["mailonlandings"].Value);
            Infrastructure.Settings.GetInstance().MailsOnBadWeather =
                Convert.ToBoolean(gameSettingsNode.Attributes["mailonbadweather"].Value);

            Infrastructure.Settings.GetInstance().AirportCodeDisplay =
                (AirportCode)
                Enum.Parse(typeof (AirportCode), gameSettingsNode.Attributes["airportcode"].Value);
            if (gameSettingsNode.HasAttribute("minutesperturn"))
            {
                Infrastructure.Settings.GetInstance().MinutesPerTurn =
                    Convert.ToInt16(gameSettingsNode.Attributes["minutesperturn"].Value);
            }
            AppSettings.GetInstance().SetLanguage(Languages.GetLanguage(gameSettingsNode.Attributes["language"].Value));
            GameObject.GetInstance().DayRoundEnabled = Convert.ToBoolean(gameSettingsNode.Attributes["dayround"].Value);

            XmlNodeList itemsList = gameSettingsNode.SelectNodes("calendaritems/calendaritem");

            CalendarItems.Clear();

            foreach (XmlElement itemNode in itemsList)
            {
                var itemType =
                    (CalendarItem.ItemType) Enum.Parse(typeof (CalendarItem.ItemType), itemNode.Attributes["type"].Value);
                DateTime itemDate = DateTime.Parse(itemNode.Attributes["date"].Value, new CultureInfo("de-DE", false));
                string itemHeader = itemNode.Attributes["header"].Value;
                string itemSubject = itemNode.Attributes["subject"].Value;

                CalendarItems.AddCalendarItem(new CalendarItem(itemType, itemDate, itemHeader, itemSubject));
            }

            XmlNodeList newsList = gameSettingsNode.SelectNodes("news/new");
            GameObject.GetInstance().NewsBox.Clear();

            foreach (XmlElement newsNode in newsList)
            {
                DateTime newsDate = DateTime.Parse(newsNode.Attributes["date"].Value, new CultureInfo("de-DE", false));
                var newsType = (News.NewsType) Enum.Parse(typeof (News.NewsType), newsNode.Attributes["type"].Value);
                string newsSubject = newsNode.Attributes["subject"].Value;
                string newsBody = newsNode.Attributes["body"].Value;
                Boolean newsIsRead = Convert.ToBoolean(newsNode.Attributes["isread"].Value);

                var news = new News(newsType, newsDate, newsSubject, newsBody) {IsRead = newsIsRead};

                GameObject.GetInstance().NewsBox.AddNews(news);
            }
            /*
               foreach (Airline airline in Airlines.GetAllAirlines())
               {
                   foreach (Route route in airline.Routes)
                   {
                       Gate gate1 = route.Destination1.Terminals.getEmptyGate(airline);
                       Gate gate2 = route.Destination2.Terminals.getEmptyGate(airline);

                       if (gate1!=null) gate1.Route = route;
                       if (gate2!=null) gate2.Route = route;

                   }
               }

               */
        }
        public static FleetAirliner AddAirliner(Airline airline, Airliner airliner, Airport airport, Boolean leased)
        {
            if (Countries.GetCountryFromTailNumber(airliner.TailNumber).Name != airline.Profile.Country.Name)
            {
                lock (airline.Profile.Country.TailNumbers)
                {
                    airliner.TailNumber = airline.Profile.Country.TailNumbers.GetNextTailNumber();
                }
            }

            var fAirliner = new FleetAirliner(leased ? FleetAirliner.PurchasedType.Leased : FleetAirliner.PurchasedType.Bought, GameObject.GetInstance().GameTime, airline, airliner, airport);

            airline.AddAirliner(fAirliner);

            return fAirliner;
        }
Пример #23
0
 //adds an airliner to the airlines fleet
 public void AddAirliner(FleetAirliner.PurchasedType type, Airliner airliner, Airport homeBase)
 {
     AddAirliner(new FleetAirliner(type, GameObject.GetInstance().GameTime, this, airliner, homeBase));
 }
        //orders a number of airliners for an airline
        public static void OrderAirliners(Airline airline, List<AirlinerOrder> orders, Airport airport, DateTime deliveryDate, double discount)
        {
            Guid id = Guid.NewGuid();

            foreach (AirlinerOrder order in orders)
            {
                for (int i = 0; i < order.Amount; i++)
                {
                    var airliner = new Airliner(id.ToString(), order.Type, airline.Profile.Country.TailNumbers.GetNextTailNumber(), deliveryDate);
                    Airliners.AddAirliner(airliner);

                    const FleetAirliner.PurchasedType pType = FleetAirliner.PurchasedType.Bought;
                    airline.AddAirliner(pType, airliner, airport);

                    airliner.ClearAirlinerClasses();

                    foreach (AirlinerClass aClass in order.Classes)
                    {
                        var tClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity) {RegularSeatingCapacity = aClass.RegularSeatingCapacity};

                        foreach (AirlinerFacility facility in aClass.GetFacilities())
                            tClass.SetFacility(airline, facility);

                        airliner.AddAirlinerClass(tClass);
                    }
                }
            }

            int totalAmount = orders.Sum(o => o.Amount);
            double price = orders.Sum(o => o.Type.Price*o.Amount);

            double totalPrice = price*((1 - GeneralHelpers.GetAirlinerOrderDiscount(totalAmount)))*((100 - discount)/100);

            AddAirlineInvoice(airline, GameObject.GetInstance().GameTime, Invoice.InvoiceType.Purchases, -totalPrice);
        }
Пример #25
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);
                                    }
                                }
                            }
                        }
                    });
        }
        private void orderAirliners(Airport airport, double discount = 0)
        {
            DateTime deliveryDate = this.getDeliveryDate();

            Guid id = Guid.NewGuid();

            foreach (AirlinerTypeMVVM type in this.SelectedAirliners)
            {
                var airliner = new Airliner(
                    id.ToString(),
                    type.Type,
                    GameObject.GetInstance().HumanAirline.Profile.Country.TailNumbers.GetNextTailNumber(),
                    deliveryDate);

                EngineType engine = EngineTypes.GetStandardEngineType(type.Type,GameObject.GetInstance().GameTime.Year);

                if (engine != null)
                    airliner.EngineType = engine;

                Airliners.AddAirliner(airliner);

                var pType = FleetAirliner.PurchasedType.Bought;
                GameObject.GetInstance().HumanAirline.AddAirliner(pType, airliner, airport);

                airliner.ClearAirlinerClasses();

                AirlinerHelpers.CreateAirlinerClasses(airliner);

                foreach (AirlinerClass aClass in airliner.Classes)
                {
                    foreach (AirlinerFacility facility in aClass.GetFacilities())
                    {
                        aClass.SetFacility(GameObject.GetInstance().HumanAirline, facility);
                    }
                }

            }

            int totalAmount = this.SelectedAirliners.Count;
            double price = this.SelectedAirliners.Sum(a => a.Type.Price);

            double totalPrice = price * ((1 - GeneralHelpers.GetAirlinerOrderDiscount(totalAmount)))
                                * ((100 - discount) / 100);

            AirlineHelpers.AddAirlineInvoice(
                GameObject.GetInstance().HumanAirline,
                GameObject.GetInstance().GameTime,
                Invoice.InvoiceType.Purchases,
                -totalPrice);
        }