// Tests if a station can be build on the given spot

// TODO: make it train compatible

    Player *p = DEREF_PLAYER(_current_player);

    if (dir == TEST_STATION_NO_DIR) {

        // TODO: currently we only allow spots that can be access from al 4 directions...

#define TILES_BETWEEN(a, b, c) (TileX(a) >= TileX(b) && TileX(a) <= TileX(c) && TileY(a) >= TileY(b) && TileY(a) <= TileY(c))

// Check if the current tile is in our end-area

	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;

	// It is not allowed to have a station on the end of a bridge or tunnel ;)

	if (current->path.node.user_data[0] != 0) return AYSTAR_DONE;

// Calculates the hash

//   Currently it is a 10 bit hash, so the hash array has a max depth of 6 bits (so 64)

	return (TileX(key1) & 0x1F) + ((TileY(key1) & 0x1F) << 5);

}

// Clear the memory of all the things

	AyStarMain_Free(aystar);

	free(aystar);

}

#include "aystar.h"

// This looks in the Hash if a node exists in ClosedList

//  If so, it returns the PathNode, else NULL

	return (PathNode*)Hash_Get(&aystar->ClosedListHash, node->tile, node->direction);

}

// This adds a node to the ClosedList

//  It makes a copy of the data

	// Add a node to the ClosedList

	PathNode *new_node = malloc(sizeof(PathNode));

	*new_node = *node;

// Checks if a node is in the OpenList

//   If so, it returns the OpenListNode, else NULL

	return (OpenListNode*)Hash_Get(&aystar->OpenListHash, node->tile, node->direction);

}

// Gets the best node from OpenList

//  returns the best node, or NULL of none is found

// Also it deletes the node from the OpenList

	// Return the item the Queue returns.. the best next OpenList item.

	OpenListNode* res = (OpenListNode*)aystar->OpenListQueue.pop(&aystar->OpenListQueue);

	if (res != NULL)

// Adds a node to the OpenList

//  It makes a copy of node, and puts the pointer of parent in the struct

	// Add a new Node to the OpenList

	OpenListNode* new_node = malloc(sizeof(OpenListNode));

	new_node->g = g;

}

	static const int32 * _clear_price_table[] = {

			NULL,

			&_price.clear_1, &_price.clear_1,&_price.clear_1,

	DrawClearLandFence(ti, _map3_hi[ti->tile] >> 2);

}

{

	return ti->tileh;

}

	return NULL;

}

	char* lines[ICON_MAX_ALIAS_LINES];

	char* linestream;

	char* linestream_s;

/*  debug commands and variables */

/* ****************************************** */

{

	// debugging variables and functions

	extern bool _stdlib_con_developer; /* XXX extern in .c */

#include "news.h"

{

	if (engine < NUM_TRAIN_ENGINES) {

		switch (_engines[engine].railtype) {

	GfxFillRect(x-(w>>1), y+10, x-(w>>1)+w, y+10, _string_colorremap[1]);

}

	int num = 0;

	int base = _stringwidth_base;

	int w;

// direction=true:  check for foundation in east and south corner

// direction=false: check for foundation in west and south corner

{

	bool south, other; // southern corner and east/west corner

	uint slope = _tile_type_procs[ti->type]->get_slope_tileh_proc(ti);

void OnNewDay_RoadVeh(Vehicle *v);

void OnNewDay_Aircraft(Vehicle *v);

void OnNewDay_Ship(Vehicle *v);

void OnNewDay_DisasterVehicle(Vehicle *v);

typedef void OnNewVehicleDayProc(Vehicle *v);

}

// p1 -1 or +1 (down/up)

{

	if(p1==-1) p1 = 3;

	if(p1==4) p1 = 0;

extern void EnginesMonthlyLoop(void);

// p2 1 (increase) or -1 (decrease)

{

	YearMonthDay ymd;

	ConvertDayToYMD(&ymd, _date);

// There was a non-recoverable error, drop back to the main menu with a nice

//  error

{

	_switch_mode = SM_MENU;

	_switch_mode_errorstr = error_string;

//  this handles what to do.

// For clients: close connection and drop back to main-menu

// For servers: close connection and that is it

{

	NetworkCloseClient(cs);

extern void UpdateNetworkGameWindow(bool unselect);

{

	NetworkGameList *item;

	NetworkGameList *next;

	}

}

{

	// We queried a server and now we are going to add it to the list

	NetworkGameList *item;

// returns the correct index in the array

// (to deal with overflows)

{

	if (i == INVALID_NEWS)

		return 0;

}

/* Do a forced show of a specific message */

{

	if (_total_news == 0) return;

	return v;

}

{

	FindVehS fs;

	fs.tile = tile;

#include "ttd.h"

#include "queue.h"

{

	uint i;

	if (free_values)

	q->data.stack.size = 0;

}

{

	q->clear(q, free_values);

	free(q->data.stack.elements);

		free(q);

}

	if (q->data.stack.size == q->data.stack.max_size)

		return false;

	q->data.stack.elements[q->data.stack.size++] = item;

	return true;

}

	void* result;

	if (q->data.stack.size == 0)

		return NULL;

	return result;

}

{

	return false;

}

	q->push = Stack_Push;

	q->pop = Stack_Pop;

	q->del = Stack_Delete;

 * Fifo

 */

{

	uint head, tail;

	if (free_values) {

	q->data.fifo.head = q->data.fifo.tail = 0;

}

{

	q->clear(q, free_values);

	free(q->data.fifo.elements);

		free(q);

}

	uint next = (q->data.fifo.head + 1) % q->data.fifo.max_size;

	if (next == q->data.fifo.tail)

		return false;

	return true;

}

	void* result;

	if (q->data.fifo.head == q->data.fifo.tail)

		return NULL;

	return result;

}

{

	return false;

}

	q->push = Fifo_Push;

	q->pop = Fifo_Pop;

	q->del = Fifo_Delete;

 * Insertion Sorter

 */

	InsSortNode* node = q->data.inssort.first;

	InsSortNode* prev;

	while (node != NULL) {

	q->data.inssort.first = NULL;

}

{

	q->clear(q, free_values);

	if (q->freeq)

		free(q);

}

	InsSortNode* newnode = malloc(sizeof(InsSortNode));

	if (newnode == NULL) return false;

	newnode->item = item;

	return true;

}

	InsSortNode* node = q->data.inssort.first;

	void* result;

	if (node == NULL)

	return result;

}

{

	return false;

}

//  q->data.binaryheap.elements[i-1] every time, we use this define.

#define BIN_HEAP_ARR(i) q->data.binaryheap.elements[((i)-1) >> BINARY_HEAP_BLOCKSIZE_BITS][((i)-1) & BINARY_HEAP_BLOCKSIZE_MASK]

{

	/* Free all items if needed and free all but the first blocks of

	 * memory */

	q->data.binaryheap.blocks = 1;

}

{

	uint i;

	q->clear(q, free_values);

		free(q);

}

	#ifdef QUEUE_DEBUG

			printf("[BinaryHeap] Pushing an element. There are %d elements left\n", q->data.binaryheap.size);

	#endif

	return true;

}

{

	#ifdef QUEUE_DEBUG

			printf("[BinaryHeap] Deleting an element. There are %d elements left\n", q->data.binaryheap.size);

	return true;

}

	#ifdef QUEUE_DEBUG

			printf("[BinaryHeap] Popping an element. There are %d elements left\n", q->data.binaryheap.size);

	#endif

 * bucket, or NULL if it is empty. prev can also be NULL, in which case it is

 * not used for output.

 */

	uint hash = h->hash(key1, key2);

	HashNode* result = NULL;

	#ifdef HASH_DEBUG

	return z;

}

{

	// check if it's a foundation

	if (ti->tileh != 0) {

void RoadVehEnterDepot(Vehicle *v);

{

	int mask;

	byte b;

	return z; // normal Z if no slope

}

{

	// check if it's a foundation

	if (ti->tileh != 0) {

	byte dir;

} RoadVehFindData;

{

	static const short _dists[] = {

		-4, -8, -4, -1, 4, 8, 4, 1,

	byte tilebits;

} OvertakeData;

{

	if (v->tile != (TileIndex)od->tile ||

			v->type != VEH_Road ||

	return (i>=0x80) ? 2 : 1;

}

{

	return SlReadSimpleGamma();

}

{

	SlWriteSimpleGamma(index);

}

{

	return SlReadSimpleGamma();

}

{

	SlWriteSimpleGamma(length);

}

	}

}

{

	while (length) {

		SlReadByte();

	return 0;

}

{

	/* From version 4.3 REF_VEHICLE_OLD is saved as REF_VEHICLE, and should be loaded

	    like that */

}

// virtual PositionMainToolbar function, calls the right one.

{

	if (_game_mode != GM_MENU)

		PositionMainToolbar(NULL);

	return 0;

}

{

  if (p1 == 1)

    ShowErrorMessage(-1, TEMP_AI_ACTIVATED, 0, 0);

  return 0;

}

{

	Town *t;

	return 0;

}

{

	MarkWholeScreenDirty();

	return 0;

}

{

	InvalidateWindowClasses(WC_VEHICLE_DETAILS);

	return 0;

}

/* Check service intervals of vehicles, p1 is value of % or day based servicing */

{

	bool warning;

	if (p1) {

	VpStartPlaceSizing(tile, VPM_X_AND_Y | (2<<4));

}

{

}

} TrainCollideChecker;

{

	if (v == tcc->v || v == tcc->v_skip || v->type != VEH_Train || v->u.rail.track==0x80)

		return 0;

static const byte _depot_track_ind[4] = {0,1,0,1};

// Validation for the news item "Train is waiting in depot"

{

	Vehicle *v = GetVehicle(data_a);

	return  (v->u.rail.track == 0x80 && (v->vehstatus | VS_STOPPED));

	*dst = 0;

}

{

	while ( (*dst++ = *src++) != 0) {}

	return dst - 1;

	}

}

{

	char *t = strchr(s, 'x');

	if (t == NULL) {

}

{

	char filename[256];

	_game_mode = GM_MENU;

}

{

	_game_mode = GM_NORMAL;

void StartupPlayers(void);

void StartupDisasters(void);

{

	_game_mode = GM_NORMAL;

	}

}

{

	uint tile;

}

// before savegame version 4, the name of the company determined if it existed

{

	Player *p;

	FOR_ALL_PLAYERS(p) {

}

// since savegame version 4.1, exclusive transport rights are stored at towns

{

	Town *t;

	FOR_ALL_TOWNS(t) if (t->xy != 0) {

	18,  2, 20, };

// since savegame version 4.2 the currencies are arranged differently

{

	_opt.currency = convert_currency[_opt.currency];

}

// up to revision 1413, the invisible tiles at the southern border have not been MP_VOID

// even though they should have. This is fixed by this function

{

	uint i;

	// create void tiles on the border

// fast routine for getting the height of a middle bridge tile. 'tile' MUST be a middle bridge tile.

{

	uint delta;

	TileInfo ti_end;

	return NULL;

}

	int z;

	Point pt;

	int a,b;

void HandleClickOnRoadVeh(Vehicle *v);

void HandleClickOnAircraft(Vehicle *v);

void HandleClickOnShip(Vehicle *v);

void HandleClickOnDisasterVeh(Vehicle *v);

typedef void OnVehicleClickProc(Vehicle *v);

static OnVehicleClickProc * const _on_vehicle_click_proc[6] = {

	return item;

}

{

	int item;

	return true;

}

	Window *w;

	Point pt;