public static object ShowPopUp(Airline airline)
{
PopUpWindow window = new PopUpCodeshareAgreement(airline);
window.ShowDialog();
return window.Selected;
}
public Scenario(
string name,
string description,
Airline airline,
Airport homebase,
int startyear,
int endyear,
long startcash,
DifficultyLevel difficulty)
{
Name = name;
Airline = airline;
Homebase = homebase;
StartYear = startyear;
StartCash = startcash;
Description = description;
Difficulty = difficulty;
EndYear = endyear;
OpponentAirlines = new List<ScenarioAirline>();
Destinations = new List<Airport>();
Fleet = new Dictionary<AirlinerType, int>();
Routes = new List<ScenarioAirlineRoute>();
Failures = new List<ScenarioFailure>();
PassengerDemands = new List<ScenarioPassengerDemand>();
}
public AirlineStartData(Airline airline)
{
Airline = airline;
Routes = new List<StartDataRoute>();
Airliners = new List<StartDataAirliners>();
OriginRoutes = new List<StartDataRoutes>();
}
public PopUpCreateSubsidiary(Airline airline)
{
this.Airline = airline;
this.DataContext = this.Airline;
this.MaxSubsidiaryMoney = this.Airline.Money / 2;
this.IATAOk = false;
this.Colors = new List<PropertyInfo>();
foreach (PropertyInfo c in typeof(Colors).GetProperties())
{
this.Colors.Add(c);
}
this.AllAirports = new ObservableCollection<Airport>();
/*
foreach (
Airport airport in
this.Airline.Airports.FindAll(
a => a.Terminals.getFreeSlotsPercent(this.Airline,this.Airline.AirlineRouteFocus == Route.RouteType.Passenger ? Terminal.TerminalType.Passenger : Terminal.TerminalType.Cargo) > 50))
{
this.AllAirports.Add(airport);
}*/
this.Loaded += PopUpCreateSubsidiary_Loaded;
InitializeComponent();
}
//changes the demand for all airports belonging to an airline with a factor
public static void ChangePaxDemand(Airline airline, double factor)
{
foreach (Airport a in airline.Airports)
{
ChangePaxDemand(a, factor);
}
}
public static object ShowPopUp(Airline airline,Airport airport)
{
PopUpWindow window = new PopUpAddCooperation(airline,airport);
window.ShowDialog();
return window.Selected;
}
public AirportContract(
Airline airline,
Airport airport,
ContractType type,
Terminal.TerminalType terminaltype,
DateTime date,
int numberOfGates,
int length,
double yearlyPayment,
bool autorenew,
bool payFull = false,
bool isExclusiveDeal = false,
Terminal terminal = null)
{
Type = type;
PayFull = payFull;
Airline = airline;
Airport = airport;
ContractDate = date;
Length = length;
YearlyPayment = yearlyPayment;
NumberOfGates = numberOfGates;
IsExclusiveDeal = isExclusiveDeal;
Terminal = terminal;
ExpireDate = ContractDate.AddYears(Length);
AutoRenew = autorenew;
TerminalType = terminaltype;
}
public AirlineAirportFacility(Airline airline, Airport airport, AirportFacility facility, DateTime date)
{
Airline = airline;
Facility = facility;
FinishedDate = date;
Airport = airport;
}
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 SpecialContract(SpecialContractType type, DateTime date, Airline airline)
{
Airline = airline;
Type = type;
Date = date;
IsOk = true;
Routes = new List<Route>();
}
public PopUpCodeshareAgreement(Airline airline)
{
this.Airline = airline;
this.DataContext = this.Airline;
this.Price = AirlineHelpers.GetCodesharingPrice(this.Airline,GameObject.GetInstance().HumanAirline);
this.TicketSalePercent = CodeshareAgreement.TicketSalePercent;
InitializeComponent();
}
public Gates(int numberOfGates, DateTime deliveryDate, Airline airline)
{
_terminalGates = new List<Gate>();
for (int i = 0; i < numberOfGates; i++)
{
var gate = new Gate(deliveryDate) {Airline = airline};
_terminalGates.Add(gate);
}
}
public static long GetAvgSubValue(Airline airline)
{
if (!airline.Subsidiaries.Any())
{
return 0;
}
return GetTotalSubValues(GameObject.GetInstance().HumanAirline)
/GameObject.GetInstance().HumanAirline.Subsidiaries.Count();
}
public Terminal(Airport airport, Airline airline, string name, int gates, DateTime deliveryDate, TerminalType type)
{
Airport = airport;
Airline = airline;
Name = name;
DeliveryDate = new DateTime(deliveryDate.Year, deliveryDate.Month, deliveryDate.Day);
Type = type;
Gates = new Gates(gates, DeliveryDate, airline);
}
public static void GenerateEvents(Airline airline)
{
var rnd = new Random();
var eventOccurences = new Dictionary<RandomEvent.EventType, double>();
int eFreq;
//sets an overall event frequency based on an airlines total overall rating
int totalRating = airline.Ratings.CustomerHappinessRating + airline.Ratings.EmployeeHappinessRating
+ airline.Ratings.SafetyRating + airline.Ratings.SecurityRating;
if (totalRating < 300)
{
eFreq = rnd.Next(1, 6);
}
else if (totalRating < 200)
{
eFreq = rnd.Next(4, 10);
}
else if (totalRating < 100)
{
eFreq = rnd.Next(8, 16);
}
else
{
eFreq = rnd.Next(0, 4);
}
//gets the event proportions and multiplies them by total # events to get events per type
List<double> probs = GetEventProportions(airline);
double custEvents = eFreq*probs[0];
double empEvents = eFreq*probs[1];
double secEvents = eFreq*probs[2];
double safEvents = eFreq*probs[3];
double maintEvents = eFreq*probs[4];
double polEvents = eFreq - custEvents - empEvents - secEvents - maintEvents;
eventOccurences.Add(RandomEvent.EventType.Customer, custEvents);
eventOccurences.Add(RandomEvent.EventType.Employee, empEvents);
eventOccurences.Add(RandomEvent.EventType.Maintenance, maintEvents);
eventOccurences.Add(RandomEvent.EventType.Safety, safEvents);
eventOccurences.Add(RandomEvent.EventType.Security, secEvents);
eventOccurences.Add(RandomEvent.EventType.Political, polEvents);
/*
//generates the given number of events for each type
foreach (KeyValuePair<RandomEvent.EventType, double> v in eventOccurences)
{
int k = (int)v.Value;
List<RandomEvent> list = RandomEvents.GetEvents(v.Key, k, airline);
foreach (RandomEvent e in list)
{
airline.EventLog.Add(e);
}
}
*/
}
//returns the value for a statistics type for an airline for a year
public double GetStatisticsValue(int year, Airline airline, StatisticsType type)
{
AirportStatisticsValue item =
Stats.Find(s => s.Year == year && s.Airline == airline && s.Stat.Shortname == type.Shortname);
if (item == null)
{
return 0;
}
return item.Value;
}
public static void AddPassengerHappiness(Airline airline)
{
/*
lock (HappinessPercent)
{
if (HappinessPercent.ContainsKey(airline))
HappinessPercent[airline] += 1;
else
HappinessPercent.Add(airline, 1);
}
* */
}
public void AddStatisticsValue(int year, Airline airline, StatisticsType type, int value)
{
AirportStatisticsValue item =
Stats.Find(s => s.Year == year && s.Airline == airline && s.Stat.Shortname == type.Shortname);
if (item == null)
{
Stats.Add(new AirportStatisticsValue(airline, year, type, value));
}
else
{
item.Value += value;
}
}
public PopUpAddCooperation(Airline airline, Airport airport)
{
this.Types = new List<CooperationType>();
this.Airline = airline;
this.Airport = airport;
foreach (CooperationType type in CooperationTypes.GetCooperationTypes())
{
if (!this.Airport.Cooperations.Exists(c => c.Airline == airline && c.Type == type) && type.AirportSizeRequired<=this.Airport.Profile.Size)
this.Types.Add(type);
}
InitializeComponent();
}
//returns all airline luxury levels
//calculates employee happiness as a function of wages, discounts, and free pilots (relative to workload)
public static double GetEmployeeHappiness(Airline airline)
{
Dictionary<Airline, double> wages = StatisticsHelpers.GetEmployeeWages();
Dictionary<Airline, double> discounts = StatisticsHelpers.GetEmployeeDiscounts();
Dictionary<Airline, double> unassignedPilots = StatisticsHelpers.GetUnassignedPilots();
IDictionary<Airline, double> scaleWages = StatisticsHelpers.GetRatingScale(wages);
IDictionary<Airline, double> scaleDiscounts = StatisticsHelpers.GetRatingScale(discounts);
IDictionary<Airline, double> scaleUPilots = StatisticsHelpers.GetRatingScale(unassignedPilots);
double airlineWages = scaleWages[airline];
double airlineDiscounts = scaleDiscounts[airline];
double airlineUnassignedPilots = scaleUPilots[airline];
return (airlineWages*0.7) + (airlineUnassignedPilots*0.2) + (airlineDiscounts*0.1);
}
public static IDictionary<DateTime, AirlineBudget> GetTestBudget(Airline airline)
{
AirlineBudget budget = GameObject.GetInstance().HumanAirline.Budget;
var random = new Random();
for (int i = 1; i < 61; i++)
{
budget.BudgetActive = GameObject.GetInstance().GameTime.AddMonths(-1);
budget.BudgetExpires = GameObject.GetInstance().GameTime.AddMonths(-1 + 12);
budget.Cash = random.Next(1, 100000000);
budget.AirportBudget = random.Next(1, 500000);
budget.CompBudget = random.Next(1, 500000);
budget.CSBudget = random.Next(1, 2000000);
budget.EndYearCash = random.Next(1, 100000000);
budget.EnginesBudget = random.Next(1, 1000000);
budget.EquipmentBudget = random.Next(1, 500000);
budget.FleetSize = random.Next(1, 250);
budget.FleetValue = random.Next(10, 10000);
budget.InFlightBudget = random.Next(1, 500000);
budget.InternetBudget = random.Next(1, 500000);
budget.ITBudget = random.Next(1, 500000);
budget.MaintenanceBudget = random.Next(1, 4000000);
budget.MarketingBudget = random.Next(1, 2000000);
budget.OverhaulBudget = random.Next(1, 1000000);
budget.PartsBudget = random.Next(1, 1000000);
budget.PRBudget = random.Next(1, 500000);
budget.PrintBudget = random.Next(1, 500000);
budget.PromoBudget = random.Next(1, 500000);
budget.RadioBudget = random.Next(1, 500000);
budget.RemainingBudget = random.Next(1, 10000000);
budget.RemoteBudget = random.Next(1, 1000000);
budget.SecurityBudget = random.Next(1, 2000000);
budget.ServCenterBudget = random.Next(1, 500000);
budget.Subsidiaries = random.Next(0, 4);
budget.TelevisionBudget = random.Next(1, 500000);
budget.TotalBudget = random.Next(4, 10000000);
budget.TotalEmployees = random.Next(1, 10000);
budget.TotalPayroll = random.Next(500000, 10000000);
budget.TotalSubValue = random.Next(200000000, 1000000000);
if (airline.TestBudget.ContainsKey(budget.BudgetActive.AddMonths(-1)))
{
}
else
{
airline.TestBudget.Add(budget.BudgetActive.AddMonths(-1), budget);
}
}
return airline.TestBudget;
}
public static void SimulateAirlineFlights(Airline airline)
{
var sw = new Stopwatch();
sw.Start();
foreach (
FleetAirliner airliner in airline.Fleet.FindAll(f => f.Status != FleetAirliner.AirlinerStatus.Stopped)) //Parallel.ForEach(
// airline.Fleet.FindAll(f => f.Status != FleetAirliner.AirlinerStatus.Stopped),
// airliner =>
{
if (airliner.CurrentFlight != null)
{
//Boolean stopoverRoute = airliner.CurrentFlight.Entry.MainEntry != null;
SimulateLanding(airliner);
}
FleetAirliner airliner1 = airliner;
IOrderedEnumerable<RouteTimeTableEntry> dayEntries =
airliner.Routes.Where(r => r.StartDate <= GameObject.GetInstance().GameTime)
.SelectMany(r => r.TimeTable.GetEntries(GameObject.GetInstance().GameTime.DayOfWeek))
.Where(
e =>
e.Airliner == airliner1
&& (e.TimeTable.Route.Season == Weather.Season.AllYear
|| e.TimeTable.Route.Season
== GeneralHelpers.GetSeason(GameObject.GetInstance().GameTime)))
.OrderBy(e => e.Time);
if (GameObject.GetInstance().GameTime > airliner.GroundedToDate)
{
foreach (RouteTimeTableEntry entry in dayEntries)
{
if (entry.TimeTable.Route.HasStopovers)
{
SimulateStopoverFlight(entry);
}
else
{
SimulateFlight(entry);
}
}
CheckForService(airliner);
}
} //);
sw.Stop();
}
private static double GetAirlineLuxuryLevel(Airline airline)
{
int luxuryLevel;
if (airline.Alliances.Count > 0)
{
luxuryLevel =
airline.Alliances.SelectMany(a => a.Members)
.Select(m => m.Airline)
.Max(m => airline.Facilities.Sum(f => f.LuxuryLevel));
}
else
{
luxuryLevel = airline.Facilities.Sum(f => f.LuxuryLevel);
}
return luxuryLevel;
}
public static double GetCustomerHappiness(Airline airline)
{
const int negInt = -1;
Dictionary<Airline, double> fillAverages = StatisticsHelpers.GetFillAverages();
Dictionary<Airline, double> onTimePercent = StatisticsHelpers.GetTotalOnTime();
Dictionary<Airline, double> ticketPPD = StatisticsHelpers.GetTotalPPD();
IDictionary<Airline, double> scaleAvgFill = StatisticsHelpers.GetRatingScale(fillAverages);
IDictionary<Airline, double> scaleOnTimeP = StatisticsHelpers.GetRatingScale(onTimePercent);
IDictionary<Airline, double> scalePPD = StatisticsHelpers.GetRatingScale(ticketPPD);
IDictionary<Airline, double> scaleLuxury = StatisticsHelpers.GetRatingScale(GetAirlinesLuxuryLevels());
double airlineAvgFill = scaleAvgFill[airline];
double airlineOTP = scaleOnTimeP[airline];
double airlinePPD = scalePPD[airline];
double airlineLuxury = scaleLuxury[airline];
return ((airlinePPD*negInt + 100)*0.4) + (airlineAvgFill*0.2) + (airlineOTP*0.2)
+ (airlineLuxury*0.2);
}
public static List<double> GetEventProportions(Airline airline)
{
//chr 0 ehr 1 scr 2 sfr 3 total 4
var ratings = new List<int>
{
100 - airline.Ratings.CustomerHappinessRating,
100 - airline.Ratings.EmployeeHappinessRating,
100 - airline.Ratings.SecurityRating,
100 - airline.Ratings.SafetyRating,
100 - airline.Ratings.MaintenanceRating
};
ratings.Add(500 - ratings.Sum());
double pCHR = ratings[0]/ratings[5];
double pEHR = ratings[1]/ratings[5];
double pSCR = ratings[2]/ratings[5];
double pSFR = ratings[3]/ratings[5];
double pMTR = ratings[4]/ratings[5];
ratings.Clear();
var pRatings = new List<double> {pCHR, pEHR, pSCR, pSFR, pMTR};
return pRatings;
}
//sets the airline for a pilot
public void SetAirline(Airline airline, DateTime signDate)
{
Airline = airline;
AirlineSignedDate = signDate;
}
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 static Airport FindComputerHomeBase(Airline airline)
{
Terminal.TerminalType terminaltype = airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger;
if (airline.Profile.PreferedAirport != null
&& GeneralHelpers.IsAirportActive(airline.Profile.PreferedAirport)
&& airline.Profile.PreferedAirport.Terminals.GetFreeGates(terminaltype) > 1)
{
return airline.Profile.PreferedAirport;
}
List<Airport> airports =
Airports.GetAirports(airline.Profile.Country).FindAll(a => a.Terminals.GetFreeGates(terminaltype) > 1);
if (airports.Count < 4)
{
airports =
Airports.GetAirports(airline.Profile.Country.Region).FindAll(a => a.Terminals.GetFreeGates(terminaltype) > 1);
}
var list = new Dictionary<Airport, int>();
airports.ForEach(
a => list.Add(a, ((int) a.Profile.Size)*(AirportHelpers.GetAirportsNearAirport(a, 1000).Count) + 1));
return AIHelpers.GetRandomItem(list);
}
private static void CreateComputerRoutes(Airline airline)
{
bool leaseAircraft = airline.Profile.PrimaryPurchasing == AirlineProfile.PreferedPurchasing.Leasing;
Airport airportHomeBase = FindComputerHomeBase(airline);
AirportFacility serviceFacility =
AirportFacilities.GetFacilities(AirportFacility.FacilityType.Service).Find(f => f.TypeLevel == 1);
AirportFacility checkinFacility =
AirportFacilities.GetFacilities(AirportFacility.FacilityType.CheckIn).Find(f => f.TypeLevel == 1);
AirportFacility cargoTerminal =
AirportFacilities.GetFacilities(AirportFacility.FacilityType.Cargo).Find(f => f.TypeLevel > 0);
airportHomeBase.AddAirportFacility(airline, serviceFacility, GameObject.GetInstance().GameTime);
airportHomeBase.AddAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);
if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
{
airportHomeBase.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
}
AirlineStartData startData = AirlineStartDatas.GetAirlineStartData(airline);
//creates the start data for an airline
if (startData != null)
{
AirportHelpers.RentGates(airportHomeBase, airline, AirportContract.ContractType.Full);
CreateAirlineStartData(airline, startData);
}
else
{
List<Airport> airportDestinations = AIHelpers.GetDestinationAirports(airline, airportHomeBase);
if (airportDestinations.Count == 0)
{
airportDestinations =
Airports.GetAirports(
a =>
a.Profile.Country.Region == airportHomeBase.Profile.Country.Region
&& a != airportHomeBase);
}
KeyValuePair<Airliner, bool>? airliner = null;
Airport airportDestination = null;
int counter = 0;
while ((airportDestination == null || airliner == null || !airliner.HasValue)
&& airportDestinations.Count > counter)
{
airportDestination = airportDestinations[counter];
airliner = AIHelpers.GetAirlinerForRoute(
airline,
airportHomeBase,
airportDestination,
leaseAircraft,
airline.AirlineRouteFocus,
true);
counter++;
}
if (airportDestination == null || !airliner.HasValue)
{
CreateComputerRoutes(airline);
}
else
{
AirportHelpers.AddAirlineContract(
new AirportContract(
airline,
airportHomeBase,
AirportContract.ContractType.Full,
airline.AirlineRouteFocus == Route.RouteType.Cargo ? Terminal.TerminalType.Cargo : Terminal.TerminalType.Passenger,
GameObject.GetInstance().GameTime,
2,
25,
0,
true));
AirportHelpers.RentGates(airportDestination, airline, AirportContract.ContractType.LowService);
//airportDestination.addAirportFacility(airline, checkinFacility, GameObject.GetInstance().GameTime);
Guid id = Guid.NewGuid();
double price = PassengerHelpers.GetPassengerPrice(airportDestination, airline.Airports[0]);
Route route = null;
if (airline.AirlineRouteFocus == Route.RouteType.Passenger)
{
route = new PassengerRoute(
id.ToString(),
airportDestination,
airline.Airports[0],
GameObject.GetInstance().GameTime,
price);
RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((PassengerRoute) route);
foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
{
((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
*GeneralHelpers
.ClassToPriceFactor
(
classConfiguration
.Type);
foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
{
((PassengerRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
.AddFacility(rFacility);
}
}
}
if (airline.AirlineRouteFocus == Route.RouteType.Helicopter)
{
route = new HelicopterRoute(
id.ToString(),
airportDestination,
airline.Airports[0],
GameObject.GetInstance().GameTime,
price);
RouteClassesConfiguration configuration = AIHelpers.GetRouteConfiguration((HelicopterRoute) route);
foreach (RouteClassConfiguration classConfiguration in configuration.GetClasses())
{
((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type).FarePrice = price
*GeneralHelpers
.ClassToPriceFactor
(
classConfiguration
.Type);
foreach (RouteFacility rFacility in classConfiguration.GetFacilities())
{
((HelicopterRoute) route).GetRouteAirlinerClass(classConfiguration.Type)
.AddFacility(rFacility);
}
}
}
if (airline.AirlineRouteFocus == Route.RouteType.Cargo)
{
route = new CargoRoute(
id.ToString(),
airportDestination,
airline.Airports[0],
GameObject.GetInstance().GameTime,
PassengerHelpers.GetCargoPrice(airportDestination, airline.Airports[0]));
airportDestination.AddAirportFacility(airline, cargoTerminal, GameObject.GetInstance().GameTime);
}
if (leaseAircraft)
{
AirlineHelpers.AddAirlineInvoice(
airline,
GameObject.GetInstance().GameTime,
Invoice.InvoiceType.Rents,
-airliner.Value.Key.LeasingPrice*2);
}
else
{
AirlineHelpers.AddAirlineInvoice(
airline,
GameObject.GetInstance().GameTime,
Invoice.InvoiceType.Purchases,
-airliner.Value.Key.GetPrice());
}
var fAirliner =
new FleetAirliner(
leaseAircraft ? FleetAirliner.PurchasedType.Leased : FleetAirliner.PurchasedType.Bought,
GameObject.GetInstance().GameTime,
airline,
airliner.Value.Key,
airportHomeBase) {Status = FleetAirliner.AirlinerStatus.ToRouteStart};
fAirliner.AddRoute(route);
AirlinerHelpers.CreateAirlinerClasses(fAirliner.Airliner);
AirlineHelpers.HireAirlinerPilots(fAirliner);
airline.AddAirliner(fAirliner);
airline.AddRoute(route);
if (route != null)
{
route.LastUpdated = GameObject.GetInstance().GameTime;
if (route.Type == Route.RouteType.Passenger || route.Type == Route.RouteType.Mixed)
{
AIHelpers.CreateRouteTimeTable(route, fAirliner);
}
if (route.Type == Route.RouteType.Cargo)
{
AIHelpers.CreateCargoRouteTimeTable(route, fAirliner);
}
}
}
}
}
public static Airline LoadAirline(string path)
{
var doc = new XmlDocument();
doc.Load(path);
XmlElement root = doc.DocumentElement;
var profileElement = (XmlElement) root?.SelectSingleNode("profile");
if (profileElement != null)
{
string name = profileElement.Attributes["name"].Value;
string iata = profileElement.Attributes["iata"].Value;
string color = profileElement.Attributes["color"].Value;
string logoImage = profileElement.HasAttribute("logo") ? profileElement.Attributes["logo"].Value : "";
string sCountries = profileElement.Attributes["country"].Value;
var countries = sCountries.Split(';').Select(Countries.GetCountry).ToList();
//Country country = Countries.GetCountry(profileElement.Attributes["country"].Value);
string ceo = profileElement.Attributes["CEO"].Value;
var mentality =
(Airline.AirlineMentality)
Enum.Parse(typeof (Airline.AirlineMentality), profileElement.Attributes["mentality"].Value);
var market =
(AirlineFocus)
Enum.Parse(typeof (AirlineFocus), profileElement.Attributes["market"].Value);
var routeFocus = Route.RouteType.Passenger;
if (profileElement.HasAttribute("routefocus"))
{
routeFocus =
(Route.RouteType) Enum.Parse(typeof (Route.RouteType), profileElement.Attributes["routefocus"].Value);
}
var narrativeElement = (XmlElement) profileElement.SelectSingleNode("narrative");
string narrative = "";
if (narrativeElement != null)
{
narrative = narrativeElement.Attributes["narrative"].Value;
}
bool isReal = true;
int founded = 1950;
int folded = 2199;
var infoElement = (XmlElement) root.SelectSingleNode("info");
if (infoElement != null)
{
isReal = Convert.ToBoolean(infoElement.Attributes["real"].Value);
founded = Convert.ToInt16(infoElement.Attributes["from"].Value);
folded = Convert.ToInt16(infoElement.Attributes["to"].Value);
}
var license = Airline.AirlineLicense.Domestic;
if (market == AirlineFocus.Global)
{
license = mentality == Airline.AirlineMentality.Aggressive ? Airline.AirlineLicense.LongHaul : Airline.AirlineLicense.ShortHaul;
}
if (market == AirlineFocus.Regional)
{
license = Airline.AirlineLicense.Regional;
}
var airline = new Airline(
new AirlineProfile(name, iata, color, ceo, isReal, founded, folded),
mentality,
market,
license,
routeFocus) {Profile = {Countries = countries}};
airline.Profile.Country = airline.Profile.Countries[0];
airline.Profile.LogoName = logoImage;
var preferedsElement = (XmlElement) root.SelectSingleNode("prefereds");
if (preferedsElement != null)
{
if (preferedsElement.HasAttribute("aircrafts"))
{
string[] preferedAircrafts = preferedsElement.Attributes["aircrafts"].Value.Split(',');
foreach (string preferedAircraft in preferedAircrafts)
{
AirlinerType pAircraft = AirlinerTypes.GetType(preferedAircraft);
airline.Profile.AddPreferedAircraft(pAircraft);
}
}
if (preferedsElement.HasAttribute("primarypurchasing"))
{
var primarypurchasing =
(AirlineProfile.PreferedPurchasing)
Enum.Parse(
typeof (AirlineProfile.PreferedPurchasing),
preferedsElement.Attributes["primarypurchasing"].Value);
airline.Profile.PrimaryPurchasing = primarypurchasing;
}
}
XmlNodeList logosList = profileElement.SelectNodes("logos/logo");
if (logosList != null)
foreach (XmlElement logoElement in logosList)
{
int logoFromYear = Convert.ToInt16(logoElement.Attributes["from"].Value);
int logoToYear = Convert.ToInt16(logoElement.Attributes["to"].Value);
string logoPath = AppSettings.GetDataPath() + "\\graphics\\airlinelogos\\multilogos\\"
+ logoElement.Attributes["path"].Value + ".png";
airline.Profile.AddLogo(new AirlineLogo(logoFromYear, logoToYear, logoPath));
}
if (profileElement.HasAttribute("preferedairport"))
{
Airport preferedAirport = Airports.GetAirport(profileElement.Attributes["preferedairport"].Value);
airline.Profile.PreferedAirport = preferedAirport;
}
XmlNodeList subsidiariesList = root.SelectNodes("subsidiaries/subsidiary");
if (subsidiariesList != null)
{
foreach (XmlElement subsidiaryElement in subsidiariesList)
{
string subName = subsidiaryElement.Attributes["name"].Value;
string subIATA = subsidiaryElement.Attributes["IATA"].Value;
Airport subAirport = Airports.GetAirport(subsidiaryElement.Attributes["homebase"].Value);
var subMentality =
(Airline.AirlineMentality)
Enum.Parse(
typeof (Airline.AirlineMentality),
subsidiaryElement.Attributes["mentality"].Value);
var subMarket =
(AirlineFocus)
Enum.Parse(typeof (AirlineFocus), subsidiaryElement.Attributes["market"].Value);
string subLogo = AppSettings.GetDataPath() + "\\graphics\\airlinelogos\\"
+ subsidiaryElement.Attributes["logo"].Value + ".png";
var airlineRouteFocus = Route.RouteType.Passenger;
if (subsidiaryElement.HasAttribute("routefocus"))
{
airlineRouteFocus =
(Route.RouteType)
Enum.Parse(typeof (Route.RouteType), subsidiaryElement.Attributes["routefocus"].Value);
}
airline.FutureAirlines.Add(
new FutureSubsidiaryAirline(
subName,
subIATA,
subAirport,
subMentality,
subMarket,
airlineRouteFocus,
subLogo));
}
}
var startDataElement = (XmlElement) root.SelectSingleNode("startdata");
if (startDataElement != null)
{
var startData = new AirlineStartData(airline);
XmlNodeList routesList = startDataElement.SelectNodes("routes/route");
if (routesList != null)
foreach (XmlElement routeElement in routesList)
{
string dest1 = routeElement.Attributes["destination1"].Value;
string dest2 = routeElement.Attributes["destination2"].Value;
int opened = Convert.ToInt16(routeElement.Attributes["opened"].Value);
int closed = Convert.ToInt16(routeElement.Attributes["closed"].Value);
Route.RouteType routetype = airline.AirlineRouteFocus;
if (routeElement.HasAttribute("routetype"))
{
routetype =
(Route.RouteType)
Enum.Parse(typeof (Route.RouteType), routeElement.Attributes["routetype"].Value);
}
var sdr = new StartDataRoute(dest1, dest2, opened, closed, routetype);
startData.AddRoute(sdr);
if (routeElement.HasAttribute("airliner"))
{
AirlinerType airlinerType = AirlinerTypes.GetType(routeElement.Attributes["airliner"].Value);
sdr.Type = airlinerType;
}
}
XmlNodeList airlinersList = startDataElement.SelectNodes("airliners/airliner");
foreach (XmlElement airlinerElement in airlinersList)
{
string type = airlinerElement.Attributes["type"].Value;
int early = Convert.ToInt16(airlinerElement.Attributes["early"].Value);
int late = Convert.ToInt16(airlinerElement.Attributes["late"].Value);
startData.AddAirliners(new StartDataAirliners(type, early, late));
}
XmlNodeList randomRoutesList = startDataElement.SelectNodes("random_routes/routes");
foreach (XmlElement routeElement in randomRoutesList)
{
string origin = routeElement.Attributes["origin"].Value;
int destinations = Convert.ToInt16(routeElement.Attributes["destinations"].Value);
var minimumsize =
(GeneralHelpers.Size)
Enum.Parse(typeof (GeneralHelpers.Size), routeElement.Attributes["minimumsize"].Value);
Route.RouteType routetype = airline.AirlineRouteFocus;
if (routeElement.HasAttribute("routetype"))
{
routetype =
(Route.RouteType)
Enum.Parse(typeof (Route.RouteType), routeElement.Attributes["routetype"].Value);
}
var routes = new StartDataRoutes(origin, destinations, minimumsize, routetype);
XmlNodeList countriesList = routeElement.SelectNodes("countries/country");
foreach (XmlElement countryElement in countriesList)
{
Country routesCountry = Countries.GetCountry(countryElement.Attributes["value"].Value);
routes.AddCountry(routesCountry);
}
startData.AddOriginRoutes(routes);
}
AirlineStartDatas.AddStartData(startData);
}
airline.Profile.Narrative = narrative;
Airlines.AddAirline(airline);
return airline;
}
return null;
}
