1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "bridge_map.h"

     6

#include "clear_map.h"

     7

#include "industry_map.h"

     8

#include "functions.h"

     9

#include "spritecache.h"

    10

#include "station_map.h"

    11

#include "table/strings.h"

    12

#include "table/sprites.h"

    13

#include "map.h"

    14

#include "tile.h"

    15

#include "gui.h"

    16

#include "tree_map.h"

    17

#include "tunnel_map.h"

    18

#include "window.h"

    19

#include "gfx.h"

    20

#include "viewport.h"

    21

#include "player.h"

    22

#include "vehicle.h"

    23

#include "town.h"

    24

#include "sound.h"

    25

#include "variables.h"

    26

    27

static const Widget _smallmap_widgets[] = {

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

{  WIDGETS_END},

    45

};

    46

    47

static int _smallmap_type;

    48

static bool _smallmap_show_towns = true;

    49

    50

#define MK(a,b) a, b

    51

#define MKEND() 0xFFFF

    52

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

    53

    54

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

    55

static const uint16 _legend_land_contours[] = {

    56

	MK(0x5A,STR_00F0_100M),

    57

	MK(0x5C,STR_00F1_200M),

    58

	MK(0x5E,STR_00F2_300M),

    59

	MK(0x1F,STR_00F3_400M),

    60

	MK(0x27,STR_00F4_500M),

    61

    62

	MS(0xD7,STR_00EB_ROADS),

    63

	MK(0x0A,STR_00EC_RAILROADS),

    64

	MK(0x98,STR_00ED_STATIONS_AIRPORTS_DOCKS),

    65

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    66

	MK(0x0F,STR_00EF_VEHICLES),

    67

	MKEND()

    68

};

    69

    70

static const uint16 _legend_vehicles[] = {

    71

	MK(0xB8,STR_00F5_TRAINS),

    72

	MK(0xBF,STR_00F6_ROAD_VEHICLES),

    73

	MK(0x98,STR_00F7_SHIPS),

    74

	MK(0x0F,STR_00F8_AIRCRAFT),

    75

	MS(0xD7,STR_00F9_TRANSPORT_ROUTES),

    76

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    77

	MKEND()

    78

};

    79

    80

static const uint16 _legend_industries_normal[] = {

    81

	MK(0xD7,STR_00FA_COAL_MINE),

    82

	MK(0xB8,STR_00FB_POWER_STATION),

    83

	MK(0x56,STR_00FC_FOREST),

    84

	MK(0xC2,STR_00FD_SAWMILL),

    85

	MK(0xBF,STR_00FE_OIL_REFINERY),

    86

	MK(0x0F,STR_0105_BANK),

    87

    88

	MS(0x30,STR_00FF_FARM),

    89

	MK(0xAE,STR_0100_FACTORY),

    90

	MK(0x98,STR_0102_OIL_WELLS),

    91

	MK(0x37,STR_0103_IRON_ORE_MINE),

    92

	MK(0x0A,STR_0104_STEEL_MILL),

    93

	MKEND()

    94

};

    95

    96

static const uint16 _legend_industries_hilly[] = {

    97

	MK(0xD7,STR_00FA_COAL_MINE),

    98

	MK(0xB8,STR_00FB_POWER_STATION),

    99

	MK(0x56,STR_00FC_FOREST),

   100

	MK(0x0A,STR_0106_PAPER_MILL),

   101

	MK(0xBF,STR_00FE_OIL_REFINERY),

   102

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   103

	MS(0x30,STR_00FF_FARM),

   104

   105

	MK(0xAE,STR_0101_PRINTING_WORKS),

   106

	MK(0x98,STR_0102_OIL_WELLS),

   107

	MK(0xC2,STR_0107_GOLD_MINE),

   108

	MK(0x0F,STR_0105_BANK),

   109

	MKEND()

   110

};

   111

   112

static const uint16 _legend_industries_desert[] = {

   113

	MK(0xBF,STR_00FE_OIL_REFINERY),

   114

	MK(0x98,STR_0102_OIL_WELLS),

   115

	MK(0x0F,STR_0105_BANK),

   116

	MK(0xB8,STR_0109_DIAMOND_MINE),

   117

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   118

	MK(0x0A,STR_010A_COPPER_ORE_MINE),

   119

	MK(0x30,STR_00FF_FARM),

   120

	MS(0x56,STR_010B_FRUIT_PLANTATION),

   121

   122

	MK(0x27,STR_010C_RUBBER_PLANTATION),

   123

	MK(0x25,STR_010D_WATER_SUPPLY),

   124

	MK(0xD0,STR_010E_WATER_TOWER),

   125

	MK(0xAE,STR_0100_FACTORY),

   126

	MK(0xC2,STR_010F_LUMBER_MILL),

   127

	MKEND()

   128

};

   129

   130

static const uint16 _legend_industries_candy[] = {

   131

	MK(0x30,STR_0110_COTTON_CANDY_FOREST),

   132

	MK(0xAE,STR_0111_CANDY_FACTORY),

   133

	MK(0x27,STR_0112_BATTERY_FARM),

   134

	MK(0x37,STR_0113_COLA_WELLS),

   135

	MK(0xD0,STR_0114_TOY_SHOP),

   136

	MK(0x0A,STR_0115_TOY_FACTORY),

   137

	MS(0x25,STR_0116_PLASTIC_FOUNTAINS),

   138

   139

	MK(0xB8,STR_0117_FIZZY_DRINK_FACTORY),

   140

	MK(0x98,STR_0118_BUBBLE_GENERATOR),

   141

	MK(0xC2,STR_0119_TOFFEE_QUARRY),

   142

	MK(0x0F,STR_011A_SUGAR_MINE),

   143

	MKEND()

   144

};

   145

   146

static const uint16 _legend_routes[] = {

   147

	MK(0xD7,STR_00EB_ROADS),

   148

	MK(0x0A,STR_00EC_RAILROADS),

   149

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   150

	MS(0x56,STR_011B_RAILROAD_STATION),

   151

   152

	MK(0xC2,STR_011C_TRUCK_LOADING_BAY),

   153

	MK(0xBF,STR_011D_BUS_STATION),

   154

	MK(0xB8,STR_011E_AIRPORT_HELIPORT),

   155

	MK(0x98,STR_011F_DOCK),

   156

	MKEND()

   157

};

   158

   159

static const uint16 _legend_vegetation[] = {

   160

	MK(0x52,STR_0120_ROUGH_LAND),

   161

	MK(0x54,STR_0121_GRASS_LAND),

   162

	MK(0x37,STR_0122_BARE_LAND),

   163

	MK(0x25,STR_0123_FIELDS),

   164

	MK(0x57,STR_0124_TREES),

   165

	MK(0xD0,STR_00FC_FOREST),

   166

	MS(0x0A,STR_0125_ROCKS),

   167

   168

	MK(0xC2,STR_012A_DESERT),

   169

	MK(0x98,STR_012B_SNOW),

   170

	MK(0xD7,STR_00F9_TRANSPORT_ROUTES),

   171

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   172

	MKEND()

   173

};

   174

   175

static const uint16 _legend_land_owners[] = {

   176

	MK(0xCA,STR_0126_WATER),

   177

	MK(0x54,STR_0127_NO_OWNER),

   178

	MK(0xB4,STR_0128_TOWNS),

   179

	MK(0x20,STR_0129_INDUSTRIES),

   180

	MKEND()

   181

};

   182

#undef MK

   183

#undef MS

   184

#undef MKEND

   185

   186

   187

enum { IND_OFFS = 6 };

   188

static const uint16 * const _legend_table[] = {

   189

	_legend_land_contours,

   190

	_legend_vehicles,

   191

	NULL,

   192

	_legend_routes,

   193

	_legend_vegetation,

   194

	_legend_land_owners,

   195

   196

	_legend_industries_normal,

   197

	_legend_industries_hilly,

   198

	_legend_industries_desert,

   199

	_legend_industries_candy,

   200

};

   201

   202

#if defined(OTTD_ALIGNMENT)

   203

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

   204

	{

   205

#	if defined(TTD_BIG_ENDIAN)

   206

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

   207

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

   208

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

   209

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

   210

#	elif defined(TTD_LITTLE_ENDIAN)

   211

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

   212

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

   213

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

   214

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

   215

#	endif

   216

	}

   217

   218

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

   219

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

   220

	{

   221

#	if defined(TTD_BIG_ENDIAN)

   222

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

   223

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

   224

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

   225

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

   226

#	elif defined(TTD_LITTLE_ENDIAN)

   227

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

   228

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

   229

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

   230

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

   231

#	endif

   232

	}

   233

#else

   234

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

   235

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

   236

#endif

   237

   238

#define MKCOLOR(x) TO_LE32X(x)

   239

   240

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

   241

static const uint32 _map_height_bits[16] = {

   242

	MKCOLOR(0x5A5A5A5A),

   243

	MKCOLOR(0x5A5B5A5B),

   244

	MKCOLOR(0x5B5B5B5B),

   245

	MKCOLOR(0x5B5C5B5C),

   246

	MKCOLOR(0x5C5C5C5C),

   247

	MKCOLOR(0x5C5D5C5D),

   248

	MKCOLOR(0x5D5D5D5D),

   249

	MKCOLOR(0x5D5E5D5E),

   250

	MKCOLOR(0x5E5E5E5E),

   251

	MKCOLOR(0x5E5F5E5F),

   252

	MKCOLOR(0x5F5F5F5F),

   253

	MKCOLOR(0x5F1F5F1F),

   254

	MKCOLOR(0x1F1F1F1F),

   255

	MKCOLOR(0x1F271F27),

   256

	MKCOLOR(0x27272727),

   257

	MKCOLOR(0x27272727),

   258

};

   259

   260

typedef struct AndOr {

   261

	uint32 mor;

   262

	uint32 mand;

   263

} AndOr;

   264

   265

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

   266

{

   267

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

   268

}

   269

   270

   271

static const AndOr _smallmap_contours_andor[] = {

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

};

   285

   286

static const AndOr _smallmap_vehicles_andor[] = {

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

};

   300

   301

static const AndOr _smallmap_vegetation_andor[] = {

   302

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

   303

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

   304

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

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

};

   315

   316

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

   317

   318

/**

   319

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

   320

 * function looks exactly the same for all types

   321

 *

   322

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

   323

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

   324

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

   325

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

   326

 * @param reps Number of lines to draw

   327

 * @param mask ?

   328

 * @param proc Pointer to the colour function

   329

 * @see GetSmallMapPixels(TileIndex)

   330

 */

   331

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

   332

{

   333

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

   334

   335

	do {

   336

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

   337

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

   338

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

   339

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

   340

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

   341

		}

   342

	// switch to next tile in the column

   343

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

   344

}

   345

   346

   347

static inline TileType GetEffectiveTileType(TileIndex tile)

   348

{

   349

	TileType t = GetTileType(tile);

   350

   351

	if (t == MP_TUNNELBRIDGE) {

   352

		TransportType tt;

   353

   354

		if (IsTunnel(tile)) {

   355

			tt = GetTunnelTransportType(tile);

   356

		} else {

   357

			tt = GetBridgeTransportType(tile);

   358

		}

   359

		switch (tt) {

   360

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   361

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   362

			default:             t = MP_WATER;   break;

   363

		}

   364

	}

   365

	return t;

   366

}

   367

   368

/**

   369

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

   370

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

   371

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

   372

 */

   373

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   374

{

   375

	TileType t = GetEffectiveTileType(tile);

   376

   377

	return

   378

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

   379

}

   380

   381

/**

   382

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

   383

 *

   384

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

   385

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

   386

 */

   387

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   388

{

   389

	TileType t = GetEffectiveTileType(tile);

   390

   391

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

   392

}

   393

   394

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

   395

static const byte _industry_smallmap_colors[175] = {

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

};

   419

   420

/**

   421

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

   422

 *

   423

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

   424

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

   425

 */

   426

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   427

{

   428

	TileType t = GetEffectiveTileType(tile);

   429

   430

	if (t == MP_INDUSTRY) {

   431

		byte color = _industry_smallmap_colors[GetIndustryGfx(tile)];

   432

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

   433

	}

   434

   435

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

   436

}

   437

   438

/**

   439

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

   440

 *

   441

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

   442

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

   443

 */

   444

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   445

{

   446

	TileType t = GetEffectiveTileType(tile);

   447

	uint32 bits;

   448

   449

	if (t == MP_STATION) {

   450

		switch (GetStationType(tile)) {

   451

			case STATION_RAIL:    bits = MKCOLOR(0x56565656); break;

   452

			case STATION_AIRPORT: bits = MKCOLOR(0xB8B8B8B8); break;

   453

			case STATION_TRUCK:   bits = MKCOLOR(0xC2C2C2C2); break;

   454

			case STATION_BUS:     bits = MKCOLOR(0xBFBFBFBF); break;

   455

			case STATION_DOCK:    bits = MKCOLOR(0x98989898); break;

   456

			default:              bits = MKCOLOR(0xFFFFFFFF); break;

   457

		}

   458

	} else {

   459

		// ground color

   460

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

   461

	}

   462

	return bits;

   463

}

   464

   465

   466

static const uint32 _vegetation_clear_bits[] = {

   467

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

   468

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

   469

	MKCOLOR(0x0A0A0A0A), ///< rocks

   470

	MKCOLOR(0x25252525), ///< fields

   471

	MKCOLOR(0x98989898), ///< snow

   472

	MKCOLOR(0xC2C2C2C2), ///< desert

   473

	MKCOLOR(0x54545454), ///< unused

   474

	MKCOLOR(0x54545454), ///< unused

   475

};

   476

   477

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   478

{

   479

	TileType t = GetEffectiveTileType(tile);

   480

	uint32 bits;

   481

   482

	switch (t) {

   483

		case MP_CLEAR:

   484

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

   485

				bits = MKCOLOR(0x37373737);

   486

			} else {

   487

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   488

			}

   489

			break;

   490

   491

		case MP_INDUSTRY:

   492

			bits = GetIndustryType(tile) == IT_FOREST ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   493

			break;

   494

   495

		case MP_TREES:

   496

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   497

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

   498

			} else {

   499

				bits = MKCOLOR(0x54575754);

   500

			}

   501

			break;

   502

   503

		default:

   504

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

   505

			break;

   506

	}

   507