1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "spritecache.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "map.h"

    10

#include "tile.h"

    11

#include "gui.h"

    12

#include "window.h"

    13

#include "gfx.h"

    14

#include "viewport.h"

    15

#include "player.h"

    16

#include "vehicle.h"

    17

#include "town.h"

    18

#include "sound.h"

    19

#include "variables.h"

    20

    21

static const Widget _smallmap_widgets[] = {

    22

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

    23

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

    24

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

    25

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

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

{  WIDGETS_END},

    39

};

    40

    41

static int _smallmap_type;

    42

static bool _smallmap_show_towns = true;

    43

    44

#define MK(a,b) a, b

    45

#define MKEND() 0xFFFF

    46

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

    47

    48

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

    49

static const uint16 _legend_land_contours[] = {

    50

	MK(0x5A,STR_00F0_100M),

    51

	MK(0x5C,STR_00F1_200M),

    52

	MK(0x5E,STR_00F2_300M),

    53

	MK(0x1F,STR_00F3_400M),

    54

	MK(0x27,STR_00F4_500M),

    55

    56

	MS(0xD7,STR_00EB_ROADS),

    57

	MK(0x0A,STR_00EC_RAILROADS),

    58

	MK(0x98,STR_00ED_STATIONS_AIRPORTS_DOCKS),

    59

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    60

	MK(0x0F,STR_00EF_VEHICLES),

    61

	MKEND()

    62

};

    63

    64

static const uint16 _legend_vehicles[] = {

    65

	MK(0xB8,STR_00F5_TRAINS),

    66

	MK(0xBF,STR_00F6_ROAD_VEHICLES),

    67

	MK(0x98,STR_00F7_SHIPS),

    68

	MK(0x0F,STR_00F8_AIRCRAFT),

    69

	MS(0xD7,STR_00F9_TRANSPORT_ROUTES),

    70

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    71

	MKEND()

    72

};

    73

    74

static const uint16 _legend_industries_normal[] = {

    75

	MK(0xD7,STR_00FA_COAL_MINE),

    76

	MK(0xB8,STR_00FB_POWER_STATION),

    77

	MK(0x56,STR_00FC_FOREST),

    78

	MK(0xC2,STR_00FD_SAWMILL),

    79

	MK(0xBF,STR_00FE_OIL_REFINERY),

    80

	MK(0x0F,STR_0105_BANK),

    81

    82

	MS(0x30,STR_00FF_FARM),

    83

	MK(0xAE,STR_0100_FACTORY),

    84

	MK(0x98,STR_0102_OIL_WELLS),

    85

	MK(0x37,STR_0103_IRON_ORE_MINE),

    86

	MK(0x0A,STR_0104_STEEL_MILL),

    87

	MKEND()

    88

};

    89

    90

static const uint16 _legend_industries_hilly[] = {

    91

	MK(0xD7,STR_00FA_COAL_MINE),

    92

	MK(0xB8,STR_00FB_POWER_STATION),

    93

	MK(0x56,STR_00FC_FOREST),

    94

	MK(0x0A,STR_0106_PAPER_MILL),

    95

	MK(0xBF,STR_00FE_OIL_REFINERY),

    96

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

    97

	MS(0x30,STR_00FF_FARM),

    98

    99

	MK(0xAE,STR_0101_PRINTING_WORKS),

   100

	MK(0x98,STR_0102_OIL_WELLS),

   101

	MK(0xC2,STR_0107_GOLD_MINE),

   102

	MK(0x0F,STR_0105_BANK),

   103

	MKEND()

   104

};

   105

   106

static const uint16 _legend_industries_desert[] = {

   107

	MK(0xBF,STR_00FE_OIL_REFINERY),

   108

	MK(0x98,STR_0102_OIL_WELLS),

   109

	MK(0x0F,STR_0105_BANK),

   110

	MK(0xB8,STR_0109_DIAMOND_MINE),

   111

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   112

	MK(0x0A,STR_010A_COPPER_ORE_MINE),

   113

	MK(0x30,STR_00FF_FARM),

   114

	MS(0x56,STR_010B_FRUIT_PLANTATION),

   115

   116

	MK(0x27,STR_010C_RUBBER_PLANTATION),

   117

	MK(0x25,STR_010D_WATER_SUPPLY),

   118

	MK(0xD0,STR_010E_WATER_TOWER),

   119

	MK(0xAE,STR_0100_FACTORY),

   120

	MK(0xC2,STR_010F_LUMBER_MILL),

   121

	MKEND()

   122

};

   123

   124

static const uint16 _legend_industries_candy[] = {

   125

	MK(0x30,STR_0110_COTTON_CANDY_FOREST),

   126

	MK(0xAE,STR_0111_CANDY_FACTORY),

   127

	MK(0x27,STR_0112_BATTERY_FARM),

   128

	MK(0x37,STR_0113_COLA_WELLS),

   129

	MK(0xD0,STR_0114_TOY_SHOP),

   130

	MK(0x0A,STR_0115_TOY_FACTORY),

   131

	MS(0x25,STR_0116_PLASTIC_FOUNTAINS),

   132

   133

	MK(0xB8,STR_0117_FIZZY_DRINK_FACTORY),

   134

	MK(0x98,STR_0118_BUBBLE_GENERATOR),

   135

	MK(0xC2,STR_0119_TOFFEE_QUARRY),

   136

	MK(0x0F,STR_011A_SUGAR_MINE),

   137

	MKEND()

   138

};

   139

   140

static const uint16 _legend_routes[] = {

   141

	MK(0xD7,STR_00EB_ROADS),

   142

	MK(0x0A,STR_00EC_RAILROADS),

   143

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   144

	MS(0x56,STR_011B_RAILROAD_STATION),

   145

   146

	MK(0xC2,STR_011C_TRUCK_LOADING_BAY),

   147

	MK(0xBF,STR_011D_BUS_STATION),

   148

	MK(0xB8,STR_011E_AIRPORT_HELIPORT),

   149

	MK(0x98,STR_011F_DOCK),

   150

	MKEND()

   151

};

   152

   153

static const uint16 _legend_vegetation[] = {

   154

	MK(0x52,STR_0120_ROUGH_LAND),

   155

	MK(0x54,STR_0121_GRASS_LAND),

   156

	MK(0x37,STR_0122_BARE_LAND),

   157

	MK(0x25,STR_0123_FIELDS),

   158

	MK(0x57,STR_0124_TREES),

   159

	MK(0xD0,STR_00FC_FOREST),

   160

	MS(0x0A,STR_0125_ROCKS),

   161

   162

	MK(0xC2,STR_012A_DESERT),

   163

	MK(0x98,STR_012B_SNOW),

   164

	MK(0xD7,STR_00F9_TRANSPORT_ROUTES),

   165

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   166

	MKEND()

   167

};

   168

   169

static const uint16 _legend_land_owners[] = {

   170

	MK(0xCA,STR_0126_WATER),

   171

	MK(0x54,STR_0127_NO_OWNER),

   172

	MK(0xB4,STR_0128_TOWNS),

   173

	MK(0x20,STR_0129_INDUSTRIES),

   174

	MKEND()

   175

};

   176

#undef MK

   177

#undef MS

   178

#undef MKEND

   179

   180

   181

enum { IND_OFFS = 6 };

   182

static const uint16 * const _legend_table[] = {

   183

	_legend_land_contours,

   184

	_legend_vehicles,

   185

	NULL,

   186

	_legend_routes,

   187

	_legend_vegetation,

   188

	_legend_land_owners,

   189

   190

	_legend_industries_normal,

   191

	_legend_industries_hilly,

   192

	_legend_industries_desert,

   193

	_legend_industries_candy,

   194

};

   195

   196

#if defined(OTTD_ALIGNMENT)

   197

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

   198

	{

   199

#	if defined(TTD_BIG_ENDIAN)

   200

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

   201

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

   202

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

   203

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

   204

#	elif defined(TTD_LITTLE_ENDIAN)

   205

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

   206

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

   207

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

   208

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

   209

#	endif

   210

	}

   211

   212

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

   213

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

   214

	{

   215

#	if defined(TTD_BIG_ENDIAN)

   216

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

   217

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

   218

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

   219

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

   220

#	elif defined(TTD_LITTLE_ENDIAN)

   221

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

   222

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

   223

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

   224

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

   225

#	endif

   226

	}

   227

#else

   228

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

   229

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

   230

#endif

   231

   232

#if defined(TTD_BIG_ENDIAN)

   233

#	define MKCOLOR(x) BSWAP32(x)

   234

#elif defined(TTD_LITTLE_ENDIAN)

   235

#	define MKCOLOR(x) (x)

   236

#endif

   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

		t = _m[tile].m5;

   351

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

   352

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

   353

			t = MP_RAILWAY;

   354

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

   355

			t = MP_STREET;

   356

		} else {

   357

			t = MP_WATER;

   358

		}

   359

	}

   360

	return t;

   361

}

   362

   363

/**

   364

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

   365

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

   366

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

   367

 */

   368

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   369

{

   370

	TileType t = GetEffectiveTileType(tile);

   371

   372

	return

   373

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

   374

}

   375

   376

/**

   377

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

   378

 *

   379

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

   380

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

   381

 */

   382

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   383

{

   384

	TileType t = GetEffectiveTileType(tile);

   385

   386

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

   387

}

   388

   389

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

   390

static const byte _industry_smallmap_colors[175] = {

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

};

   414

   415

/**

   416

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

   417

 *

   418

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

   419

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

   420

 */

   421

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   422

{

   423

	TileType t = GetEffectiveTileType(tile);

   424

   425

	if (t == MP_INDUSTRY) {

   426

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

   427

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

   428

	}

   429

   430

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

   431

}

   432

   433

/**

   434

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

   435

 *

   436

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

   437

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

   438

 */

   439

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   440

{

   441

	TileType t = GetEffectiveTileType(tile);

   442

	uint32 bits;

   443

   444

	if (t == MP_STATION) {

   445

		byte m5 = _m[tile].m5;

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

	} else {

   454

		// ground color

   455

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

   456

	}

   457

	return bits;

   458

}

   459

   460

   461

static const uint32 _vegetation_clear_bits[4 + 7] = {

   462

	MKCOLOR(0x37373737), ///< bare land

   463

	MKCOLOR(0x37373737), ///< 1/3 grass

   464

	MKCOLOR(0x37373737), ///< 2/3 grass

   465

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

   466

   467

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

   468

	MKCOLOR(0x0A0A0A0A), ///< rocks

   469

	MKCOLOR(0x25252525), ///< fields

   470

	MKCOLOR(0x98989898), ///< snow

   471

	MKCOLOR(0xC2C2C2C2), ///< desert

   472

	MKCOLOR(0x54545454), ///< unused

   473

	MKCOLOR(0x54545454), ///< unused

   474

};

   475

   476

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   477

{

   478

	TileType t = GetEffectiveTileType(tile);

   479

	int i;

   480

	uint32 bits;

   481

   482

	switch (t) {

   483

		case MP_CLEAR:

   484

			i = (_m[tile].m5 & 0x1F) - 4;

   485

			if (i >= 0) i >>= 2;

   486

			bits = _vegetation_clear_bits[i + 4];

   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 ((_m[tile].m2 & 0x30) == 0x20)

   495

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

   496

			else

   497

				bits = MKCOLOR(0x54575754);

   498

			break;

   499

   500

		default:

   501

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

   502

			break;

   503

	}

   504

   505

	return bits;

   506

}

   507

   508

   509

static uint32 _owner_colors[256];

   510