1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear.h"

     6

#include "functions.h"

     7

#include "spritecache.h"

     8

#include "table/strings.h"

     9

#include "table/sprites.h"

    10

#include "map.h"

    11

#include "tile.h"

    12

#include "gui.h"

    13

#include "window.h"

    14

#include "gfx.h"

    15

#include "viewport.h"

    16

#include "player.h"

    17

#include "vehicle.h"

    18

#include "town.h"

    19

#include "sound.h"

    20

#include "variables.h"

    21

    22

static const Widget _smallmap_widgets[] = {

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

{  WIDGETS_END},

    40

};

    41

    42

static int _smallmap_type;

    43

static bool _smallmap_show_towns = true;

    44

    45

#define MK(a,b) a, b

    46

#define MKEND() 0xFFFF

    47

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

    48

    49

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

    50

static const uint16 _legend_land_contours[] = {

    51

	MK(0x5A,STR_00F0_100M),

    52

	MK(0x5C,STR_00F1_200M),

    53

	MK(0x5E,STR_00F2_300M),

    54

	MK(0x1F,STR_00F3_400M),

    55

	MK(0x27,STR_00F4_500M),

    56

    57

	MS(0xD7,STR_00EB_ROADS),

    58

	MK(0x0A,STR_00EC_RAILROADS),

    59

	MK(0x98,STR_00ED_STATIONS_AIRPORTS_DOCKS),

    60

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    61

	MK(0x0F,STR_00EF_VEHICLES),

    62

	MKEND()

    63

};

    64

    65

static const uint16 _legend_vehicles[] = {

    66

	MK(0xB8,STR_00F5_TRAINS),

    67

	MK(0xBF,STR_00F6_ROAD_VEHICLES),

    68

	MK(0x98,STR_00F7_SHIPS),

    69

	MK(0x0F,STR_00F8_AIRCRAFT),

    70

	MS(0xD7,STR_00F9_TRANSPORT_ROUTES),

    71

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    72

	MKEND()

    73

};

    74

    75

static const uint16 _legend_industries_normal[] = {

    76

	MK(0xD7,STR_00FA_COAL_MINE),

    77

	MK(0xB8,STR_00FB_POWER_STATION),

    78

	MK(0x56,STR_00FC_FOREST),

    79

	MK(0xC2,STR_00FD_SAWMILL),

    80

	MK(0xBF,STR_00FE_OIL_REFINERY),

    81

	MK(0x0F,STR_0105_BANK),

    82

    83

	MS(0x30,STR_00FF_FARM),

    84

	MK(0xAE,STR_0100_FACTORY),

    85

	MK(0x98,STR_0102_OIL_WELLS),

    86

	MK(0x37,STR_0103_IRON_ORE_MINE),

    87

	MK(0x0A,STR_0104_STEEL_MILL),

    88

	MKEND()

    89

};

    90

    91

static const uint16 _legend_industries_hilly[] = {

    92

	MK(0xD7,STR_00FA_COAL_MINE),

    93

	MK(0xB8,STR_00FB_POWER_STATION),

    94

	MK(0x56,STR_00FC_FOREST),

    95

	MK(0x0A,STR_0106_PAPER_MILL),

    96

	MK(0xBF,STR_00FE_OIL_REFINERY),

    97

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

    98

	MS(0x30,STR_00FF_FARM),

    99

   100

	MK(0xAE,STR_0101_PRINTING_WORKS),

   101

	MK(0x98,STR_0102_OIL_WELLS),

   102

	MK(0xC2,STR_0107_GOLD_MINE),

   103

	MK(0x0F,STR_0105_BANK),

   104

	MKEND()

   105

};

   106

   107

static const uint16 _legend_industries_desert[] = {

   108

	MK(0xBF,STR_00FE_OIL_REFINERY),

   109

	MK(0x98,STR_0102_OIL_WELLS),

   110

	MK(0x0F,STR_0105_BANK),

   111

	MK(0xB8,STR_0109_DIAMOND_MINE),

   112

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   113

	MK(0x0A,STR_010A_COPPER_ORE_MINE),

   114

	MK(0x30,STR_00FF_FARM),

   115

	MS(0x56,STR_010B_FRUIT_PLANTATION),

   116

   117

	MK(0x27,STR_010C_RUBBER_PLANTATION),

   118

	MK(0x25,STR_010D_WATER_SUPPLY),

   119

	MK(0xD0,STR_010E_WATER_TOWER),

   120

	MK(0xAE,STR_0100_FACTORY),

   121

	MK(0xC2,STR_010F_LUMBER_MILL),

   122

	MKEND()

   123

};

   124

   125

static const uint16 _legend_industries_candy[] = {

   126

	MK(0x30,STR_0110_COTTON_CANDY_FOREST),

   127

	MK(0xAE,STR_0111_CANDY_FACTORY),

   128

	MK(0x27,STR_0112_BATTERY_FARM),

   129

	MK(0x37,STR_0113_COLA_WELLS),

   130

	MK(0xD0,STR_0114_TOY_SHOP),

   131

	MK(0x0A,STR_0115_TOY_FACTORY),

   132

	MS(0x25,STR_0116_PLASTIC_FOUNTAINS),

   133

   134

	MK(0xB8,STR_0117_FIZZY_DRINK_FACTORY),

   135

	MK(0x98,STR_0118_BUBBLE_GENERATOR),

   136

	MK(0xC2,STR_0119_TOFFEE_QUARRY),

   137

	MK(0x0F,STR_011A_SUGAR_MINE),

   138

	MKEND()

   139

};

   140

   141

static const uint16 _legend_routes[] = {

   142

	MK(0xD7,STR_00EB_ROADS),

   143

	MK(0x0A,STR_00EC_RAILROADS),

   144

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   145

	MS(0x56,STR_011B_RAILROAD_STATION),

   146

   147

	MK(0xC2,STR_011C_TRUCK_LOADING_BAY),

   148

	MK(0xBF,STR_011D_BUS_STATION),

   149

	MK(0xB8,STR_011E_AIRPORT_HELIPORT),

   150

	MK(0x98,STR_011F_DOCK),

   151

	MKEND()

   152

};

   153

   154

static const uint16 _legend_vegetation[] = {

   155

	MK(0x52,STR_0120_ROUGH_LAND),

   156

	MK(0x54,STR_0121_GRASS_LAND),

   157

	MK(0x37,STR_0122_BARE_LAND),

   158

	MK(0x25,STR_0123_FIELDS),

   159

	MK(0x57,STR_0124_TREES),

   160

	MK(0xD0,STR_00FC_FOREST),

   161

	MS(0x0A,STR_0125_ROCKS),

   162

   163

	MK(0xC2,STR_012A_DESERT),

   164

	MK(0x98,STR_012B_SNOW),

   165

	MK(0xD7,STR_00F9_TRANSPORT_ROUTES),

   166

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   167

	MKEND()

   168

};

   169

   170

static const uint16 _legend_land_owners[] = {

   171

	MK(0xCA,STR_0126_WATER),

   172

	MK(0x54,STR_0127_NO_OWNER),

   173

	MK(0xB4,STR_0128_TOWNS),

   174

	MK(0x20,STR_0129_INDUSTRIES),

   175

	MKEND()

   176

};

   177

#undef MK

   178

#undef MS

   179

#undef MKEND

   180

   181

   182

enum { IND_OFFS = 6 };

   183

static const uint16 * const _legend_table[] = {

   184

	_legend_land_contours,

   185

	_legend_vehicles,

   186

	NULL,

   187

	_legend_routes,

   188

	_legend_vegetation,

   189

	_legend_land_owners,

   190

   191

	_legend_industries_normal,

   192

	_legend_industries_hilly,

   193

	_legend_industries_desert,

   194

	_legend_industries_candy,

   195

};

   196

   197

#if defined(OTTD_ALIGNMENT)

   198

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

   199

	{

   200

#	if defined(TTD_BIG_ENDIAN)

   201

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

   202

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

   203

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

   204

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

   205

#	elif defined(TTD_LITTLE_ENDIAN)

   206

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

   207

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

   208

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

   209

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

   210

#	endif

   211

	}

   212

   213

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

   214

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

   215

	{

   216

#	if defined(TTD_BIG_ENDIAN)

   217

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

   218

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

   219

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

   220

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

   221

#	elif defined(TTD_LITTLE_ENDIAN)

   222

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

   223

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

   224

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

   225

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

   226

#	endif

   227

	}

   228

#else

   229

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

   230

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

   231

#endif

   232

   233

#if defined(TTD_BIG_ENDIAN)

   234

#	define MKCOLOR(x) BSWAP32(x)

   235

#elif defined(TTD_LITTLE_ENDIAN)

   236

#	define MKCOLOR(x) (x)

   237

#endif

   238

   239

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

   240

static const uint32 _map_height_bits[16] = {

   241

	MKCOLOR(0x5A5A5A5A),

   242

	MKCOLOR(0x5A5B5A5B),

   243

	MKCOLOR(0x5B5B5B5B),

   244

	MKCOLOR(0x5B5C5B5C),

   245

	MKCOLOR(0x5C5C5C5C),

   246

	MKCOLOR(0x5C5D5C5D),

   247

	MKCOLOR(0x5D5D5D5D),

   248

	MKCOLOR(0x5D5E5D5E),

   249

	MKCOLOR(0x5E5E5E5E),

   250

	MKCOLOR(0x5E5F5E5F),

   251

	MKCOLOR(0x5F5F5F5F),

   252

	MKCOLOR(0x5F1F5F1F),

   253

	MKCOLOR(0x1F1F1F1F),

   254

	MKCOLOR(0x1F271F27),

   255

	MKCOLOR(0x27272727),

   256

	MKCOLOR(0x27272727),

   257

};

   258

   259

typedef struct AndOr {

   260

	uint32 mor;

   261

	uint32 mand;

   262

} AndOr;

   263

   264

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

   265

{

   266

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

   267

}

   268

   269

   270

static const AndOr _smallmap_contours_andor[] = {

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

};

   284

   285

static const AndOr _smallmap_vehicles_andor[] = {

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

};

   299

   300

static const AndOr _smallmap_vegetation_andor[] = {

   301

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

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

};

   314

   315

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

   316

   317

/**

   318

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

   319

 * function looks exactly the same for all types

   320

 *

   321

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

   322

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

   323

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

   324

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

   325

 * @param reps Number of lines to draw

   326

 * @param mask ?

   327

 * @param proc Pointer to the colour function

   328

 * @see GetSmallMapPixels(TileIndex)

   329

 */

   330

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

   331

{

   332

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

   333

   334

	do {

   335

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

   336

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

   337

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

   338

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

   339

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

   340

		}

   341

	// switch to next tile in the column

   342

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

   343

}

   344

   345

   346

static inline TileType GetEffectiveTileType(TileIndex tile)

   347

{

   348

	TileType t = GetTileType(tile);

   349

   350

	if (t == MP_TUNNELBRIDGE) {

   351

		t = _m[tile].m5;

   352

		if ((t & 0x80) == 0) t >>= 1;

   353

		if ((t & 6) == 0) {

   354

			t = MP_RAILWAY;

   355

		} else if ((t & 6) == 2) {

   356

			t = MP_STREET;

   357

		} else {

   358

			t = MP_WATER;

   359

		}

   360

	}

   361

	return t;

   362

}

   363

   364

/**

   365

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

   366

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

   367

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

   368

 */

   369

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   370

{

   371

	TileType t = GetEffectiveTileType(tile);

   372

   373

	return

   374

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

   375

}

   376

   377

/**

   378

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

   379

 *

   380

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

   381

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

   382

 */

   383

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   384

{

   385

	TileType t = GetEffectiveTileType(tile);

   386

   387

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

   388

}

   389

   390

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

   391

static const byte _industry_smallmap_colors[175] = {

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

};

   415

   416

/**

   417

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

   418

 *

   419

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

   420

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

   421

 */

   422

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   423

{

   424

	TileType t = GetEffectiveTileType(tile);

   425

   426

	if (t == MP_INDUSTRY) {

   427

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

   428

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

   429

	}

   430

   431

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

   432

}

   433

   434

/**

   435

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

   436

 *

   437

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

   438

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

   439

 */

   440

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   441

{

   442

	TileType t = GetEffectiveTileType(tile);

   443

	uint32 bits;

   444

   445

	if (t == MP_STATION) {

   446

		byte m5 = _m[tile].m5;

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

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

   454

	} else {

   455

		// ground color

   456

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

   457

	}

   458

	return bits;

   459

}

   460

   461

   462

static const uint32 _vegetation_clear_bits[] = {

   463

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

   464

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

   465

	MKCOLOR(0x0A0A0A0A), ///< rocks

   466

	MKCOLOR(0x25252525), ///< fields

   467

	MKCOLOR(0x98989898), ///< snow

   468

	MKCOLOR(0xC2C2C2C2), ///< desert

   469

	MKCOLOR(0x54545454), ///< unused

   470

	MKCOLOR(0x54545454), ///< unused

   471

};

   472

   473

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   474

{

   475

	TileType t = GetEffectiveTileType(tile);

   476

	uint32 bits;

   477

   478

	switch (t) {

   479

		case MP_CLEAR:

   480

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

   481

				bits = MKCOLOR(0x37373737);

   482

			} else {

   483

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   484

			}

   485

			break;

   486

   487

		case MP_INDUSTRY:

   488

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

   489

			break;

   490

   491

		case MP_TREES:

   492

			if ((_m[tile].m2 & 0x30) == 0x20) {

   493

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

   494

			} else {

   495

				bits = MKCOLOR(0x54575754);

   496

			}

   497

			break;

   498

   499

		default:

   500

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

   501

			break;

   502

	}

   503

   504

	return bits;

   505

}

   506

   507

   508

static uint32 _owner_colors[256];

   509