1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "functions.h"

     5

#include "map.h"

     6

     7

uint _map_log_x;

     8

uint _map_log_y;

     9

    10

byte   *_map_type_and_height = NULL;

    11

byte   *_map_owner           = NULL;

    12

uint16 *_map2                = NULL;

    13

byte   *_map3_lo             = NULL;

    14

byte   *_map3_hi             = NULL;

    15

byte   *_map5                = NULL;

    16

byte   *_map_extra_bits      = NULL;

    17

    18

    19

void InitMap(uint log_x, uint log_y)

    20

{

    21

	uint map_size;

    22

    23

	if (log_x < 6 || log_x > 11 || log_y < 6 || log_y > 11)

    24

		error("Invalid map size");

    25

    26

	DEBUG(map, 1)("Allocating map of size %dx%d", log_x, log_y);

    27

    28

	// XXX - MSVC6 volatile workaround

    29

	*(volatile uint*)&_map_log_x = log_x;

    30

	*(volatile uint*)&_map_log_y = log_y;

    31

    32

	map_size = MapSize();

    33

    34

	_map_type_and_height =

    35

		realloc(_map_type_and_height, map_size * sizeof(_map_type_and_height[0]));

    36

	_map_owner = realloc(_map_owner, map_size * sizeof(_map_owner[0]));

    37

	_map2      = realloc(_map2,      map_size * sizeof(_map2[0]));

    38

	_map3_lo   = realloc(_map3_lo,   map_size * sizeof(_map3_lo[0]));

    39

	_map3_hi   = realloc(_map3_hi,   map_size * sizeof(_map3_hi[0]));

    40

	_map5      = realloc(_map5,      map_size * sizeof(_map5[0]));

    41

	_map_extra_bits =

    42

		realloc(_map_extra_bits, map_size * sizeof(_map_extra_bits[0] / 4));

    43

    44

	// XXX TODO handle memory shortage more gracefully

    45

	if (_map_type_and_height == NULL ||

    46

			_map_owner           == NULL ||

    47

			_map2                == NULL ||

    48

			_map3_lo             == NULL ||

    49

			_map3_hi             == NULL ||

    50

			_map5                == NULL ||

    51

			_map_extra_bits      == NULL)

    52

		error("Failed to allocate memory for the map");

    53

}

    54

    55

    56

#ifdef _DEBUG

    57

TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

    58

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

    59

{

    60

	int dx;

    61

	int dy;

    62

	uint x;

    63

	uint y;

    64

    65

	dx = add & MapMaxX();

    66

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

    67

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

    68

    69

	x = TileX(tile) + dx;

    70

	y = TileY(tile) + dy;

    71

    72

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

    73

		char buf[512];

    74

    75

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

    76

			exp, tile, add);

    77

#if !defined(_MSC_VER)

    78

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

    79

#else

    80

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

    81

#endif

    82

	}

    83

    84

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

    85

    86

	return TILE_XY(x,y);

    87

}

    88

#endif

    89

    90

    91

uint ScaleByMapSize(uint n)

    92

{

    93

	int shift = (int)MapLogX() - 8 + (int)MapLogY() - 8;

    94

    95

	if (shift < 0)

    96

		return (n + (1 << -shift) - 1) >> -shift;

    97

	else

    98

		return n << shift;

    99

}

   100

   101

   102

uint ScaleByMapSize1D(uint n)

   103

{

   104

	int shift = ((int)MapLogX() - 8 + (int)MapLogY() - 8) / 2;

   105

   106

	if (shift < 0)

   107

		return (n + (1 << -shift) - 1) >> -shift;

   108

	else

   109

		return n << shift;

   110

}

   111

   112

   113

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

   114

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

   115

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

   116

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

   117

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

   118

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

   119

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

   120

{

   121

	uint x, y;

   122

	x = TileX(tile) + addx;

   123

	y = TileY(tile) + addy;

   124

   125

	// Are we about to wrap?

   126

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

   127

		return tile + TILE_XY(addx, addy);

   128

   129

	return INVALID_TILE;

   130

}

   131

   132

const TileIndexDiffC _tileoffs_by_dir[] = {

   133

	{-1,  0},

   134

	{ 0,  1},

   135

	{ 1,  0},

   136

	{ 0, -1}

   137

};

   138

   139

uint DistanceManhattan(TileIndex t0, TileIndex t1)

   140

{

   141

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

   142

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

   143

	return dx + dy;

   144

}

   145

   146

   147

uint DistanceSquare(TileIndex t0, TileIndex t1)

   148

{

   149

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

   150

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

   151

	return dx * dx + dy * dy;

   152

}

   153

   154

   155

uint DistanceMax(TileIndex t0, TileIndex t1)

   156

{

   157

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

   158

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

   159

	return dx > dy ? dx : dy;

   160

}

   161

   162

   163

uint DistanceMaxPlusManhattan(TileIndex t0, TileIndex t1)

   164

{

   165

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

   166

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

   167

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

   168

}

   169

   170

uint DistanceTrack(TileIndex t0, TileIndex t1)

   171

{

   172

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

   173

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

   174

   175

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

   176

	/* OPTIMISATION:

   177

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

   178

	 * Proof:

   179

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

   180

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

   181

   182

	return diagTracks + straightTracks * STRAIGHT_TRACK_LENGTH;

   183

}

   184

   185

uint DistanceFromEdge(TileIndex tile)

   186

{

   187

	const uint xl = TileX(tile);

   188

	const uint yl = TileY(tile);

   189

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

   190

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

   191

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

   192

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

   193

	return minl < minh ? minl : minh;

   194

}

   195