1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "bridge_map.h"

     7

#include "clear_map.h"

     8

#include "industry_map.h"

     9

#include "station_map.h"

    10

#include "table/strings.h"

    11

#include "table/sprites.h"

    12

#include "map.h"

    13

#include "tile.h"

    14

#include "gui.h"

    15

#include "tree_map.h"

    16

#include "tunnel_map.h"

    17

#include "window.h"

    18

#include "gfx.h"

    19

#include "viewport.h"

    20

#include "player.h"

    21

#include "vehicle.h"

    22

#include "town.h"

    23

#include "sound.h"

    24

#include "variables.h"

    25

    26

static const Widget _smallmap_widgets[] = {

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   258,   279, SPR_IMG_SMALLMAP,        STR_SMALLMAP_CENTER},

    39

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

    40

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

    41

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

    42

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

    43

{  WIDGETS_END},

    44

};

    45

    46

static int _smallmap_type;

    47

static bool _smallmap_show_towns = true;

    48

    49

#define MK(a,b) a, b

    50

#define MKEND() 0xFFFF

    51

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

    52

    53

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

    54

static const uint16 _legend_land_contours[] = {

    55

	MK(0x5A, STR_00F0_100M),

    56

	MK(0x5C, STR_00F1_200M),

    57

	MK(0x5E, STR_00F2_300M),

    58

	MK(0x1F, STR_00F3_400M),

    59

	MK(0x27, STR_00F4_500M),

    60

    61

	MS(0xD7, STR_00EB_ROADS),

    62

	MK(0x0A, STR_00EC_RAILROADS),

    63

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    64

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    65

	MK(0x0F, STR_00EF_VEHICLES),

    66

	MKEND()

    67

};

    68

    69

static const uint16 _legend_vehicles[] = {

    70

	MK(0xB8, STR_00F5_TRAINS),

    71

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    72

	MK(0x98, STR_00F7_SHIPS),

    73

	MK(0x0F, STR_00F8_AIRCRAFT),

    74

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

    75

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    76

	MKEND()

    77

};

    78

    79

static const uint16 _legend_industries_normal[] = {

    80

	MK(0xD7, STR_00FA_COAL_MINE),

    81

	MK(0xB8, STR_00FB_POWER_STATION),

    82

	MK(0x56, STR_00FC_FOREST),

    83

	MK(0xC2, STR_00FD_SAWMILL),

    84

	MK(0xBF, STR_00FE_OIL_REFINERY),

    85

	MK(0x0F, STR_0105_BANK),

    86

    87

	MS(0x30, STR_00FF_FARM),

    88

	MK(0xAE, STR_0100_FACTORY),

    89

	MK(0x98, STR_0102_OIL_WELLS),

    90

	MK(0x37, STR_0103_IRON_ORE_MINE),

    91

	MK(0x0A, STR_0104_STEEL_MILL),

    92

	MKEND()

    93

};

    94

    95

static const uint16 _legend_industries_hilly[] = {

    96

	MK(0xD7, STR_00FA_COAL_MINE),

    97

	MK(0xB8, STR_00FB_POWER_STATION),

    98

	MK(0x56, STR_00FC_FOREST),

    99

	MK(0x0A, STR_0106_PAPER_MILL),

   100

	MK(0xBF, STR_00FE_OIL_REFINERY),

   101

	MK(0x37, STR_0108_FOOD_PROCESSING_PLANT),

   102

	MS(0x30, STR_00FF_FARM),

   103

   104

	MK(0xAE, STR_0101_PRINTING_WORKS),

   105

	MK(0x98, STR_0102_OIL_WELLS),

   106

	MK(0xC2, STR_0107_GOLD_MINE),

   107

	MK(0x0F, STR_0105_BANK),

   108

	MKEND()

   109

};

   110

   111

static const uint16 _legend_industries_desert[] = {

   112

	MK(0xBF, STR_00FE_OIL_REFINERY),

   113

	MK(0x98, STR_0102_OIL_WELLS),

   114

	MK(0x0F, STR_0105_BANK),

   115

	MK(0xB8, STR_0109_DIAMOND_MINE),

   116

	MK(0x37, STR_0108_FOOD_PROCESSING_PLANT),

   117

	MK(0x0A, STR_010A_COPPER_ORE_MINE),

   118

	MK(0x30, STR_00FF_FARM),

   119

	MS(0x56, STR_010B_FRUIT_PLANTATION),

   120

   121

	MK(0x27, STR_010C_RUBBER_PLANTATION),

   122

	MK(0x25, STR_010D_WATER_SUPPLY),

   123

	MK(0xD0, STR_010E_WATER_TOWER),

   124

	MK(0xAE, STR_0100_FACTORY),

   125

	MK(0xC2, STR_010F_LUMBER_MILL),

   126

	MKEND()

   127

};

   128

   129

static const uint16 _legend_industries_candy[] = {

   130

	MK(0x30, STR_0110_COTTON_CANDY_FOREST),

   131

	MK(0xAE, STR_0111_CANDY_FACTORY),

   132

	MK(0x27, STR_0112_BATTERY_FARM),

   133

	MK(0x37, STR_0113_COLA_WELLS),

   134

	MK(0xD0, STR_0114_TOY_SHOP),

   135

	MK(0x0A, STR_0115_TOY_FACTORY),

   136

	MS(0x25, STR_0116_PLASTIC_FOUNTAINS),

   137

   138

	MK(0xB8, STR_0117_FIZZY_DRINK_FACTORY),

   139

	MK(0x98, STR_0118_BUBBLE_GENERATOR),

   140

	MK(0xC2, STR_0119_TOFFEE_QUARRY),

   141

	MK(0x0F, STR_011A_SUGAR_MINE),

   142

	MKEND()

   143

};

   144

   145

static const uint16 _legend_routes[] = {

   146

	MK(0xD7, STR_00EB_ROADS),

   147

	MK(0x0A, STR_00EC_RAILROADS),

   148

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   149

	MS(0x56, STR_011B_RAILROAD_STATION),

   150

   151

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   152

	MK(0xBF, STR_011D_BUS_STATION),

   153

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   154

	MK(0x98, STR_011F_DOCK),

   155

	MKEND()

   156

};

   157

   158

static const uint16 _legend_vegetation[] = {

   159

	MK(0x52, STR_0120_ROUGH_LAND),

   160

	MK(0x54, STR_0121_GRASS_LAND),

   161

	MK(0x37, STR_0122_BARE_LAND),

   162

	MK(0x25, STR_0123_FIELDS),

   163

	MK(0x57, STR_0124_TREES),

   164

	MK(0xD0, STR_00FC_FOREST),

   165

	MS(0x0A, STR_0125_ROCKS),

   166

   167

	MK(0xC2, STR_012A_DESERT),

   168

	MK(0x98, STR_012B_SNOW),

   169

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   170

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   171

	MKEND()

   172

};

   173

   174

static const uint16 _legend_land_owners[] = {

   175

	MK(0xCA, STR_0126_WATER),

   176

	MK(0x54, STR_0127_NO_OWNER),

   177

	MK(0xB4, STR_0128_TOWNS),

   178

	MK(0x20, STR_0129_INDUSTRIES),

   179

	MKEND()

   180

};

   181

#undef MK

   182

#undef MS

   183

#undef MKEND

   184

   185

   186

enum { IND_OFFS = 6 };

   187

static const uint16 * const _legend_table[] = {

   188

	_legend_land_contours,

   189

	_legend_vehicles,

   190

	NULL,

   191

	_legend_routes,

   192

	_legend_vegetation,

   193

	_legend_land_owners,

   194

   195

	_legend_industries_normal,

   196

	_legend_industries_hilly,

   197

	_legend_industries_desert,

   198

	_legend_industries_candy,

   199

};

   200

   201

#if defined(OTTD_ALIGNMENT)

   202

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

   203

	{

   204

#	if defined(TTD_BIG_ENDIAN)

   205

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

   206

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

   207

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

   208

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

   209

#	elif defined(TTD_LITTLE_ENDIAN)

   210

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

   211

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

   212

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

   213

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

   214

#	endif

   215

	}

   216

   217

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

   218

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

   219

	{

   220

#	if defined(TTD_BIG_ENDIAN)

   221

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

   222

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

   223

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

   224

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

   225

#	elif defined(TTD_LITTLE_ENDIAN)

   226

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

   227

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

   228

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

   229

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

   230

#	endif

   231

	}

   232

#else

   233

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

   234

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

   235

#endif

   236

   237

#define MKCOLOR(x) TO_LE32X(x)

   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

		TransportType tt;

   352

   353

		if (IsTunnel(tile)) {

   354

			tt = GetTunnelTransportType(tile);

   355

		} else {

   356

			tt = GetBridgeTransportType(tile);

   357

		}

   358

		switch (tt) {

   359

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   360

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   361

			default:             t = MP_WATER;   break;

   362

		}

   363

	}

   364

	return t;

   365

}

   366

   367

/**

   368

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

   369

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

   370

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

   371

 */

   372

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   373

{

   374

	TileType t = GetEffectiveTileType(tile);

   375

   376

	return

   377

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

   378

}

   379

   380

/**

   381

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

   382

 *

   383

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

   384

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

   385

 */

   386

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   387

{

   388

	TileType t = GetEffectiveTileType(tile);

   389

   390

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

   391

}

   392

   393

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

   394

static const byte _industry_smallmap_colors[175] = {

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

};

   418

   419

/**

   420

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

   421

 *

   422

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

   423

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

   424

 */

   425

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   426

{

   427

	TileType t = GetEffectiveTileType(tile);

   428

   429

	if (t == MP_INDUSTRY) {

   430

		return _industry_smallmap_colors[GetIndustryGfx(tile)] * 0x01010101;

   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

		switch (GetStationType(tile)) {

   449

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

   450

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

   451

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

   452

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

   453

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

   454

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

   455

		}

   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, CLEAR_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 = GetIndustryType(tile) == IT_FOREST ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   491

			break;

   492

   493

		case MP_TREES:

   494

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   495

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