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

	switch (GetTileType(tile)) {

   349

		case MP_STREET_BRIDGE:  return MP_STREET;

   350

		case MP_RAILWAY_BRIDGE: return MP_RAILWAY;

   351

		case MP_TUNNEL:

   352

			if (GetTunnelTransportType(tile) == TRANSPORT_RAIL) return MP_RAILWAY;

   353

			return MP_STREET;

   354

		default: return GetTileType(tile);

   355

	}

   356

}

   357

   358

/**

   359

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

   360

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

   361

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

   362

 */

   363

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   364

{

   365

	TileType t = GetEffectiveTileType(tile);

   366

   367

	return

   368

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

   369

}

   370

   371

/**

   372

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

   373

 *

   374

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

   375

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

   376

 */

   377

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   378

{

   379

	TileType t = GetEffectiveTileType(tile);

   380

   381

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

   382

}

   383

   384

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

   385

static const byte _industry_smallmap_colors[175] = {

   386

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

   387

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

   388

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

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

};

   409

   410

/**

   411

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

   412

 *

   413

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

   414

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

   415

 */

   416

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   417

{

   418

	TileType t = GetEffectiveTileType(tile);

   419

   420

	if (t == MP_INDUSTRY) {

   421

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

   422

	}

   423

   424

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

   425

}

   426

   427

/**

   428

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

   429

 *

   430

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

   431

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

   432

 */

   433

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   434

{

   435

	TileType t = GetEffectiveTileType(tile);

   436

	uint32 bits;

   437

   438

	if (t == MP_STATION) {

   439

		switch (GetStationType(tile)) {

   440

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

   441

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

   442

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

   443

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

   444

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

   445

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

   446

		}

   447

	} else {

   448

		// ground color

   449

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

   450

	}

   451

	return bits;

   452

}

   453

   454

   455

static const uint32 _vegetation_clear_bits[] = {

   456

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

   457

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

   458

	MKCOLOR(0x0A0A0A0A), ///< rocks

   459

	MKCOLOR(0x25252525), ///< fields

   460

	MKCOLOR(0x98989898), ///< snow

   461

	MKCOLOR(0xC2C2C2C2), ///< desert

   462

	MKCOLOR(0x54545454), ///< unused

   463

	MKCOLOR(0x54545454), ///< unused

   464

};

   465

   466

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   467

{

   468

	TileType t = GetEffectiveTileType(tile);

   469

	uint32 bits;

   470

   471

	switch (t) {

   472

		case MP_CLEAR:

   473

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

   474

				bits = MKCOLOR(0x37373737);

   475

			} else {

   476

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   477

			}

   478

			break;

   479

   480

		case MP_INDUSTRY:

   481

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

   482

			break;

   483

   484

		case MP_TREES:

   485

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   486

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

   487

			} else {

   488

				bits = MKCOLOR(0x54575754);

   489

			}

   490

			break;

   491

   492

		default:

   493

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

   494

			break;

   495

	}

   496