1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "bridge_map.h"

     6

#include "clear_map.h"

     7

#include "functions.h"

     8

#include "spritecache.h"

     9

#include "table/strings.h"

    10

#include "table/sprites.h"

    11

#include "map.h"

    12

#include "tile.h"

    13

#include "gui.h"

    14

#include "tree_map.h"

    15

#include "tunnel_map.h"

    16

#include "window.h"

    17

#include "gfx.h"

    18

#include "viewport.h"

    19

#include "player.h"

    20

#include "vehicle.h"

    21

#include "town.h"

    22

#include "sound.h"

    23

#include "variables.h"

    24

    25

static const Widget _smallmap_widgets[] = {

    26

{  WWT_CLOSEBOX,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5,                STR_018B_CLOSE_WINDOW},

    27

{   WWT_CAPTION,  RESIZE_RIGHT,    13,    11,   433,     0,    13, STR_00B0_MAP,            STR_018C_WINDOW_TITLE_DRAG_THIS},

    28

{ WWT_STICKYBOX,     RESIZE_LR,    13,   434,   445,     0,    13, 0x0,                     STR_STICKY_BUTTON},

    29

{     WWT_PANEL,     RESIZE_RB,    13,     0,   445,    14,   257, 0x0,                     STR_NULL},

    30

{         WWT_6,     RESIZE_RB,    13,     2,   443,    16,   255, 0x0,                     STR_NULL},

    31

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   258,   279, SPR_IMG_SHOW_COUNTOURS,  STR_0191_SHOW_LAND_CONTOURS_ON_MAP},

    32

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   258,   279, SPR_IMG_SHOW_VEHICLES,   STR_0192_SHOW_VEHICLES_ON_MAP},

    33

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   258,   279, SPR_IMG_INDUSTRY,        STR_0193_SHOW_INDUSTRIES_ON_MAP},

    34

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   280,   301, SPR_IMG_SHOW_ROUTES,     STR_0194_SHOW_TRANSPORT_ROUTES_ON},

    35

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   280,   301, SPR_IMG_PLANTTREES,      STR_0195_SHOW_VEGETATION_ON_MAP},

    36

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   280,   301, SPR_IMG_COMPANY_GENERAL, STR_0196_SHOW_LAND_OWNERS_ON_MAP},

    37

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   258,   279, 0x0,                     STR_NULL},

    38

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   280,   301, SPR_IMG_TOWN,            STR_0197_TOGGLE_TOWN_NAMES_ON_OFF},

    39

{    WWT_IMGBTN,    RESIZE_RTB,    13,     0,   357,   258,   301, 0x0,                     STR_NULL},

    40

{     WWT_PANEL,    RESIZE_RTB,    13,     0,   433,   302,   313, 0x0,                     STR_NULL},

    41

{ WWT_RESIZEBOX,   RESIZE_LRTB,    13,   434,   445,   302,   313, 0x0,                     STR_RESIZE_BUTTON},

    42

{  WIDGETS_END},

    43

};

    44

    45

static int _smallmap_type;

    46

static bool _smallmap_show_towns = true;

    47

    48

#define MK(a,b) a, b

    49

#define MKEND() 0xFFFF

    50

#define MS(a,b) (a | 0x100), b

    51

    52

/* Legend text giving the colours to look for on the minimap */

    53

static const uint16 _legend_land_contours[] = {

    54

	MK(0x5A,STR_00F0_100M),

    55

	MK(0x5C,STR_00F1_200M),

    56

	MK(0x5E,STR_00F2_300M),

    57

	MK(0x1F,STR_00F3_400M),

    58

	MK(0x27,STR_00F4_500M),

    59

    60

	MS(0xD7,STR_00EB_ROADS),

    61

	MK(0x0A,STR_00EC_RAILROADS),

    62

	MK(0x98,STR_00ED_STATIONS_AIRPORTS_DOCKS),

    63

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    64

	MK(0x0F,STR_00EF_VEHICLES),

    65

	MKEND()

    66

};

    67

    68

static const uint16 _legend_vehicles[] = {

    69

	MK(0xB8,STR_00F5_TRAINS),

    70

	MK(0xBF,STR_00F6_ROAD_VEHICLES),

    71

	MK(0x98,STR_00F7_SHIPS),

    72

	MK(0x0F,STR_00F8_AIRCRAFT),

    73

	MS(0xD7,STR_00F9_TRANSPORT_ROUTES),

    74

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    75

	MKEND()

    76

};

    77

    78

static const uint16 _legend_industries_normal[] = {

    79

	MK(0xD7,STR_00FA_COAL_MINE),

    80

	MK(0xB8,STR_00FB_POWER_STATION),

    81

	MK(0x56,STR_00FC_FOREST),

    82

	MK(0xC2,STR_00FD_SAWMILL),

    83

	MK(0xBF,STR_00FE_OIL_REFINERY),

    84

	MK(0x0F,STR_0105_BANK),

    85

    86

	MS(0x30,STR_00FF_FARM),

    87

	MK(0xAE,STR_0100_FACTORY),

    88

	MK(0x98,STR_0102_OIL_WELLS),

    89

	MK(0x37,STR_0103_IRON_ORE_MINE),

    90

	MK(0x0A,STR_0104_STEEL_MILL),

    91

	MKEND()

    92

};

    93

    94

static const uint16 _legend_industries_hilly[] = {

    95

	MK(0xD7,STR_00FA_COAL_MINE),

    96

	MK(0xB8,STR_00FB_POWER_STATION),

    97

	MK(0x56,STR_00FC_FOREST),

    98

	MK(0x0A,STR_0106_PAPER_MILL),

    99

	MK(0xBF,STR_00FE_OIL_REFINERY),

   100

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   101

	MS(0x30,STR_00FF_FARM),

   102

   103

	MK(0xAE,STR_0101_PRINTING_WORKS),

   104

	MK(0x98,STR_0102_OIL_WELLS),

   105

	MK(0xC2,STR_0107_GOLD_MINE),

   106

	MK(0x0F,STR_0105_BANK),

   107

	MKEND()

   108

};

   109

   110

static const uint16 _legend_industries_desert[] = {

   111

	MK(0xBF,STR_00FE_OIL_REFINERY),

   112

	MK(0x98,STR_0102_OIL_WELLS),

   113

	MK(0x0F,STR_0105_BANK),

   114

	MK(0xB8,STR_0109_DIAMOND_MINE),

   115

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   116

	MK(0x0A,STR_010A_COPPER_ORE_MINE),

   117

	MK(0x30,STR_00FF_FARM),

   118

	MS(0x56,STR_010B_FRUIT_PLANTATION),

   119

   120

	MK(0x27,STR_010C_RUBBER_PLANTATION),

   121

	MK(0x25,STR_010D_WATER_SUPPLY),

   122

	MK(0xD0,STR_010E_WATER_TOWER),

   123

	MK(0xAE,STR_0100_FACTORY),

   124

	MK(0xC2,STR_010F_LUMBER_MILL),

   125

	MKEND()

   126

};

   127

   128

static const uint16 _legend_industries_candy[] = {

   129

	MK(0x30,STR_0110_COTTON_CANDY_FOREST),

   130

	MK(0xAE,STR_0111_CANDY_FACTORY),

   131

	MK(0x27,STR_0112_BATTERY_FARM),

   132

	MK(0x37,STR_0113_COLA_WELLS),

   133

	MK(0xD0,STR_0114_TOY_SHOP),

   134

	MK(0x0A,STR_0115_TOY_FACTORY),

   135

	MS(0x25,STR_0116_PLASTIC_FOUNTAINS),

   136

   137

	MK(0xB8,STR_0117_FIZZY_DRINK_FACTORY),

   138

	MK(0x98,STR_0118_BUBBLE_GENERATOR),

   139

	MK(0xC2,STR_0119_TOFFEE_QUARRY),

   140

	MK(0x0F,STR_011A_SUGAR_MINE),

   141

	MKEND()

   142

};

   143

   144

static const uint16 _legend_routes[] = {

   145

	MK(0xD7,STR_00EB_ROADS),

   146

	MK(0x0A,STR_00EC_RAILROADS),

   147

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   148

	MS(0x56,STR_011B_RAILROAD_STATION),

   149

   150

	MK(0xC2,STR_011C_TRUCK_LOADING_BAY),

   151

	MK(0xBF,STR_011D_BUS_STATION),

   152

	MK(0xB8,STR_011E_AIRPORT_HELIPORT),

   153

	MK(0x98,STR_011F_DOCK),

   154

	MKEND()

   155

};

   156

   157

static const uint16 _legend_vegetation[] = {

   158

	MK(0x52,STR_0120_ROUGH_LAND),

   159

	MK(0x54,STR_0121_GRASS_LAND),

   160

	MK(0x37,STR_0122_BARE_LAND),

   161

	MK(0x25,STR_0123_FIELDS),

   162

	MK(0x57,STR_0124_TREES),

   163

	MK(0xD0,STR_00FC_FOREST),

   164

	MS(0x0A,STR_0125_ROCKS),

   165

   166

	MK(0xC2,STR_012A_DESERT),

   167

	MK(0x98,STR_012B_SNOW),

   168

	MK(0xD7,STR_00F9_TRANSPORT_ROUTES),

   169

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   170

	MKEND()

   171

};

   172

   173

static const uint16 _legend_land_owners[] = {

   174

	MK(0xCA,STR_0126_WATER),

   175

	MK(0x54,STR_0127_NO_OWNER),

   176

	MK(0xB4,STR_0128_TOWNS),

   177

	MK(0x20,STR_0129_INDUSTRIES),

   178

	MKEND()

   179

};

   180

#undef MK

   181

#undef MS

   182

#undef MKEND

   183

   184

   185

enum { IND_OFFS = 6 };

   186

static const uint16 * const _legend_table[] = {

   187

	_legend_land_contours,

   188

	_legend_vehicles,

   189

	NULL,

   190

	_legend_routes,

   191

	_legend_vegetation,

   192

	_legend_land_owners,

   193

   194

	_legend_industries_normal,

   195

	_legend_industries_hilly,

   196

	_legend_industries_desert,

   197

	_legend_industries_candy,

   198

};

   199

   200

#if defined(OTTD_ALIGNMENT)

   201

	static inline void WRITE_PIXELS(Pixel* d, uint32 val)

   202

	{

   203

#	if defined(TTD_BIG_ENDIAN)

   204

		d[0] = GB(val, 24, 8);

   205

		d[1] = GB(val, 16, 8);

   206

		d[2] = GB(val,  8, 8);

   207

		d[3] = GB(val,  0, 8);

   208

#	elif defined(TTD_LITTLE_ENDIAN)

   209

		d[0] = GB(val,  0, 8);

   210

		d[1] = GB(val,  8, 8);

   211

		d[2] = GB(val, 16, 8);

   212

		d[3] = GB(val, 24, 8);

   213

#	endif

   214

	}

   215

   216

/* need to use OR, otherwise we will overwrite the wrong pixels at the edges :( */

   217

	static inline void WRITE_PIXELS_OR(Pixel* d, uint32 val)

   218

	{

   219

#	if defined(TTD_BIG_ENDIAN)

   220

		d[0] |= GB(val, 24, 8);

   221

		d[1] |= GB(val, 16, 8);

   222

		d[2] |= GB(val,  8, 8);

   223

		d[3] |= GB(val,  0, 8);

   224

#	elif defined(TTD_LITTLE_ENDIAN)

   225

		d[0] |= GB(val,  0, 8);

   226

		d[1] |= GB(val,  8, 8);

   227

		d[2] |= GB(val, 16, 8);

   228

		d[3] |= GB(val, 24, 8);

   229

#	endif

   230

	}

   231

#else

   232

#	define WRITE_PIXELS(dst, val)		*(uint32*)(dst) = (val);

   233

#	define WRITE_PIXELS_OR(dst,val)	*(uint32*)(dst) |= (val);

   234

#endif

   235

   236

#define MKCOLOR(x) TO_LE32X(x)

   237

   238

/* Height encodings; 16 levels XXX - needs updating for more/finer heights! */

   239

static const uint32 _map_height_bits[16] = {

   240

	MKCOLOR(0x5A5A5A5A),

   241

	MKCOLOR(0x5A5B5A5B),

   242

	MKCOLOR(0x5B5B5B5B),

   243

	MKCOLOR(0x5B5C5B5C),

   244

	MKCOLOR(0x5C5C5C5C),

   245

	MKCOLOR(0x5C5D5C5D),

   246

	MKCOLOR(0x5D5D5D5D),

   247

	MKCOLOR(0x5D5E5D5E),

   248

	MKCOLOR(0x5E5E5E5E),

   249

	MKCOLOR(0x5E5F5E5F),

   250

	MKCOLOR(0x5F5F5F5F),

   251

	MKCOLOR(0x5F1F5F1F),

   252

	MKCOLOR(0x1F1F1F1F),

   253

	MKCOLOR(0x1F271F27),

   254

	MKCOLOR(0x27272727),

   255

	MKCOLOR(0x27272727),

   256

};

   257

   258

typedef struct AndOr {

   259

	uint32 mor;

   260

	uint32 mand;

   261

} AndOr;

   262

   263

static inline uint32 ApplyMask(uint32 colour, const AndOr* mask)

   264

{

   265

	return (colour & mask->mand) | mask->mor;

   266

}

   267

   268

   269

static const AndOr _smallmap_contours_andor[] = {

   270

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   271

	{MKCOLOR(0x000A0A00),MKCOLOR(0xFF0000FF)},

   272

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   273

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   274

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   275

	{MKCOLOR(0x98989898),MKCOLOR(0x00000000)},

   276

	{MKCOLOR(0xCACACACA),MKCOLOR(0x00000000)},

   277

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   278

	{MKCOLOR(0xB5B5B5B5),MKCOLOR(0x00000000)},

   279

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   280

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   281

	{MKCOLOR(0x000A0A00),MKCOLOR(0xFF0000FF)},

   282

};

   283

   284

static const AndOr _smallmap_vehicles_andor[] = {

   285

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   286

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   287

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   288

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   289

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   290

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   291

	{MKCOLOR(0xCACACACA),MKCOLOR(0x00000000)},

   292

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   293

	{MKCOLOR(0xB5B5B5B5),MKCOLOR(0x00000000)},

   294

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   295

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   296

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   297

};

   298

   299

static const AndOr _smallmap_vegetation_andor[] = {

   300

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   301

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   302

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   303

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   304

	{MKCOLOR(0x00575700),MKCOLOR(0xFF0000FF)},

   305

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   306

	{MKCOLOR(0xCACACACA),MKCOLOR(0x00000000)},

   307

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   308

	{MKCOLOR(0xB5B5B5B5),MKCOLOR(0x00000000)},

   309

	{MKCOLOR(0x00000000),MKCOLOR(0xFFFFFFFF)},

   310

	{MKCOLOR(0x00B5B500),MKCOLOR(0xFF0000FF)},

   311

	{MKCOLOR(0x00D7D700),MKCOLOR(0xFF0000FF)},

   312

};

   313

   314

typedef uint32 GetSmallMapPixels(TileIndex tile); // typedef callthrough function

   315

   316

/**

   317

 * Draws one column of the small map in a certain mode onto the screen buffer. This

   318

 * function looks exactly the same for all types

   319

 *

   320

 * @param dst Pointer to a part of the screen buffer to write to.

   321

 * @param xc The X coordinate of the first tile in the column.

   322

 * @param yc The Y coordinate of the first tile in the column

   323

 * @param pitch Number of pixels to advance in the screen buffer each time a pixel is written.

   324

 * @param reps Number of lines to draw

   325

 * @param mask ?

   326

 * @param proc Pointer to the colour function

   327

 * @see GetSmallMapPixels(TileIndex)

   328

 */

   329

static void DrawSmallMapStuff(Pixel *dst, uint xc, uint yc, int pitch, int reps, uint32 mask, GetSmallMapPixels *proc)

   330

{

   331

	Pixel *dst_ptr_end = _screen.dst_ptr + _screen.width * _screen.height - _screen.width;

   332

   333

	do {

   334

		// check if the tile (xc,yc) is within the map range

   335

		if (xc < MapMaxX() && yc < MapMaxY()) {

   336

			// check if the dst pointer points to a pixel inside the screen buffer

   337

			if (dst > _screen.dst_ptr && dst < dst_ptr_end)

   338

				WRITE_PIXELS_OR(dst, proc(TileXY(xc, yc)) & mask);

   339

		}

   340

	// switch to next tile in the column

   341

	} while (xc++, yc++, dst += pitch, --reps != 0);

   342

}

   343

   344

   345

static inline TileType GetEffectiveTileType(TileIndex tile)

   346

{

   347

	TileType t = GetTileType(tile);

   348

   349

	if (t == MP_TUNNELBRIDGE) {

   350

		TransportType tt;

   351

   352

		if (IsTunnel(tile)) {

   353

			tt = GetTunnelTransportType(tile);

   354

		} else {

   355

			tt = GetBridgeTransportType(tile);

   356

		}

   357

		switch (tt) {

   358

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   359

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   360

			default:             t = MP_WATER;   break;

   361

		}

   362

	}

   363

	return t;

   364

}

   365

   366

/**

   367

 * Return the color a tile would be displayed with in the small map in mode "Contour".

   368

 * @param tile The tile of which we would like to get the color.

   369

 * @return The color of tile in the small map in mode "Contour"

   370

 */

   371

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   372

{

   373

	TileType t = GetEffectiveTileType(tile);

   374

   375

	return

   376

		ApplyMask(_map_height_bits[TileHeight(tile)], &_smallmap_contours_andor[t]);

   377

}

   378

   379

/**

   380

 * Return the color a tile would be displayed with in the small map in mode "Vehicles".

   381

 *

   382

 * @param t The tile of which we would like to get the color.

   383

 * @return The color of tile in the small map in mode "Vehicles"

   384

 */

   385

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   386

{

   387

	TileType t = GetEffectiveTileType(tile);

   388

   389

	return ApplyMask(MKCOLOR(0x54545454), &_smallmap_vehicles_andor[t]);

   390

}

   391

   392

/* Industry colours... a total of 175 gfx - XXX - increase if more industries */

   393

static const byte _industry_smallmap_colors[175] = {

   394

	215,215,215,215,215,215,215,184,

   395

	184,184,184,194,194,194,194,194,

   396

	 86, 86,191,191,191,191,191,191,

   397

	152,152,152,152,152,152,152,152,

   398

	152, 48, 48, 48, 48, 48, 48,174,

   399

	174,174,174,174,174,174,174, 10,

   400

	 10, 10, 10, 10, 10, 10, 10, 10,

   401

	 10, 10, 15, 15, 55, 55, 55, 55,

   402

	 10, 10, 10, 10, 10, 10, 10, 10,

   403

	194,194,194,194,194,194,194,194,

   404

	194,194,194,194,194,194,194,194,

   405

	194, 15, 15,184,184,184,184,184,

   406

	184,184,184,184, 55, 55, 55, 55,

   407

	 55, 55, 55, 55, 55, 55, 55, 55,

   408

	 55, 55, 55, 55, 86, 39, 37, 37,

   409

	208,174,174,174,174,194,194,194,

   410

	194, 48, 48,174,174,174,174, 39,

   411

	 39, 55,208,208,208,208, 10, 10,

   412

	 10, 10, 10, 10, 37, 37, 37, 37,

   413

	 37, 37, 37, 37,184,184,184,184,

   414

	152,152,152,152,194,194,194, 15,

   415

	 15, 15, 15, 15, 15, 15, 15,

   416

};

   417

   418

/**

   419

 * Return the color a tile would be displayed with in the small map in mode "Industries".

   420

 *

   421

 * @param tile The tile of which we would like to get the color.

   422

 * @return The color of tile in the small map in mode "Industries"

   423

 */

   424

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   425

{

   426

	TileType t = GetEffectiveTileType(tile);

   427

   428

	if (t == MP_INDUSTRY) {

   429

		byte color = _industry_smallmap_colors[_m[tile].m5];

   430

		return color + (color << 8) + (color << 16) + (color << 24);

   431

	}

   432

   433

	return ApplyMask(MKCOLOR(0x54545454), &_smallmap_vehicles_andor[t]);

   434

}

   435

   436

/**

   437

 * Return the color a tile would be displayed with in the small map in mode "Routes".

   438

 *

   439

 * @param t The tile of which we would like to get the color.

   440

 * @return The color of tile  in the small map in mode "Routes"

   441

 */

   442

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   443

{

   444

	TileType t = GetEffectiveTileType(tile);

   445

	uint32 bits;

   446

   447

	if (t == MP_STATION) {

   448

		byte m5 = _m[tile].m5;

   449

		(bits = MKCOLOR(0x56565656), m5 < 8) ||			//   8 - railroad station (green)

   450

		(bits = MKCOLOR(0xB8B8B8B8), m5 < 0x43) ||	//  67 - airport (red)

   451

		(bits = MKCOLOR(0xC2C2C2C2), m5 < 0x47) ||	//  71 - truck loading bay (orange)

   452

		(bits = MKCOLOR(0xBFBFBFBF), m5 < 0x4B) ||	//  75 - bus station (yellow)

   453

		(bits = MKCOLOR(0x98989898), m5 < 0x53) ||	//  83 - docks (blue)

   454

		(bits = MKCOLOR(0xB8B8B8B8), m5 < 0x73) ||	// 115 - airport (red) (new airports)

   455

		(bits = MKCOLOR(0xFFFFFFFF), true);					// all others

   456

	} else {

   457

		// ground color

   458

		bits = ApplyMask(MKCOLOR(0x54545454), &_smallmap_contours_andor[t]);

   459

	}

   460

	return bits;

   461

}

   462

   463

   464

static const uint32 _vegetation_clear_bits[] = {

   465

	MKCOLOR(0x54545454), ///< full grass

   466

	MKCOLOR(0x52525252), ///< rough land

   467

	MKCOLOR(0x0A0A0A0A), ///< rocks

   468

	MKCOLOR(0x25252525), ///< fields

   469

	MKCOLOR(0x98989898), ///< snow

   470

	MKCOLOR(0xC2C2C2C2), ///< desert

   471

	MKCOLOR(0x54545454), ///< unused

   472

	MKCOLOR(0x54545454), ///< unused

   473

};

   474

   475

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   476

{

   477

	TileType t = GetEffectiveTileType(tile);

   478

	uint32 bits;

   479

   480

	switch (t) {

   481

		case MP_CLEAR:

   482

			if (IsClearGround(tile, CL_GRASS) && GetClearDensity(tile) < 3) {

   483

				bits = MKCOLOR(0x37373737);

   484

			} else {

   485

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   486

			}

   487

			break;

   488

   489

		case MP_INDUSTRY:

   490

			bits = IS_BYTE_INSIDE(_m[tile].m5, 0x10, 0x12) ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   491

			break;

   492

   493

		case MP_TREES:

   494

			if (GetTreeGround(tile) == TR_SNOW_DESERT) {

   495

				bits = (_opt.landscape == LT_HILLY) ? MKCOLOR(0x98575798) : MKCOLOR(0xC25757C2);

   496

			} else {

   497

				bits = MKCOLOR(0x54575754);

   498

			}

   499

			break;

   500

   501

		default:

   502

			bits = ApplyMask(MKCOLOR(0x54545454), &_smallmap_vehicles_andor[t]);

   503

			break;

   504

	}

   505

   506

	return bits;

   507

}

   508