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

#if defined(_MSC_VER) && _MSC_VER >= 1400 /* VStudio 2005 is stupid! */

    11

/* Why the hell is that not in all MSVC headers?? */

    12

_CRTIMP void __cdecl _assert(void *, void *, unsigned);

    13

#endif

    14

    15

uint _map_log_x;

    16

uint _map_size_x;

    17

uint _map_size_y;

    18

uint _map_tile_mask;

    19

uint _map_size;

    20

    21

Tile* _m = NULL;

    22

    23

    24

void AllocateMap(uint size_x, uint size_y)

    25

{

    26

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

    27

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

    28

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

    29

			size_y < 64 || size_y > 2048 ||

    30

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

    31

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

    32

		error("Invalid map size");

    33

    34

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

    35

    36

	_map_log_x = FindFirstBit(size_x);

    37

	_map_size_x = size_x;

    38

	_map_size_y = size_y;

    39

	_map_size = size_x * size_y;

    40

	_map_tile_mask = _map_size - 1;

    41

    42

	free(_m);

    43

	_m = calloc(_map_size, sizeof(*_m));

    44

    45

	// XXX TODO handle memory shortage more gracefully

    46

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

    47

}

    48

    49

    50

#ifdef _DEBUG

    51

TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

    52

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

    53

{

    54

	int dx;

    55

	int dy;

    56

	uint x;

    57

	uint y;

    58

    59

	dx = add & MapMaxX();

    60

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

    61

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

    62

    63

	x = TileX(tile) + dx;

    64

	y = TileY(tile) + dy;

    65

    66

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

    67

		char buf[512];

    68

    69

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

    70

			exp, tile, add);

    71

#if !defined(_MSC_VER)

    72

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

    73

#else

    74

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

    75

#endif

    76

	}

    77

    78

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

    79

    80

	return TileXY(x,y);

    81

}

    82

#endif

    83

    84

    85

uint ScaleByMapSize(uint n)

    86

{

    87

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

    88

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

    89

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

    90

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

    91

}

    92

    93

    94

// Scale relative to the circumference of the map

    95

uint ScaleByMapSize1D(uint n)

    96

{

    97

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

    98

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

    99

	// just half of it.

   100

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

   101

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

   102

}

   103

   104

   105

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

   106

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

   107

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

   108

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

   109

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

   110

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

   111

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

   112

{

   113

	uint x = TileX(tile) + addx;

   114

	uint y = TileY(tile) + addy;

   115

   116

	// Are we about to wrap?

   117

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

   118

		return tile + TileDiffXY(addx, addy);

   119

   120

	return INVALID_TILE;

   121

}

   122

   123

const TileIndexDiffC _tileoffs_by_diagdir[] = {

   124

	{-1,  0}, // DIAGDIR_NE

   125

	{ 0,  1}, // DIAGDIR_SE

   126

	{ 1,  0}, // DIAGDIR_SW

   127

	{ 0, -1}  // DIAGDIR_NW

   128

};

   129

   130

const TileIndexDiffC _tileoffs_by_dir[] = {

   131

	{-1, -1}, // DIR_N

   132

	{-1,  0}, // DIR_NE

   133

	{-1,  1}, // DIR_E

   134

	{ 0,  1}, // DIR_SE

   135

	{ 1,  1}, // DIR_S

   136

	{ 1,  0}, // DIR_SW

   137

	{ 1, -1}, // DIR_W

   138

	{ 0, -1}  // DIR_NW

   139

};

   140

   141

uint DistanceManhattan(TileIndex t0, TileIndex t1)

   142

{

   143

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

   144

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

   145

	return dx + dy;

   146

}

   147

   148

   149

uint DistanceSquare(TileIndex t0, TileIndex t1)

   150

{

   151

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

   152

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

   153

	return dx * dx + dy * dy;

   154

}

   155

   156

   157

uint DistanceMax(TileIndex t0, TileIndex t1)

   158

{

   159

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

   160

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

   161

	return dx > dy ? dx : dy;

   162

}

   163

   164

   165

uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)

   166

{

   167

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

   168

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

   169

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

   170

}

   171

   172

uint DistanceFromEdge(TileIndex tile)

   173

{

   174

	const uint xl = TileX(tile);

   175

	const uint yl = TileY(tile);

   176

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

   177

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

   178

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

   179

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

   180

	return minl < minh ? minl : minh;

   181

}