public AirlinerOrder(AirlinerType type, List<AirlinerClass> classes, int amount, bool customConfiguration)
{
Type = type;
Amount = amount;
Classes = classes;
CustomConfiguration = customConfiguration;
}
public AirlinerTypeConfiguration(string name, AirlinerType type, Period<DateTime> period, Boolean standard)
: base(ConfigurationType.AirlinerType, name, standard)
{
Airliner = type;
Period = period;
Classes = new List<AirlinerClassConfiguration>();
}
public Airliner(string id, AirlinerType type, string tailNumber, DateTime builtDate)
{
ID = id;
BuiltDate = new DateTime(builtDate.Year, builtDate.Month, builtDate.Day);
Type = type;
LastServiceCheck = 0;
TailNumber = tailNumber;
Flown = 0;
Condition = _rnd.Next(90, 100);
Status = StatusTypes.Normal;
Classes = new List<AirlinerClass>();
if (Type.TypeAirliner == AirlinerType.TypeOfAirliner.Passenger)
{
var aClass = new AirlinerClass(
AirlinerClass.ClassType.EconomyClass,
((AirlinerPassengerType) Type).MaxSeatingCapacity);
aClass.CreateBasicFacilities(Airline);
Classes.Add(aClass);
}
if (Type.TypeAirliner == AirlinerType.TypeOfAirliner.Cargo)
{
var aClass = new AirlinerClass(AirlinerClass.ClassType.EconomyClass, 0);
aClass.CreateBasicFacilities(Airline);
Classes.Add(aClass);
}
}
public ScenarioAirlineRoute(Airport destination1, Airport destination2, AirlinerType airlinertype, int quantity)
{
Destination1 = destination1;
Destination2 = destination2;
AirlinerType = airlinertype;
Quantity = quantity;
}
public PopUpAirlinerConfiguration(AirlinerType type, List<AirlinerClass> classes)
{
this.Classes = new List<AirlinerClass>(classes);
this.Type = type;
createPopUp();
}
public static object ShowPopUp(AirlinerType airliner, List<AirlinerClass> classes)
{
PopUpWindow window = new PopUpAirlinerConfiguration(airliner,classes);
window.ShowDialog();
return window.Selected;
}
public AirlineFleetSizeMVVM(AirlinerType type, int count)
{
this.Type = type;
this.Count = count;
}
public static List<EngineType> GetEngineTypes(AirlinerType type)
{
return (from t in _types from at in t.Types where at.Name == type.Name select t).ToList();
}
public AirlinerScheduleConfiguration(string name, AirlinerType type)
: base(ConfigurationType.AirlinerSchedule, name, false)
{
AirlinerType = type;
Entries = new List<RouteTimeTableEntry>();
}
public static void AddType(AirlinerType type)
{
_types.Add(type);
}
public static List<AirlinerClass> GetAirlinerClasses(AirlinerType type)
{
var classes = new List<AirlinerClass>();
var passengerType = type as AirlinerPassengerType;
if (passengerType != null)
{
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)
{
int seatingDiff = 0;
AirlinerConfiguration configuration = null;
int numOfClasses = Rnd.Next(0, passengerType.MaxAirlinerClasses) + 1;
if (GameObject.GetInstance().GameTime.Year >= (int) AirlinerClass.ClassType.BusinessClass)
{
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");
}
}
if (configuration != null)
{
foreach (AirlinerClassConfiguration aClass in configuration.Classes)
{
var airlinerClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity) {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);
}
seatingDiff = passengerType.MaxSeatingCapacity - configuration.MinimumSeats;
}
AirlinerClass economyClass = classes.Find(c => c.Type == AirlinerClass.ClassType.EconomyClass);
economyClass.RegularSeatingCapacity += seatingDiff;
AirlinerFacility seatingFacility = economyClass.GetFacility(AirlinerFacility.FacilityType.Seat);
var extraSeats = (int) (seatingDiff/seatingFacility.SeatUses);
economyClass.SeatingCapacity += extraSeats;
}
else
{
foreach (
AirlinerClassConfiguration aClass in
((AirlinerTypeConfiguration) airlinerTypeConfiguration).Classes)
{
var airlinerClass = new AirlinerClass(aClass.Type, aClass.SeatingCapacity) {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)
{
var cargoClass = new AirlinerClass(AirlinerClass.ClassType.EconomyClass, 0);
classes.Add(cargoClass);
}
else if (type.TypeAirliner == AirlinerType.TypeOfAirliner.Helicopter)
{
var helicopterClass = new AirlinerClass(AirlinerClass.ClassType.EconomyClass, 0);
classes.Add(helicopterClass);
}
return classes;
}
public static List<Airport> GetHomebases(Airline airline, AirlinerType type)
{
return GetHomebases(airline, type.MinRunwaylength);
}
//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;
}
public TimeSpan GetFlightTime(AirlinerType type)
{
if (HasStopovers)
{
double totalMinutes = Stopovers.SelectMany(s => s.Legs)
.Sum(l => l.GetFlightTime(type).TotalMinutes);
double totalRestTime = FleetAirlinerHelpers.GetMinTimeBetweenFlights(type).TotalMinutes
*(Stopovers.SelectMany(s => s.Legs).Count() - 1);
var time = (int) (totalRestTime + totalMinutes);
return new TimeSpan(0, time, 0);
}
return MathHelpers.GetFlightTime(Destination1, Destination2, type);
}
public static object ShowPopUp(AirlinerType type, List<AirlinerClass> classes, EngineType engine)
{
PopUpWindow window = new PopUpAirlinerSeatsConfiguration(type, classes, engine);
window.ShowDialog();
return window.Selected;
}
public PopUpAirlinerSeatsConfiguration(AirlinerType type, List<AirlinerClass> classes, EngineType engine)
{
this.FreeClassTypes = new ObservableCollection<AirlinerClass.ClassType>();
this.Classes = new ObservableCollection<AirlinerClassMVVM>();
this.Type = type;
this.Engines = new List<EngineType>();
foreach (EngineType e in EngineTypes.GetEngineTypes(type, GameObject.GetInstance().GameTime.Year).OrderBy(t => t.Price))
this.Engines.Add(e);
if (this.Engines.Count > 0)
this.SelectedEngine = engine;
AirlinerClass economyClass = classes.Find(c => c.Type == AirlinerClass.ClassType.EconomyClass);
foreach (AirlinerClass aClass in classes)
{
int maxseats = aClass.Type == AirlinerClass.ClassType.EconomyClass ? aClass.SeatingCapacity : economyClass.RegularSeatingCapacity - 1;
AirlinerClassMVVM nClass = new AirlinerClassMVVM(aClass.Type, aClass.SeatingCapacity, maxseats, aClass.Type != AirlinerClass.ClassType.EconomyClass);
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.BusinessClass);
this.FreeClassTypes.Add(AirlinerClass.ClassType.FirstClass);
}
this.Loaded += PopUpAirlinerSeatsConfiguration_Loaded;
InitializeComponent();
}
public PopUpAirlinerConfiguration(Airliner airliner)
{
this.Classes = new List<AirlinerClass>();
foreach (AirlinerClass aClass in airliner.Classes)
{
this.Classes.Add(aClass);
}
this.Type = airliner.Type;
createPopUp();
}
//returns a calculated weight for an airliner
public static double GetCalculatedWeight(AirlinerType type)
{
return GetCalculatedWeight(type.Wingspan, type.Length, type.FuelCapacity);
}
public static TimeSpan GetMinTimeBetweenFlights(AirlinerType type)
{
if (type == null || type is AirlinerCargoType)
return GetMinTimeBetweenFlights(0);
return GetMinTimeBetweenFlights(((AirlinerPassengerType) type).MaxSeatingCapacity);
}
//removes an airliner type
public static void RemoveType(AirlinerType type)
{
_types.Remove(type);
}
public void AddAirlinerType(AirlinerType type)
{
Types.Add(type);
}
public void AddPreferedAircraft(AirlinerType type)
{
PreferedAircrafts.Add(type);
}
public AirlinerTypeMVVM(AirlinerType type)
{
this.Type = type;
this.IsSelected = false;
}
public RoutePlannerItemMVVM(Route route, AirlinerType type)
{
Route = route;
var g2 = new Guid(Route.Id);
byte[] bytes = g2.ToByteArray();
byte red = bytes[0];
byte green = bytes[1];
byte blue = bytes[2];
var brush = new SolidColorBrush(Color.FromRgb(red, green, blue));
brush.Opacity = 0.4;
Brush = brush;
FlightTime = MathHelpers.GetFlightTime(Route.Destination1, Route.Destination2, type);
Airliners = Route.GetAirliners().Count;
}
public AirlinerQuantityMVVM(AirlinerType type, string cabinConfig, int quantity, int onOrder)
{
Quantity = quantity;
OnOrder = onOrder;
Type = type;
CabinConfiguration = cabinConfig;
}
//returns the list of engine types for an airliner type
public static List<EngineType> GetEngineTypes(AirlinerType type, int year)
{
return GetEngineTypes(type).FindAll(t => t.Produced.From <= year && t.Produced.To >= year);
}
public void AddFleet(AirlinerType type, int quantity)
{
Fleet.Add(type, quantity);
}
public static EngineType GetStandardEngineType(AirlinerType type)
{
List<EngineType> allTypes = GetEngineTypes(type);
if (allTypes.Count > 0)
{
return allTypes.OrderBy(t => t.Price).First();
}
return null;
}
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 || this.Type.TypeAirliner == AirlinerType.TypeOfAirliner.Helicopter)
{
var eClass = new AirlinerClass(
AirlinerClass.ClassType.EconomyClass,
((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);
List<Airport> homebases = AirlineHelpers.GetHomebases(GameObject.GetInstance().HumanAirline, minRunway);
foreach (Airport homebase in homebases)
{
this.Homebases.Add(homebase);
}
this.Engine = EngineTypes.GetStandardEngineType(this.Type, GameObject.GetInstance().GameTime.Year);
this.ForConfig = this.Type.TypeAirliner == AirlinerType.TypeOfAirliner.Passenger || this.Type.TypeAirliner == AirlinerType.TypeOfAirliner.Mixed || EngineTypes.GetEngineTypes(type,GameObject.GetInstance().GameTime.Year).Count > 0;
}
