public DestinationFlight(Airline airline, RouteTimeTableEntry entry, DateTime time)
{
this.Airline = airline;
this.Entry = entry;
this.Time = time;
this.AirlinerType = this.Entry.Airliner.Airliner.Type;
}
/*! create a random airliner with a minimum range.
*/
private static Airliner CreateAirliner(double minRange)
{
Guid id = Guid.NewGuid();
List <AirlinerType> types = AirlinerTypes.GetTypes(delegate(AirlinerType t) { return(t.Range >= minRange && t.Produced.From.Year < GameObject.GetInstance().GameTime.Year&& t.Produced.To > GameObject.GetInstance().GameTime.AddYears(-30)); });
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 - 30), Math.Min(GameObject.GetInstance().GameTime.Year - 1, type.Produced.To.Year));
Airliner 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);
return(airliner);
}
private void cbAirliner_Checked(object sender, RoutedEventArgs e)
{
int maxNumberOfAirliners = this.AirlineFacility.ServiceLevel;
FleetAirliner airliner = (FleetAirliner)((CheckBox)sender).Tag;
if (this.AirlinersToMaintain.Count == 0 || (this.AirlinersToMaintain.Exists(a => a.Airliner.Type == airliner.Airliner.Type) && this.AirlinersToMaintain.Count + 1 <= maxNumberOfAirliners))
{
this.AirlinersToMaintain.Add(airliner);
AirlinerType type = this.AirlinersToMaintain[0].Airliner.Type;
if (this.Classes == null || this.Classes.Count == 0)
{
AirlinerClass eClass = new AirlinerClass(AirlinerClass.ClassType.Economy_Class, ((AirlinerPassengerType)type).MaxSeatingCapacity);
eClass.createBasicFacilities(null);
this.Classes.Add(eClass);
showClasses();
}
btnEquipped.IsEnabled = true;
btnApply.IsEnabled = true;
}
else
{
if (this.AirlinersToMaintain.Count == maxNumberOfAirliners)
{
WPFMessageBox.Show(Translator.GetInstance().GetString("MessageBox", "2901"), string.Format(Translator.GetInstance().GetString("MessageBox", "2901", "message"), maxNumberOfAirliners), WPFMessageBoxButtons.Ok);
}
((CheckBox)sender).IsChecked = false;
}
}
private void link_Click(object sender, RoutedEventArgs e)
{
AirlinerType type = this.AirlinersToMaintain[0].Airliner.Type;
if (this.Classes == null)
{
AirlinerClass eClass = new AirlinerClass(AirlinerClass.ClassType.Economy_Class, ((AirlinerPassengerType)type).MaxSeatingCapacity);
eClass.createBasicFacilities(null);
this.Classes.Add(eClass);
}
AirlinerClass aClass = (AirlinerClass)((Hyperlink)sender).Tag;
AirlinerClass newClass = (AirlinerClass)PopUpAirlinerClassConfiguration.ShowPopUp(aClass);
AirlinerClass economyClass = this.Classes.Find(c => c.Type == AirlinerClass.ClassType.Economy_Class);
if (newClass != null)
{
AirlinerClass airlinerClass = new AirlinerClass(newClass.Type, newClass.SeatingCapacity);
airlinerClass.RegularSeatingCapacity = newClass.RegularSeatingCapacity;
int seatingDiff = ((AirlinerPassengerType)type).MaxSeatingCapacity;
economyClass.RegularSeatingCapacity += seatingDiff;
AirlinerFacility seatingFacility = economyClass.getFacility(AirlinerFacility.FacilityType.Seat);
int extraSeats = (int)(seatingDiff / seatingFacility.SeatUses);
economyClass.SeatingCapacity += extraSeats;
}
}
public ScenarioAirlineRoute(Airport destination1, Airport destination2, AirlinerType airlinertype, int quantity)
{
this.Destination1 = destination1;
this.Destination2 = destination2;
this.AirlinerType = airlinertype;
this.Quantity = quantity;
}
public AirlinerOrderMVVM(AirlinerType type, AirlinerOrdersMVVM order, int amount = 1)
{
this.Type = type;
this.Order = order;
this.Amount = amount;
this._classes = new List <AirlinerClass>();
this.Homebases = new List <Airport>();
if (this.Type.TypeAirliner == AirlinerType.TypeOfAirliner.Passenger)
{
AirlinerClass eClass = new AirlinerClass(AirlinerClass.ClassType.Economy_Class, ((AirlinerPassengerType)type).MaxSeatingCapacity);
eClass.createBasicFacilities(null);
this.Classes.Add(eClass);
}
long minRunway = this.Type.MinRunwaylength;
//var homebases = GameObject.GetInstance().HumanAirline.Airports.FindAll(a => (a.hasContractType(GameObject.GetInstance().HumanAirline, AirportContract.ContractType.Full_Service) || a.getCurrentAirportFacility(GameObject.GetInstance().HumanAirline, AirportFacility.FacilityType.Service).TypeLevel > 0) && a.getMaxRunwayLength() >= minRunway);
var homebases = AirlineHelpers.GetHomebases(GameObject.GetInstance().HumanAirline, minRunway);
foreach (var homebase in homebases)
{
this.Homebases.Add(homebase);
}
}
/*!creates an airliner from a specific year
*/
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;
Airliner 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;
CreateAirlinerClasses(airliner);
return(airliner);
}
private void btnAddOrder_Click(object sender, RoutedEventArgs e)
{
AirlinerType type = (AirlinerType)cbTypes.SelectedItem;
int number = Convert.ToInt16(nudAirliners.Value);
WPFMessageBoxResult result = WPFMessageBox.Show(Translator.GetInstance().GetString("MessageBox", "2012"), string.Format(Translator.GetInstance().GetString("MessageBox", "2012", "message"), number, type.Name, this.Classes.Count), WPFMessageBoxButtons.YesNo);
if (result == WPFMessageBoxResult.Yes)
{
this.orders.Add(new AirlinerOrder(type, this.Classes, number, customConfiguration));
showOrders();
DateTime firstDeliveryDate = getDeliveryDate();
dpDate.DisplayDate = dpDate.DisplayDate > firstDeliveryDate ? dpDate.DisplayDate : firstDeliveryDate;
dpDate.SelectedDate = dpDate.SelectedDate > firstDeliveryDate ? dpDate.SelectedDate : firstDeliveryDate;
dpDate.BlackoutDates.Clear();
for (int i = 1; i < firstDeliveryDate.Day; i++)
{
dpDate.BlackoutDates.Add(new CalendarDateRange(new DateTime(firstDeliveryDate.Year, firstDeliveryDate.Month, i)));
}
}
}
private void cbStandardConfiguration_Checked(object sender, RoutedEventArgs e)
{
btnEquipped.IsEnabled = false;
btnApplyConfiguration.IsEnabled = false;
AirlinerType type = (AirlinerType)((CheckBox)sender).Tag;
Configuration airlinerTypeConfiguration = Configurations.GetConfigurations(Configuration.ConfigurationType.AirlinerType).Find(c => ((AirlinerTypeConfiguration)c).Airliner == type && ((AirlinerTypeConfiguration)c).Period.From <= GameObject.GetInstance().GameTime&& ((AirlinerTypeConfiguration)c).Period.To > GameObject.GetInstance().GameTime);
List <AirlinerClass> classes = new List <AirlinerClass>();
foreach (AirlinerClassConfiguration aClass in ((AirlinerTypeConfiguration)airlinerTypeConfiguration).Classes)
{
AirlinerClass airlinerClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity);
airlinerClass.RegularSeatingCapacity = aClass.RegularSeatingCapacity;
foreach (AirlinerFacility facility in aClass.getFacilities())
{
airlinerClass.setFacility(GameObject.GetInstance().HumanAirline, facility);
}
classes.Add(airlinerClass);
}
if (classes != null)
{
this.Classes = classes;
panelClasses.Children.Clear();
foreach (AirlinerClass aClass in this.Classes)
{
panelClasses.Children.Add(createAirlineClassLink(aClass));
}
}
}
public PopUpAirlinerSeatsConfiguration(AirlinerType type, List <AirlinerClass> classes)
{
this.FreeClassTypes = new ObservableCollection <AirlinerClass.ClassType>();
this.Classes = new ObservableCollection <AirlinerClassMVVM>();
this.Type = type;
AirlinerClass economyClass = classes.Find(c => c.Type == AirlinerClass.ClassType.Economy_Class);
foreach (AirlinerClass aClass in classes)
{
int maxseats = aClass.Type == AirlinerClass.ClassType.Economy_Class ? aClass.SeatingCapacity : economyClass.RegularSeatingCapacity - 1;
AirlinerClassMVVM nClass = new AirlinerClassMVVM(aClass.Type, aClass.SeatingCapacity, maxseats, aClass.Type != AirlinerClass.ClassType.Economy_Class);
this.Classes.Add(nClass);
foreach (AirlinerFacility facility in aClass.getFacilities())
{
nClass.Facilities.Where(f => f.Type == facility.Type).First().SelectedFacility = facility;
}
}
this.CanAddNewClass = this.Classes.Count < ((AirlinerPassengerType)this.Type).MaxAirlinerClasses;
if (this.Classes.Count < 3)
{
this.FreeClassTypes.Clear();
this.FreeClassTypes.Add(AirlinerClass.ClassType.Business_Class);
this.FreeClassTypes.Add(AirlinerClass.ClassType.First_Class);
}
InitializeComponent();
}
public static object ShowPopUp(AirlinerType type, List <AirlinerClass> classes)
{
PopUpWindow window = new PopUpAirlinerSeatsConfiguration(type, classes);
window.ShowDialog();
return(window.Selected);
}
private void nudAirliners_ValueChanged(object sender, RoutedPropertyChangedEventArgs <decimal> e)
{
AirlinerType type = (AirlinerType)cbTypes.SelectedItem;
int number = Convert.ToInt16(nudAirliners.Value);
txtPrice.Text = new ValueCurrencyConverter().Convert(type.Price * number).ToString(); //txtPrice.Text = string.Format("{0:C}", type.Price * number);
}
public PopUpAirlinerConfiguration(AirlinerType type, List <AirlinerClass> classes)
{
this.Classes = new List <AirlinerClass>(classes);
this.Type = type;
createPopUp();
}
private void btnEquipped_Click(object sender, RoutedEventArgs e)
{
AirlinerType type = this.AirlinersToMaintain[0].Airliner.Type;
List <AirlinerClass> classes = (List <AirlinerClass>)PopUpAirlinerConfiguration.ShowPopUp(type, this.Classes);
if (classes != null)
{
this.Classes = classes;
showClasses();
}
}
public PopUpAirlinerConfiguration(Airliner airliner)
{
this.Classes = new List <AirlinerClass>();
foreach (AirlinerClass aClass in airliner.Classes)
{
this.Classes.Add(aClass);
}
this.Type = airliner.Type;
createPopUp();
}
private void cbAircraft_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
AirlinerType type = (AirlinerType)((ComboBox)sender).SelectedItem;
if (this.AirportsList != null)
{
var source = this.AirportsList.Items as ICollectionView;
source.Filter = o =>
{
AirportMVVM a = o as AirportMVVM;
return(a != null && a.Airport.getMaxRunwayLength() >= type.MinRunwaylength || type.Manufacturer.Name == "Dummy");
};
}
}
private void cbAircraft_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
AirlinerType type = (AirlinerType)((ComboBox)sender).SelectedItem;
if (cbDestination2.ItemsSource != null && cbDestination1.SelectedItem != null)
{
var source = cbDestination2.Items as ICollectionView;
source.Filter = o =>
{
Airport a = o as Airport;
return(a != null && a.getMaxRunwayLength() >= type.MinRunwaylength && MathHelpers.GetDistance((Airport)cbDestination1.SelectedItem, a) <= type.Range || type.Manufacturer.Name == "Dummy");
};
}
}
//returns the flight time for the route for a specific airliner type
public TimeSpan getFlightTime(AirlinerType type)
{
if (this.HasStopovers)
{
double totalMinutes = this.Stopovers.SelectMany(s => s.Legs).Sum(l => l.getFlightTime(type).TotalMinutes);
double totalRestTime = FleetAirlinerHelpers.GetMinTimeBetweenFlights(type).TotalMinutes *(this.Stopovers.SelectMany(s => s.Legs).Count() - 1);
int time = (int)(totalRestTime + totalMinutes);
return(new TimeSpan(0, time, 0));
}
else
{
return(MathHelpers.GetFlightTime(this.Destination1, this.Destination2, type));
}
}
public RoutePlannerItemMVVM(Route route, AirlinerType type)
{
this.Route = route;
Guid g2 = new Guid(this.Route.Id);
byte[] bytes = g2.ToByteArray();
byte red = bytes[0];
byte green = bytes[1];
byte blue = bytes[2];
SolidColorBrush brush = new SolidColorBrush(Color.FromRgb(red, green, blue));
brush.Opacity = 0.4;
this.Brush = brush;
this.FlightTime = MathHelpers.GetFlightTime(this.Route.Destination1, this.Route.Destination2, type);
}
private void btnEquipped_Click(object sender, RoutedEventArgs e)
{
AirlinerType type = (AirlinerType)((Button)sender).Tag;
List <AirlinerClass> classes = (List <AirlinerClass>)PopUpAirlinerConfiguration.ShowPopUp(type, this.Classes);
if (classes != null)
{
this.customConfiguration = true;
this.Classes = classes;
panelClasses.Children.Clear();
foreach (AirlinerClass aClass in this.Classes)
{
panelClasses.Children.Add(createAirlineClassLink(aClass));
}
}
}
private void cbTypes_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
AirlinerType type = (AirlinerType)cbTypes.SelectedItem;
if (type != null)
{
int number = Convert.ToInt16(nudAirliners.Value);
txtPrice.Text = new ValueCurrencyConverter().Convert(type.Price * number).ToString();//string.Format("{0:C}", type.Price * number);
StackPanel panelType = new StackPanel();
panelType.Children.Add(PanelAirliner.createQuickInfoPanel(type));
if (type is AirlinerPassengerType)
{
panelType.Children.Add(createEquippedPanel(type));
}
frameAirlinerInfo.Content = panelType;
}
}
public AirlinerOrderMVVM(AirlinerType type, int amount = 1)
{
this.Type = type;
this.Amount = amount;
this.Classes = new List <AirlinerClass>();
this.Homebases = new List <Airport>();
if (this.Type.TypeAirliner == AirlinerType.TypeOfAirliner.Passenger)
{
AirlinerClass eClass = new AirlinerClass(AirlinerClass.ClassType.Economy_Class, ((AirlinerPassengerType)type).MaxSeatingCapacity);
eClass.createBasicFacilities(null);
this.Classes.Add(eClass);
}
long minRequiredRunway = this.Type.MinRunwaylength;
foreach (var homebase in GameObject.GetInstance().HumanAirline.Airports.FindAll(a => a.getCurrentAirportFacility(GameObject.GetInstance().HumanAirline, AirportFacility.FacilityType.Service).TypeLevel > 0 && a.getMaxRunwayLength() >= minRequiredRunway))
{
this.Homebases.Add(homebase);
}
}
public PopUpAirlinerImage(AirlinerType type)
{
this.Type = type;
InitializeComponent();
this.Width = 700;
this.Height = 260;
this.Title = type.Name;
this.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen;
Image imgMap = new Image();
imgMap.Width = 700;
imgMap.Height = 240;
imgMap.Source = new BitmapImage(new Uri(this.Type.Image, UriKind.RelativeOrAbsolute));
RenderOptions.SetBitmapScalingMode(imgMap, BitmapScalingMode.HighQuality);
this.Content = imgMap;
}
//returns the flight time for a given airliner type between two coordinates
public static TimeSpan GetFlightTime(GeoCoordinate coordinate1, GeoCoordinate coordinate2, AirlinerType type)
{
double dist = GetDistance(coordinate1, coordinate2);
if (dist == 0)
{
return(new TimeSpan(0, 0, 0));
}
double speed = type.CruisingSpeed;
double dtime = dist / speed;
int hours = Convert.ToInt16(Math.Floor(dtime));
double dMinutes = (dtime - hours) * 60;
int minutes = Convert.ToInt16(Math.Floor(dMinutes));
//2.5 minutes for takeoff and 2.5 minutes for landing
minutes += 5;
return(new TimeSpan(hours, minutes, 0));
}
//adds a prefered aircraft type to the airline
public void addPreferedAircraft(AirlinerType type)
{
this.PreferedAircrafts.Add(type);
}
//adds an airliner type with a quantity to the scenario
public void addFleet(AirlinerType type, int quantity)
{
this.Fleet.Add(type, quantity);
}
public static TimeSpan GetFlightTime(Airport airport1, Airport airport2, AirlinerType type)
{
return(GetFlightTime(airport1.Profile.Coordinates.convertToGeoCoordinate(), airport2.Profile.Coordinates.convertToGeoCoordinate(), type));
}
//returns the airliner classes for an airliner
public static List <AirlinerClass> GetAirlinerClasses(AirlinerType type)
{
List <AirlinerClass> classes = new List <AirlinerClass>();
if (type is AirlinerPassengerType)
{
Configuration airlinerTypeConfiguration = Configurations.GetConfigurations(Configuration.ConfigurationType.AirlinerType).Find(c => ((AirlinerTypeConfiguration)c).Airliner == type && ((AirlinerTypeConfiguration)c).Period.From <= GameObject.GetInstance().GameTime&& ((AirlinerTypeConfiguration)c).Period.To > GameObject.GetInstance().GameTime);
if (airlinerTypeConfiguration == null)
{
AirlinerConfiguration configuration = null;
int numOfClasses = rnd.Next(0, ((AirlinerPassengerType)type).MaxAirlinerClasses) + 1;
if (GameObject.GetInstance().GameTime.Year >= (int)AirlinerClass.ClassType.Business_Class)
{
if (numOfClasses == 1)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("200");
}
if (numOfClasses == 2)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("202");
}
if (numOfClasses == 3)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("203");
}
}
else
{
if (numOfClasses == 1)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("200");
}
if (numOfClasses == 2)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("201");
}
if (numOfClasses == 3)
{
configuration = (AirlinerConfiguration)Configurations.GetStandardConfiguration("201");
}
}
foreach (AirlinerClassConfiguration aClass in configuration.Classes)
{
AirlinerClass airlinerClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity);
airlinerClass.RegularSeatingCapacity = aClass.RegularSeatingCapacity;
foreach (AirlinerFacility facility in aClass.getFacilities())
{
airlinerClass.setFacility(null, facility);
}
foreach (AirlinerFacility.FacilityType fType in Enum.GetValues(typeof(AirlinerFacility.FacilityType)))
{
if (!aClass.Facilities.Exists(f => f.Type == fType))
{
airlinerClass.setFacility(null, AirlinerFacilities.GetBasicFacility(fType));
}
}
airlinerClass.SeatingCapacity = Convert.ToInt16(Convert.ToDouble(airlinerClass.RegularSeatingCapacity) / airlinerClass.getFacility(AirlinerFacility.FacilityType.Seat).SeatUses);
classes.Add(airlinerClass);
}
int seatingDiff = ((AirlinerPassengerType)type).MaxSeatingCapacity - configuration.MinimumSeats;
AirlinerClass economyClass = classes.Find(c => c.Type == AirlinerClass.ClassType.Economy_Class);
economyClass.RegularSeatingCapacity += seatingDiff;
AirlinerFacility seatingFacility = economyClass.getFacility(AirlinerFacility.FacilityType.Seat);
int extraSeats = (int)(seatingDiff / seatingFacility.SeatUses);
economyClass.SeatingCapacity += extraSeats;
}
else
{
foreach (AirlinerClassConfiguration aClass in ((AirlinerTypeConfiguration)airlinerTypeConfiguration).Classes)
{
AirlinerClass airlinerClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity);
airlinerClass.RegularSeatingCapacity = aClass.RegularSeatingCapacity;
foreach (AirlinerFacility facility in aClass.getFacilities())
{
airlinerClass.setFacility(null, facility);
}
airlinerClass.SeatingCapacity = Convert.ToInt16(Convert.ToDouble(airlinerClass.RegularSeatingCapacity) / airlinerClass.getFacility(AirlinerFacility.FacilityType.Seat).SeatUses);
classes.Add(airlinerClass);
}
}
}
else if (type is AirlinerCargoType)
{
AirlinerClass cargoClass = new AirlinerClass(AirlinerClass.ClassType.Economy_Class, 0);
classes.Add(cargoClass);
}
return(classes);
}
public AirlineFleetSizeMVVM(AirlinerType type, int count)
{
this.Type = type;
this.Count = count;
}
private void btnAddType_Click(object sender, RoutedEventArgs e)
{
AirlinerType type = (AirlinerType)((Button)sender).Tag;
this.Orders.addOrder(new AirlinerOrderMVVM(type));
}
//returns the flight time for the route for a specific airliner type
public TimeSpan getFlightTime(AirlinerType type)
{
if (this.HasStopovers)
{
double totalMinutes = this.Stopovers.SelectMany(s => s.Legs).Sum(l => l.getFlightTime(type).TotalMinutes);
double totalRestTime = FleetAirlinerHelpers.GetMinTimeBetweenFlights(type).TotalMinutes * (this.Stopovers.SelectMany(s => s.Legs).Count() - 1);
int time = (int)(totalRestTime + totalMinutes);
return new TimeSpan(0, time, 0);
}
else
return MathHelpers.GetFlightTime(this.Destination1, this.Destination2, type);
}
