1

/* $Id$ */

     2

     3

/** @file map.h */

     4

     5

#ifndef MAP_H

     6

#define MAP_H

     7

     8

#include "stdafx.h"

     9

    10

extern uint _map_tile_mask;

    11

    12

/**

    13

 * 'Wraps' the given tile to it is within the map. It does

    14

 * this by masking the 'high' bits of.

    15

 * @param x the tile to 'wrap'

    16

 */

    17

    18

#define TILE_MASK(x) ((x) & _map_tile_mask)

    19

/**

    20

 * Asserts when the tile is outside of the map.

    21

 * @param x the tile to check

    22

 */

    23

#define TILE_ASSERT(x) assert(TILE_MASK(x) == (x));

    24

    25

/**

    26

 * Data that is stored per tile. Also used TileExtended for this.

    27

 * Look at docs/landscape.html for the exact meaning of the members.

    28

 */

    29

struct Tile {

    30

	byte type_height; ///< The type (bits 4..7) and height of the northern corner

    31

	byte m1;   ///< Primarily used for ownership information

    32

	uint16 m2; ///< Primarily used for indices to towns, industries and stations

    33

	byte m3;   ///< General purpose

    34

	byte m4;   ///< General purpose

    35

	byte m5;   ///< General purpose

    36

	byte m6;   ///< Primarily used for bridges and rainforest/desert

    37

};

    38

    39

/**

    40

 * Data that is stored per tile. Also used Tile for this.

    41

 * Look at docs/landscape.html for the exact meaning of the members.

    42

 */

    43

struct TileExtended {

    44

	byte m7; ///< Primarily used for newgrf support

    45

};

    46

    47

extern Tile *_m;

    48

extern TileExtended *_me;

    49

    50

void AllocateMap(uint size_x, uint size_y);

    51

    52

/**

    53

 * Logarithm of the map size along the X side.

    54

 * @note try to avoid using this one

    55

 * @return 2^"return value" == MapSizeX()

    56

 */

    57

static inline uint MapLogX()

    58

{

    59

	extern uint _map_log_x;

    60

	return _map_log_x;

    61

}

    62

    63

/**

    64

 * Get the size of the map along the X

    65

 * @return the number of tiles along the X of the map

    66

 */

    67

static inline uint MapSizeX()

    68

{

    69

	extern uint _map_size_x;

    70

	return _map_size_x;

    71

}

    72

    73

/**

    74

 * Get the size of the map along the Y

    75

 * @return the number of tiles along the Y of the map

    76

 */

    77

static inline uint MapSizeY()

    78

{

    79

	extern uint _map_size_y;

    80

	return _map_size_y;

    81

}

    82

    83

/**

    84

 * Get the size of the map

    85

 * @return the number of tiles of the map

    86

 */

    87

static inline uint MapSize()

    88

{

    89

	extern uint _map_size;

    90

	return _map_size;

    91

}

    92

    93

/**

    94

 * Gets the maximum X coordinate within the map, including MP_VOID

    95

 * @return the maximum X coordinate

    96

 */

    97

static inline uint MapMaxX()

    98

{

    99

	return MapSizeX() - 1;

   100

}

   101

   102

/**

   103

 * Gets the maximum X coordinate within the map, including MP_VOID

   104

 * @return the maximum X coordinate

   105

 */

   106

static inline uint MapMaxY()

   107

{

   108

	return MapSizeY() - 1;

   109

}

   110

   111

/* Scale a number relative to the map size */

   112

uint ScaleByMapSize(uint); // Scale relative to the number of tiles

   113

uint ScaleByMapSize1D(uint); // Scale relative to the circumference of the map

   114

   115

typedef uint32 TileIndex;

   116

typedef int32 TileIndexDiff;

   117

   118

static inline TileIndex TileXY(uint x, uint y)

   119

{

   120

	return (y * MapSizeX()) + x;

   121

}

   122

   123

static inline TileIndexDiff TileDiffXY(int x, int y)

   124

{

   125

	/* Multiplication gives much better optimization on MSVC than shifting.

   126

	 * 0 << shift isn't optimized to 0 properly.

   127

	 * Typically x and y are constants, and then this doesn't result

   128

	 * in any actual multiplication in the assembly code.. */

   129

	return (y * MapSizeX()) + x;

   130

}

   131

   132

static inline TileIndex TileVirtXY(uint x, uint y)

   133

{

   134

	return (y >> 4 << MapLogX()) + (x >> 4);

   135

}

   136

   137

   138

enum {

   139

	INVALID_TILE = (TileIndex)-1 ///< The very nice invalid tile marker

   140

};

   141

   142

enum {

   143

	TILE_SIZE   = 16,   ///< Tiles are 16x16 "units" in size

   144

	TILE_PIXELS = 32,   ///< a tile is 32x32 pixels

   145

	TILE_HEIGHT =  8,   ///< The standard height-difference between tiles on two levels is 8 (z-diff 8)

   146

};

   147

   148

   149

/**

   150

 * Get the X component of a tile

   151

 * @param tile the tile to get the X component of

   152

 * @return the X component

   153

 */

   154

static inline uint TileX(TileIndex tile)

   155

{

   156

	return tile & MapMaxX();

   157

}

   158

   159

/**

   160

 * Get the Y component of a tile

   161

 * @param tile the tile to get the Y component of

   162

 * @return the Y component

   163

 */

   164

static inline uint TileY(TileIndex tile)

   165

{

   166

	return tile >> MapLogX();

   167

}

   168

   169

   170

struct TileIndexDiffC {

   171

	int16 x;

   172

	int16 y;

   173

};

   174

   175

static inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)

   176

{

   177

	return (tidc.y << MapLogX()) + tidc.x;

   178

}

   179

   180

   181

#ifndef _DEBUG

   182

	#define TILE_ADD(x,y) ((x) + (y))

   183

#else

   184

	extern TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

   185

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

   186

	#define TILE_ADD(x, y) (TileAdd((x), (y), #x " + " #y, __FILE__, __LINE__))

   187

#endif

   188

   189

#define TILE_ADDXY(tile, x, y) TILE_ADD(tile, TileDiffXY(x, y))

   190

   191

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

   192

   193

static inline TileIndexDiffC TileIndexDiffCByDiagDir(uint dir) {

   194

	extern const TileIndexDiffC _tileoffs_by_diagdir[4];

   195

   196

	assert(dir < lengthof(_tileoffs_by_diagdir));

   197

	return _tileoffs_by_diagdir[dir];

   198

}

   199

   200

/* Returns tile + the diff given in diff. If the result tile would end up

   201

 * outside of the map, INVALID_TILE is returned instead.

   202

 */

   203

static inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff) {

   204

	int x = TileX(tile) + diff.x;

   205

	int y = TileY(tile) + diff.y;

   206

	if (x < 0 || y < 0 || x > (int)MapMaxX() || y > (int)MapMaxY())

   207

		return INVALID_TILE;

   208

	else

   209

		return TileXY(x, y);

   210

}

   211

   212

/**

   213

 * Returns the diff between two tiles

   214

 *

   215

 * @param tile_a from tile

   216

 * @param tile_b to tile

   217

 * @return the difference between tila_a and tile_b

   218

 */

   219

static inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)

   220

{

   221

	TileIndexDiffC difference;

   222

   223

	difference.x = TileX(tile_a) - TileX(tile_b);

   224

	difference.y = TileY(tile_a) - TileY(tile_b);

   225

   226

	return difference;

   227

}

   228

   229

/* Functions to calculate distances */

   230

uint DistanceManhattan(TileIndex, TileIndex); ///< also known as L1-Norm. Is the shortest distance one could go over diagonal tracks (or roads)

   231

uint DistanceSquare(TileIndex, TileIndex); ///< euclidian- or L2-Norm squared

   232

uint DistanceMax(TileIndex, TileIndex); ///< also known as L-Infinity-Norm

   233

uint DistanceMaxPlusManhattan(TileIndex, TileIndex); ///< Max + Manhattan

   234

uint DistanceFromEdge(TileIndex); ///< shortest distance from any edge of the map

   235

   236

   237

#define BEGIN_TILE_LOOP(var, w, h, tile)                      \

   238

	{                                                        \

   239

		int h_cur = h;                                         \

   240

		uint var = tile;                                       \

   241

		do {                                                   \

   242

			int w_cur = w;                                       \

   243

			do {

   244

   245

#define END_TILE_LOOP(var, w, h, tile)                        \

   246

			} while (++var, --w_cur != 0);                       \

   247

		} while (var += TileDiffXY(0, 1) - (w), --h_cur != 0); \

   248

	}

   249

   250

static inline TileIndexDiff TileOffsByDiagDir(uint dir)

   251

{

   252

	extern const TileIndexDiffC _tileoffs_by_diagdir[4];

   253

   254

	assert(dir < lengthof(_tileoffs_by_diagdir));

   255

	return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);

   256

}

   257

   258

static inline TileIndexDiff TileOffsByDir(uint dir)

   259

{

   260

	extern const TileIndexDiffC _tileoffs_by_dir[8];

   261

   262

	assert(dir < lengthof(_tileoffs_by_dir));

   263

	return ToTileIndexDiff(_tileoffs_by_dir[dir]);

   264

}

   265

   266

typedef bool TestTileOnSearchProc(TileIndex tile, uint32 data);

   267

bool CircularTileSearch(TileIndex tile, uint size, TestTileOnSearchProc proc, uint32 data);

   268

   269

/* Approximation of the length of a straight track, relative to a diagonal

   270

 * track (ie the size of a tile side). #defined instead of const so it can

   271

 * stay integer. (no runtime float operations) Is this needed?

   272

 * Watch out! There are _no_ brackets around here, to prevent intermediate

   273

 * rounding! Be careful when using this!

   274

 * This value should be sqrt(2)/2 ~ 0.7071 */

   275

#define STRAIGHT_TRACK_LENGTH 7071/10000

   276

   277

#endif /* MAP_H */