1

/* $Id$ */

     2

     3

/** @file map.h */

     4

     5

#ifndef MAP_H

     6

#define MAP_H

     7

     8

#include "stdafx.h"

     9

#include "direction_func.h"

    10

#include "tile_type.h"

    11

    12

extern uint _map_tile_mask;

    13

    14

/**

    15

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

    16

 * this by masking the 'high' bits of.

    17

 * @param x the tile to 'wrap'

    18

 */

    19

    20

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

    21

/**

    22

 * Asserts when the tile is outside of the map.

    23

 * @param x the tile to check

    24

 */

    25

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

    26

    27

/**

    28

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

    29

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

    30

 */

    31

struct Tile {

    32

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

    33

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

    34

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

    35

	byte m3;   ///< General purpose

    36

	byte m4;   ///< General purpose

    37

	byte m5;   ///< General purpose

    38

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

    39

};

    40

    41

/**

    42

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

    43

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

    44

 */

    45

struct TileExtended {

    46

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

    47

};

    48

    49

/**

    50

 * Pointer to the tile-array.

    51

 *

    52

 * This variable points to the tile-array which contains the tiles of

    53

 * the map.

    54

 */

    55

extern Tile *_m;

    56

    57

/**

    58

 * Pointer to the extended tile-array.

    59

 *

    60

 * This variable points to the extended tile-array which contains the tiles

    61

 * of the map.

    62

 */

    63

extern TileExtended *_me;

    64

    65

/**

    66

 * Allocate a new map with the given size.

    67

 */

    68

void AllocateMap(uint size_x, uint size_y);

    69

    70

/**

    71

 * Logarithm of the map size along the X side.

    72

 * @note try to avoid using this one

    73

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

    74

 */

    75

static inline uint MapLogX()

    76

{

    77

	extern uint _map_log_x;

    78

	return _map_log_x;

    79

}

    80

    81

/**

    82

 * Get the size of the map along the X

    83

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

    84

 */

    85

static inline uint MapSizeX()

    86

{

    87

	extern uint _map_size_x;

    88

	return _map_size_x;

    89

}

    90

    91

/**

    92

 * Get the size of the map along the Y

    93

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

    94

 */

    95

static inline uint MapSizeY()

    96

{

    97

	extern uint _map_size_y;

    98

	return _map_size_y;

    99

}

   100

   101

/**

   102

 * Get the size of the map

   103

 * @return the number of tiles of the map

   104

 */

   105

static inline uint MapSize()

   106

{

   107

	extern uint _map_size;

   108

	return _map_size;

   109

}

   110

   111

/**

   112

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

   113

 * @return the maximum X coordinate

   114

 */

   115

static inline uint MapMaxX()

   116

{

   117

	return MapSizeX() - 1;

   118

}

   119

   120

/**

   121

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

   122

 * @return the maximum X coordinate

   123

 */

   124

static inline uint MapMaxY()

   125

{

   126

	return MapSizeY() - 1;

   127

}

   128

   129

/**

   130

 * Scales relative to the number of tiles.

   131

 */

   132

uint ScaleByMapSize(uint);

   133

   134

/**

   135

 * Scale relative to the circumference of the map.

   136

 */

   137

uint ScaleByMapSize1D(uint);

   138

   139

/**

   140

 * An offset value between to tiles.

   141

 *

   142

 * This value is used fro the difference between

   143

 * to tiles. It can be added to a tileindex to get

   144

 * the resulting tileindex of the start tile applied

   145

 * with this saved difference.

   146

 *

   147

 * @see TileDiffXY(int, int)

   148

 */

   149

typedef int32 TileIndexDiff;

   150

   151

/**

   152

 * Returns the TileIndex of a coordinate.

   153

 *

   154

 * @param x The x coordinate of the tile

   155

 * @param y The y coordinate of the tile

   156

 * @return The TileIndex calculated by the coordinate

   157

 */

   158

static inline TileIndex TileXY(uint x, uint y)

   159

{

   160

	return (y * MapSizeX()) + x;

   161

}

   162

   163

/**

   164

 * Calculates an offset for the given coordinate(-offset).

   165

 *

   166

 * This function calculate an offset value which can be added to an

   167

 * #TileIndex. The coordinates can be negative.

   168

 *

   169

 * @param x The offset in x direction

   170

 * @param y The offset in y direction

   171

 * @return The resulting offset value of the given coordinate

   172

 * @see ToTileIndexDiff(TileIndexDiffC)

   173

 */

   174

static inline TileIndexDiff TileDiffXY(int x, int y)

   175

{

   176

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

   177

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

   178

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

   179

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

   180

	return (y * MapSizeX()) + x;

   181

}

   182

   183

static inline TileIndex TileVirtXY(uint x, uint y)

   184

{

   185

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

   186

}

   187

   188

   189

/**

   190

 * Get the X component of a tile

   191

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

   192

 * @return the X component

   193

 */

   194

static inline uint TileX(TileIndex tile)

   195

{

   196

	return tile & MapMaxX();

   197

}

   198

   199

/**

   200

 * Get the Y component of a tile

   201

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

   202

 * @return the Y component

   203

 */

   204

static inline uint TileY(TileIndex tile)

   205

{

   206

	return tile >> MapLogX();

   207

}

   208

   209

/**

   210

 * A pair-construct of a TileIndexDiff.

   211

 *

   212

 * This can be used to save the difference between to

   213

 * tiles as a pair of x and y value.

   214

 */

   215

struct TileIndexDiffC {

   216

	int16 x;        ///< The x value of the coordinate

   217

	int16 y;        ///< The y value of the coordinate

   218

};

   219

   220

/**

   221

 * Return the offset between to tiles from a TileIndexDiffC struct.

   222

 *

   223

 * This function works like #TileDiffXY(int, int) and returns the

   224

 * difference between two tiles.

   225

 *

   226

 * @param tidc The coordinate of the offset as TileIndexDiffC

   227

 * @return The difference between two tiles.

   228

 * @see TileDiffXY(int, int)

   229

 */

   230

static inline TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)

   231

{

   232

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

   233

}

   234

   235

   236

#ifndef _DEBUG

   237

        /**

   238

         * Adds to tiles together.

   239

         *

   240

         * @param x One tile

   241

         * @param y An other tile to add

   242

         * @return The resulting tile(index)

   243

         */

   244

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

   245

#else

   246

	extern TileIndex TileAdd(TileIndex tile, TileIndexDiff add,

   247

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

   248

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

   249

#endif

   250

   251

/**

   252

 * Adds a given offset to a tile.

   253

 *

   254

 * @param tile The tile to add an offset on it

   255

 * @param x The x offset to add to the tile

   256

 * @param y The y offset to add to the tile

   257

 */

   258

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

   259

   260

/**

   261

 * Adds an offset to a tile and check if we are still on the map.

   262

 */

   263

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

   264

   265

/**

   266

 * Returns the TileIndexDiffC offset from a DiagDirection.

   267

 *

   268

 * @param dir The given direction

   269

 * @return The offset as TileIndexDiffC value

   270

 */

   271

static inline TileIndexDiffC TileIndexDiffCByDiagDir(DiagDirection dir)

   272

{

   273

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   274

   275

	assert(IsValidDiagDirection(dir));

   276

	return _tileoffs_by_diagdir[dir];

   277

}

   278

/**

   279

 * Add a TileIndexDiffC to a TileIndex and returns the new one.

   280

 *

   281

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

   282

 * outside of the map, INVALID_TILE is returned instead.

   283

 *

   284

 * @param tile The base tile to add the offset on

   285

 * @param diff The offset to add on the tile

   286

 * @return The resulting TileIndex

   287

 */

   288

static inline TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)

   289

{

   290

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

   291

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

   292

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

   293

		return INVALID_TILE;

   294

	else

   295

		return TileXY(x, y);

   296

}

   297

   298

/**

   299

 * Returns the diff between two tiles

   300

 *

   301

 * @param tile_a from tile

   302

 * @param tile_b to tile

   303

 * @return the difference between tila_a and tile_b

   304

 */

   305

static inline TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)

   306

{

   307

	TileIndexDiffC difference;

   308

   309

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

   310

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

   311

   312

	return difference;

   313

}

   314

   315

/* Functions to calculate distances */

   316

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

   317

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

   318

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

   319

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

   320

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

   321

   322

/**

   323

 * Starts a loop which iterates to a square of tiles

   324

 *

   325

 * This macro starts 2 nested loops which iterates over a square of tiles.

   326

 *

   327

 * @param var The name of the variable which contains the current tile

   328

 * @param w The width (x-width) of the square

   329

 * @param h The heigth (y-width) of the square

   330

 * @param tile The start tile of the square

   331

 */

   332

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

   333

	{                                                        \

   334

		int h_cur = h;                                         \

   335

		uint var = tile;                                       \

   336

		do {                                                   \

   337

			int w_cur = w;                                       \

   338

			do {

   339

/**

   340

 * Ends the square-loop used before

   341

 *

   342

 * @see BEGIN_TILE_LOOP

   343

 */

   344

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

   345

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

   346

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

   347

	}

   348

/**

   349

 * Convert a DiagDirection to a TileIndexDiff

   350

 *

   351

 * @param dir The DiagDirection

   352

 * @return The resulting TileIndexDiff

   353

 * @see TileIndexDiffCByDiagDir

   354

 */

   355

static inline TileIndexDiff TileOffsByDiagDir(DiagDirection dir)

   356

{

   357

	extern const TileIndexDiffC _tileoffs_by_diagdir[DIAGDIR_END];

   358

   359

	assert(IsValidDiagDirection(dir));

   360

	return ToTileIndexDiff(_tileoffs_by_diagdir[dir]);

   361

}

   362

   363

/**

   364

 * Convert a Direction to a TileIndexDiff.

   365

 *

   366

 * @param dir The direction to convert from

   367

 * @return The resulting TileIndexDiff

   368

 */

   369

static inline TileIndexDiff TileOffsByDir(Direction dir)

   370

{

   371

	extern const TileIndexDiffC _tileoffs_by_dir[DIR_END];

   372

   373

	assert(IsValidDirection(dir));

   374

	return ToTileIndexDiff(_tileoffs_by_dir[dir]);

   375

}

   376

   377

/**

   378

 * Adds a DiagDir to a tile.

   379

 *

   380

 * @param tile The current tile

   381

 * @param dir The direction in which we want to step

   382

 * @return the moved tile

   383

 */

   384

static inline TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)

   385

{

   386

	return TILE_ADD(tile, TileOffsByDiagDir(dir));

   387

}

   388

   389

/**

   390

 * A callback function type for searching tiles.

   391

 *

   392

 * @param tile The tile to test

   393

 * @param data additional data for the callback function to use

   394

 * @return A boolean value, depend on the definition of the function.

   395

 */

   396

typedef bool TestTileOnSearchProc(TileIndex tile, uint32 data);

   397

   398

/**

   399

 * Searches for some cirumstances of a tile around a given tile with a helper function.

   400

 */

   401

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

   402

   403

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

   404

 * track (ie the size of a tile side).

   405

 *

   406

 * #defined instead of const so it can

   407

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

   408

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

   409

 * rounding! Be careful when using this!

   410

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

   411

#define STRAIGHT_TRACK_LENGTH 7071/10000

   412

   413

#endif /* MAP_H */