AeroLinear

name speaks for itself

message from Palm Tree Air:

Are you having fun resetting all of my routes a hundred times? Should I build my next two terminals in LAS and SFO and flood all your routes with A330's?

Now I usually wouldn't bring this into forums, but what's the need of threatening me in private? It's only a game, pal. If you don't like it, make it fun or quit playing.

And since you're into threatening, hear this. If you do what you "threaten" to do (9 times out of 10 people only talk out of frustration, you and I both probably know that) you will regret it at LAX and at EWR.

making them load before the page does = no page if the adserver is down. i can't edit all my routes now because google's ad thing is screwed up.

so i take all the remaining gates at LAS. four days later there are 15 more gates available, so I take them. 2 days later there are 15 more, so I take them. I look around at my competition to see it has now 18 additional gates. I'm pretty sure there are no new "players" at this airport.

It annoys me how I play by the rules and take a hit to get my gates and then some schmuck goes around creating (apparently) 5-10 airlines just to gain an edge. i'm not accusing anybody because i don't know who it is but cmon this is ridiculous.

Some of you may know what I'm talking about just from the title. However, since I just coined the term (as far as I know) I'll elaborate.

It is possible to cover more "ground" than is physically possible for one plane in AE.

For example: Put an A333 on a flight from Asia the the US. Then, put the A333 on extremely short routes on each end. Third, close the longhaul route. Voila! you can now make medium-ranged flights on 2 ends of the planet with one plane.

Now there are two ways to abuse this "feature" to my knowledge. One is to do what I said above and split one plane between two of your hubs without actually having to fly the plane inbetween. The other is to hold gates. I'll explain.

Airline A buys 10 gates at the following airports: LGA, JFK, DCA, IAD, TPA, MCO, FLL, MIA, MDW, ORD.

Now, normally a beech might be able to connect around 1/2 to 2/3 of these gates. However, if I follow the following instructions I can make a beech fly to cover every gate and have probably half my flight time left.

Action

1. Create Route: LGA-JFK
2. Create Route: JFK-DCA
3. Create Route: DCA-IAD

4. Close Route: JFK-DCA

5. Create Route: IAD-TPA
6. Create Route: TPA-MCO

7. Close Route: IAD-TPA

8. Create Route: TPA-FLL
9. Create Route: FLL-MIA

10. Close Route: TPA-FLL

11. Create Route: LGA-ORD
12. Create Route: ORD-MDW

13. Close Route: LGA-ORD

So, we are left with LGA-JFK, DCA-IAD, TPA-MCO, MIA-FLL, and ORD-MDW.

The plane flies 5 separate routes, taking a fraction of the time needed to traverse the country to complete the routes. You could take it a few steps further and cover around 20 sub-100nm city pairs around the world.

The question: should we consider this a bug or a feature? Is this ok to use to my advantage? Obviously it's not possible in real life, but neither are a lot of things in AE.

EDIT: I guess I should recommend a solution also.

It's a simple connectivity problem. So, take each route for the plane and assign it a number whenever an airline closes a route BEFORE the closing is actually done.

So, if we have LGA-JFK, JFK-DCA, DCA-IAD and we want to close JFK-DCA:

LGA: 1
JFK: 2
DCA: 3
IAD: 4

The condition of whether or not you may close an airport rests on whether or not all the remaining pairs of numbers are connected. So, to put it into human terms, here are our routes:

1-2
2-3
3-4

If we want to close 2-3, we must check to see if 1-2 and 3-4 are connected. They obviously aren't, since they don't share any number. It gets more complicated, though. Say we had 5 routes.

1-2
2-3
1-4
3-6

Now say we want to close 2-3. This would sever the connection between 1-2 and 3-6. So, we need an algorithm to solve the problem. As with most algorithms, there are multiple solutions, some generally more efficient than others, some more suitable to certain situations. Since we can be generally sure that no plane will fly more than, say, 25 individual routes, efficiency isn't really a factor. So, if we create a two-dimensional array to store "connected" flights, our job becomes easy.

We take every route except the the one requesting to be closed. For each route, we take each number, see if either one (or both) are in the first array. If both are, we take no action. If 1 is, we add the other to the array. If neither are, we check the next array, etc. If we find no matches, we create a new array element and place the new connection into the new array. At the end of our algorithm, if we have all the remaining cities in one array element, then we have continuity. Otherwise, we have a split and cannot close the route.

Here's the code:

//$connections is structured as an array of arrays, the inner array elements being [0]=city1 & [1]=city2

//num_cities() would be a function written simply to count the number of cities a plane "touches". The code here is not clear since I do not know the database, but it is part of the algorithm so I included just a function call.

//$continue is the boolean variable that tells us whether or not the "close" operation is in fact permissable.

$num=num_cities();

foreach($connections as $connection)
{
if (!$routesarray)
{
$routesarray=array($connection);
}
else
{
foreach ($routesarray as $node)
{
if (!in_array($connection[0], $node) OR !in_array($connection[1], $node))
{
if (in_array($connection[0], $node))
{
$node=array_merge($node, array($connection[1]));
}
else if (in_array($connection[1], $node))
{
$node=array_merge($node, array($connection[0]));
}
else
{
array_merge($routes_array, $connection);
}
}
}
}
}

foreach ($routesarray as $node)
{
if(size($node)==$num)
{
$continue=true;
}
}

Now, we can just use our variable $continue to check for connectivity. Throw this thing into a function and you can make a call like "if(flights_connect($routelistminusroutetoremove))" to check for connectivity.