1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "macros.h"

     8

#include "map.h"

     9

    10

uint _map_log_x;

    11

uint _map_size_x;

    12

uint _map_size_y;

    13

uint _map_tile_mask;

    14

uint _map_size;

    15

    16

Tile* _m = NULL;

    17

    18

    19

void AllocateMap(uint size_x, uint size_y)

    20

{

    21

	// Make sure that the map size is within the limits and that

    22

	// the x axis size is a power of 2.

    23

	if (size_x < 64 || size_x > 2048 ||

    24

			size_y < 64 || size_y > 2048 ||

    25

			(size_x&(size_x-1)) != 0 ||

    26

			(size_y&(size_y-1)) != 0)

    27

		error("Invalid map size");

    28

    29

	DEBUG(map, 1)("Allocating map of size %dx%d", size_x, size_y);

    30

    31

	_map_log_x = FindFirstBit(size_x);

    32

	_map_size_x = size_x;

    33

	_map_size_y = size_y;

    34

	_map_size = size_x * size_y;

    35

	_map_tile_mask = _map_size - 1;

    36

    37

	// free/malloc uses less memory than realloc.

    38

	free(_m);

    39

	_m = malloc(_map_size * sizeof(*_m));

    40

    41

	// XXX TODO handle memory shortage more gracefully

    42

	if (_m == NULL) error("Failed to allocate memory for the map");

    43

}

    44

    45

    46

#ifdef _DEBUG

    47

TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

    48

	const char *exp, const char *file, int line)

    49

{

    50

	int dx;

    51

	int dy;

    52

	uint x;

    53

	uint y;

    54

    55

	dx = add & MapMaxX();

    56

	if (dx >= (int)MapSizeX() / 2) dx -= MapSizeX();

    57

	dy = (add - dx) / (int)MapSizeX();

    58

    59

	x = TileX(tile) + dx;

    60

	y = TileY(tile) + dy;

    61

    62

	if (x >= MapSizeX() || y >= MapSizeY()) {

    63

		char buf[512];

    64

    65

		sprintf(buf, "TILE_ADD(%s) when adding 0x%.4X and 0x%.4X failed",

    66

			exp, tile, add);

    67

#if !defined(_MSC_VER)

    68

		fprintf(stderr, "%s:%d %s\n", file, line, buf);

    69

#else

    70

		_assert(buf, (char*)file, line);

    71

#endif

    72

	}

    73

    74

	assert(TileXY(x,y) == TILE_MASK(tile + add));

    75

    76

	return TileXY(x,y);

    77

}

    78

#endif

    79

    80

    81

uint ScaleByMapSize(uint n)

    82

{

    83

	// First shift by 12 to prevent integer overflow for large values of n.

    84

	// >>12 is safe since the min mapsize is 64x64

    85

	// Add (1<<4)-1 to round upwards.

    86

	return (n * (MapSize() >> 12) + (1<<4) - 1) >> 4;

    87

}

    88

    89

    90

// Scale relative to the circumference of the map

    91

uint ScaleByMapSize1D(uint n)

    92

{

    93

	// Normal circumference for the X+Y is 256+256 = 1<<9

    94

	// Note, not actually taking the full circumference into account,

    95

	// just half of it.

    96

	// (1<<9) - 1 is there to scale upwards.

    97

	return (n * (MapSizeX() + MapSizeY()) + (1<<9) - 1) >> 9;

    98

}

    99

   100

   101

// This function checks if we add addx/addy to tile, if we

   102

//  do wrap around the edges. For example, tile = (10,2) and

   103

//  addx = +3 and addy = -4. This function will now return

   104

//  INVALID_TILE, because the y is wrapped. This is needed in

   105

//  for example, farmland. When the tile is not wrapped,

   106

//  the result will be tile + TileDiffXY(addx, addy)

   107

uint TileAddWrap(TileIndex tile, int addx, int addy)

   108

{

   109

	uint x, y;

   110

	x = TileX(tile) + addx;

   111

	y = TileY(tile) + addy;

   112

   113

	// Are we about to wrap?

   114

	if (x < MapMaxX() && y < MapMaxY())

   115

		return tile + TileDiffXY(addx, addy);

   116

   117

	return INVALID_TILE;

   118

}

   119

   120

const TileIndexDiffC _tileoffs_by_dir[] = {

   121

	{-1,  0},

   122

	{ 0,  1},

   123

	{ 1,  0},

   124

	{ 0, -1}

   125

};

   126

   127

uint DistanceManhattan(TileIndex t0, TileIndex t1)

   128

{

   129

	const uint dx = abs(TileX(t0) - TileX(t1));

   130

	const uint dy = abs(TileY(t0) - TileY(t1));

   131

	return dx + dy;

   132

}

   133

   134

   135

uint DistanceSquare(TileIndex t0, TileIndex t1)

   136

{

   137

	const int dx = TileX(t0) - TileX(t1);

   138

	const int dy = TileY(t0) - TileY(t1);

   139

	return dx * dx + dy * dy;

   140

}

   141

   142

   143

uint DistanceMax(TileIndex t0, TileIndex t1)

   144

{

   145

	const uint dx = abs(TileX(t0) - TileX(t1));

   146

	const uint dy = abs(TileY(t0) - TileY(t1));

   147

	return dx > dy ? dx : dy;

   148

}

   149

   150

   151

uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)

   152

{

   153

	const uint dx = abs(TileX(t0) - TileX(t1));

   154

	const uint dy = abs(TileY(t0) - TileY(t1));

   155

	return dx > dy ? 2 * dx + dy : 2 * dy + dx;

   156

}

   157

   158

uint DistanceTrack(TileIndex t0, TileIndex t1)

   159

{

   160

	const uint dx = abs(TileX(t0) - TileX(t1));

   161

	const uint dy = abs(TileY(t0) - TileY(t1));

   162

   163

	const uint straightTracks = 2 * min(dx, dy); /* The number of straight (not full length) tracks */

   164

	/* OPTIMISATION:

   165

	 * Original: diagTracks = max(dx, dy) - min(dx,dy);

   166

	 * Proof:

   167

	 * (dx-dy) - straightTracks  == (min + max) - straightTracks = min + // max - 2 * min = max - min */

   168

	const uint diagTracks = dx + dy - straightTracks; /* The number of diagonal (full tile length) tracks. */

   169

   170

	return diagTracks + straightTracks * STRAIGHT_TRACK_LENGTH;

   171

}

   172

   173

uint DistanceFromEdge(TileIndex tile)

   174

{

   175

	const uint xl = TileX(tile);

   176

	const uint yl = TileY(tile);

   177

	const uint xh = MapSizeX() - 1 - xl;

   178

	const uint yh = MapSizeY() - 1 - yl;

   179

	const uint minl = xl < yl ? xl : yl;

   180

	const uint minh = xh < yh ? xh : yh;

   181

	return minl < minh ? minl : minh;

   182

}

   183