* {0,HANGAR,NOTHING_block,1}, {0,255,TERM_GROUP1_block,0}, {0,255,TERM_GROUP2_ENTER_block,1}, {0,0,N,1},

	 * Heading 255 denotes a group. We see 2 groups here:

	 * 1. group 0 -- TERM_GROUP1_block (check block)

	 * 2. group 1 -- TERM_GROUP2_ENTER_block (check block)

	 * First in line is checked first, group 0. If the block (TERM_GROUP1_block) is free, it

	 * looks at the corresponding terminals of that group. If no free ones are found, other

	 * possible groups are checked (in this case group 1, since that is after group 0). If that

	 * fails, then attempt fails and plane waits

 * This file deals with displaying wires and pylons for electric railways.

 * <h2>Basics</h2>

 *

 * <h3>Tile Types</h3>

 *

 * We have two different types of tiles in the drawing code:

 * Normal Railway Tiles (NRTs) which can have more than one track on it, and

 * Special Railways tiles (SRTs) which have only one track (like crossings, depots

 * stations, etc).

 *

 * <h3>Location Categories</h3>

 *

 * All tiles are categorized into three location groups (TLG):

 * Group 0: Tiles with both an even X coordinate and an even Y coordinate

 * Group 1: Tiles with an even X and an odd Y coordinate

 * Group 2: Tiles with an odd X and an even Y coordinate

 * Group 3: Tiles with both an odd X and Y coordnate.

 *

 * <h3>Pylon Points</h3>

 * <h4>Control Points</h4>

 * A Pylon Control Point (PCP) is a position where a wire (or rather two)

 * is mounted onto a pylon.

 * Each NRT does contain 4 PCPs which are bitmapped to a byte

 * variable and are represented by the DiagDirection enum

 *

 * Each track ends on two PCPs and thus requires one pylon on each end. However,

 * there is one exception: Straight-and-level tracks only have one pylon every

 * other tile.

 *

 * Now on each edge there are two PCPs: One from each adjacent tile. Both PCPs

 * are merged using an OR operation (i. e. if one tile needs a PCP at the postion

 * in question, both tiles get it).

 *

 * <h4>Position Points</h4>

 * A Pylon Position Point (PPP) is a position where a pylon is located on the

 * ground.  Each PCP owns 8 in (45 degree steps) PPPs that are located around

 * it. PPPs are represented using the Direction enum. Each track bit has PPPs

 * that are impossible (because the pylon would be situated on the track) and

 * some that are preferred (because the pylon would be rectangular to the track).

 *

 * <img src="../../elrail_tile.png">

 * <img src="../../elrail_track.png">

 *

	 * the track configuration of 2 adjacent tiles. trackconfig[0] stores the

	 * current tile (home tile) while [1] holds the neighbour */

	 * We don't draw a pylon:

	 * 1) INSIDE a tunnel (we wouldn't see it anyway)

	 * 2) on the "far" end of a bridge head (the one that connects to bridge middle),

	 *    because that one is drawn on the bridge. Exception is for length 0 bridges

	 *    which have no middle tiles */

		 * existing foundataions, so we do have to do that manually later on.*/

		 * PPPs we want to have, or may not have at all */

			 * (TrackSourceTile) */

				 * of the PCP for preferred/allowed determination*/

		 * Delete the PCP if this is the case. */

		 * In that case, we try the any of the allowed ones. if they don't exist either, don't draw

		 * anything. Note that the preferred PPPs still contain the end-of-line markers.

		 * Remove those (simply by ANDing with allowed, since these markers are never allowed) */

		 * It is needed if you want to ask the engine what type it is

		 * It should hopefully be the same as when you ask a vehicle what it is

		 * but using this, you can ask what type an engine number is

		 * even if it is not a vehicle (yet)*/

/** @file engine.h */

 * News system is realized as a FIFO queue (in an array)

 * The positions in the queue can't be rearranged, we only access

 * the array elements through pointers to the elements. Once the

 * array is full, the oldest entry (_oldest_news) is being overwritten

 * by the newest (_latest news).

 *

 * oldest                   current   lastest

 *  |                          |         |

 * [O------------F-------------C---------L           ]

 *               |

 *            forced

 * recent news. Returns INVALID_NEWS if end of queue reached. */

	 *   could be implemented this way:

	 * 1.) Go through all stations

	 *     Build an array town_blocked[ town_id ][ player_id ]

	 *     that stores if at least one station in that town is blocked for a player

	 * 2.) Go through that array, if you find a town that is not blocked for

	 *     one player, but for all others, then give him exclusivity.

/** @file order.h */

	 *  order number is one more than the current amount of orders, and because

	 *  in network the commands are queued before send, the second insert always

	 *  fails in test mode. By bypassing the test-mode, that no longer is a problem. */

		 *  vehicle which shares the same order-list, nothing will change. If

		 *  this is the last vehicle, the last line of the order-window

		 *  will change from Shared order list, to Order list, so it needs

		 *  an update */

			 *   Vehicle one had order[0], and as long as order++.type was not

			 *   OT_NOTHING, it was part of the order-list of that vehicle */

/** Finds out if a Player has a certain railtype available */

 * direction (corresponding to the Track enum) and 8-13 in the other direction. */

 * direction (corresponding to the Track enum) and 8-13 in the other direction. */

	 * The tile is non-flat AND

	 * 1) The AI is "old-school"

	 * 2) build-on-slopes is disabled

	 * 3) the tile is steep i.e. spans two height levels

	 * 4) the exit points in the wrong direction

	 *              and convert all others to semaphore/signal

 * A: competitors

 * B: start time in months / 3

 * C: town count (2 = high, 0 = low)

 * D: industry count (3 = high, 0 = none)

 * E: inital loan / 1000 (in GBP)

 * F: interest rate

 * G: running costs (0 = low, 2 = high)

 * H: construction speed of competitors (0 = very slow, 4 = very fast)

 * I: intelligence (0-2)

 * J: breakdowns (0 = off, 2 = normal)

 * K: subsidy multiplier (0 = 1.5, 3 = 4.0)

 * L: construction cost (0-2)

 * M: terrain type (0 = very flat, 3 = mountainous)

 * N: amount of water (0 = very low, 3 = high)

 * O: economy (0 = steady, 1 = fluctuating)

 * P: Train reversing (0 = end of line + stations, 1 = end of line)

 * Q: disasters

 * R: area restructuring (0 = permissive, 2 = hostile)

#if 0 /* Parameter edit box not used yet */

#endif

/** @file station_cmd.c */

 *  radius that is available within the station */

		 *   1) The tile is "steep" (i.e. stretches two height levels)

		 * -OR-

		 *   2) The tile is non-flat if

		 *     a) the player building is an "old-school" AI

		 *   -OR-

		 *     b) the build_on_slopes switch is disabled

 *  / \    / \    / \    / \   / \   / \

 * /  /\  /\  \  /===\  /   \ /|  \ /  |\

 * \/  /  \  \/  \   /  \===/ \|  / \  |/

 *  \ /    \ /    \ /    \ /   \ /   \ /

 *   0      1      2      3     4     5

 *  @see elrail.c */

 * This defines whether the X and or Y coordinate of a tile is even */

 * into account: the tile being drawn itself (the home tile, the one in

 * ti->tile), and the neighbouring tile */

 * the following system is used: if you rotate the PCP so that it is in the

 * north, the eastern PPP belongs to the tile. */

 * track, plus the point in extension of the track (to mark end-of-track). PCPs

 * which are not on either end of the track are fully preferred.

 * @see PCPpositions */

 * so there are certain tiles which we ignore. A straight line is found if

 * we have exactly two PPPs. */

 * assigns it to the home tile or neighbour tile */

static const int8 x_ppp_offsets[DIR_END] = {-3, -4, -3,  0,  3,  4,  3,  0};

static const int8 y_ppp_offsets[DIR_END] = {-3,  0,  3,  4,  3,  0, -3, -4};

 * a) none (should never happen)

 * b) the first

 * c) the second

 * d) both

 * PCP exists.*/

 * This file contails all sprite-related enums and defines. These consist mainly of

 * the sprite numbers and a bunch of masks and macros to handle sprites and to get

 * rid of all the magic numbers in the code.

 *

 * @NOTE:

 * ALL SPRITE NUMBERS BELOW 5126 are in the main files

 * SPR_CANALS_BASE is in canalsw.grf

 * SPR_SLOPES_BASE is in trkfoundw.grf

 * SPR_OPENTTD_BASE is in openttd.grf

 *

 * All elements which consist of two elements should

 * have the same name and then suffixes

 *   _GROUND and _BUILD for building-type sprites

 *   _REAR and _FRONT for transport-type sprites (tiles where vehicles are on)

 * These sprites are split because of the Z order of the elements

 *  (like some parts of a bridge are behind the vehicle, while others are before)

 *

 *

 * All sprites which are described here are referenced only one to a handful of times

 * throughout the code. When introducing new sprite enums, use meaningful names.

 * Don't be lazy and typing, and only use abbrevations when their meaning is clear or

 * the length of the enum would get out of hand. In that case EXPLAIN THE ABBREVATION

 * IN THIS FILE, and perhaps add some comments in the code where it is used.

 * Now, don't whine about this being too much typing work if the enums are like

 * 30 characters in length. If your editor doen't help you simplifying your work,

 * get a proper editor. If your Operating Systems don't have any decent editors,

 * get a proper Operating System.

 *

 * @todo Split the "Sprites" enum into smaller chunks and document them

	 * "short" denotes a wire that requires a pylon on each end. Third identifier is the direction of the slope

	 * (in positive coordinate direction) */

	 * can have

	 * TILE_A and TILE_B are the "beginnings" and "ends" of the

	 *   suspension system. they have small rectangluar endcaps

	 * TILE_C and TILE_D look almost identical to TILE_A and

	 *   TILE_B, but they do not have the "endcaps". They form the

	 *   middle part

	 * TILE_E is a condensed configuration of two pillars. while they

	 *   are usually 2 pillars apart, they only have 1 pillar separation

	 *   here

	 * TILE_F is an extended configuration of pillars. they are

	 *   plugged in when pillars should be 3 tiles apart

	 *  a start tile (with only half a tube on the far side, marked _BEG

	 *  a middle tile (full tunnel), marked _MID

	 *  and an end tile (half a tube on the near side, maked _END

/** @file town_land.h */

			 *  in those versions, they both were 4 bits big) to type and flags */

				 *  in both vehicles */

 *  array of fixed size arrays */