1

/* $Id$ */

     2

     3

/** @file smallmap_gui.cpp GUI that shows a small map of the world with metadata like owner or height. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "clear_map.h"

     9

#include "industry_map.h"

    10

#include "industry.h"

    11

#include "station_map.h"

    12

#include "landscape.h"

    13

#include "gui.h"

    14

#include "window_gui.h"

    15

#include "tree_map.h"

    16

#include "tunnel_map.h"

    17

#include "viewport_func.h"

    18

#include "gfx_func.h"

    19

#include "player_base.h"

    20

#include "town.h"

    21

#include "variables.h"

    22

#include "blitter/factory.hpp"

    23

#include "tunnelbridge_map.h"

    24

#include "strings_func.h"

    25

#include "zoom_func.h"

    26

#include "core/endian_func.hpp"

    27

#include "vehicle_base.h"

    28

#include "sound_func.h"

    29

#include "settings_type.h"

    30

#include "window_func.h"

    31

    32

#include "table/strings.h"

    33

#include "table/sprites.h"

    34

    35

static const Widget _smallmap_widgets[] = {

    36

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

    37

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

    38

{ WWT_STICKYBOX,     RESIZE_LR,    13,   338,   349,     0,    13, 0x0,                     STR_STICKY_BUTTON},

    39

{     WWT_PANEL,     RESIZE_RB,    13,     0,   349,    14,   157, 0x0,                     STR_NULL},

    40

{     WWT_INSET,     RESIZE_RB,    13,     2,   347,    16,   155, 0x0,                     STR_NULL},

    41

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   284,   305,   158,   179, SPR_IMG_SHOW_COUNTOURS,  STR_0191_SHOW_LAND_CONTOURS_ON_MAP},

    42

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   306,   327,   158,   179, SPR_IMG_SHOW_VEHICLES,   STR_0192_SHOW_VEHICLES_ON_MAP},

    43

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   328,   349,   158,   179, SPR_IMG_INDUSTRY,        STR_0193_SHOW_INDUSTRIES_ON_MAP},

    44

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   284,   307,   180,   201, SPR_IMG_SHOW_ROUTES,     STR_0194_SHOW_TRANSPORT_ROUTES_ON},

    45

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   306,   327,   180,   201, SPR_IMG_PLANTTREES,      STR_0195_SHOW_VEGETATION_ON_MAP},

    46

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   328,   349,   180,   201, SPR_IMG_COMPANY_GENERAL, STR_0196_SHOW_LAND_OWNERS_ON_MAP},

    47

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   262,   283,   158,   179, SPR_IMG_SMALLMAP,        STR_SMALLMAP_CENTER},

    48

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   262,   283,   180,   201, SPR_IMG_TOWN,            STR_0197_TOGGLE_TOWN_NAMES_ON_OFF},

    49

{     WWT_PANEL,    RESIZE_RTB,    13,     0,   261,   158,   201, 0x0,                     STR_NULL},

    50

{     WWT_PANEL,   RESIZE_LRTB,    13,   262,   349,   202,   202, 0x0,                     STR_NULL},

    51

{     WWT_PANEL,    RESIZE_RTB,    13,     0,   337,   202,   213, 0x0,                     STR_NULL},

    52

{   WWT_TEXTBTN,     RESIZE_TB,    13,     0,    99,   202,   213, STR_MESSAGES_ENABLE_ALL, STR_NULL},

    53

{   WWT_TEXTBTN,     RESIZE_TB,    13,   100,   201,   202,   213, STR_MESSAGES_DISABLE_ALL,STR_NULL},

    54

{ WWT_RESIZEBOX,   RESIZE_LRTB,    13,   338,   349,   202,   213, 0x0,                     STR_RESIZE_BUTTON},

    55

{  WIDGETS_END},

    56

};

    57

    58

static int _smallmap_type;

    59

static bool _smallmap_show_towns = true;

    60

/* number of used industries */

    61

static int _smallmap_industry_count;

    62

/* number of industries per column*/

    63

static uint _industries_per_column;

    64

    65

/** Macro for ordinary entry of LegendAndColor */

    66

#define MK(a,b) {a, b, INVALID_INDUSTRYTYPE, true, false, false}

    67

/** Macro for end of list marker in arrays of LegendAndColor */

    68

#define MKEND() {0, STR_NULL, INVALID_INDUSTRYTYPE, true, true, false}

    69

/** Macro for break marker in arrays of LegendAndColor.

    70

 * It will have valid data, though */

    71

#define MS(a,b) {a, b, INVALID_INDUSTRYTYPE, true, false, true}

    72

    73

/** Structure for holding relevant data for legends in small map */

    74

struct LegendAndColour {

    75

	uint16 colour;     ///< color of the item on the map

    76

	StringID legend;   ///< string corresponding to the colored item

    77

	IndustryType type; ///< type of industry

    78

	bool show_on_map;  ///< for filtering industries, if true is shown on map in color

    79

	bool end;          ///< this is the end of the list

    80

	bool col_break;    ///< perform a break and go one collumn further

    81

};

    82

    83

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

    84

static const LegendAndColour _legend_land_contours[] = {

    85

	MK(0x5A, STR_00F0_100M),

    86

	MK(0x5C, STR_00F1_200M),

    87

	MK(0x5E, STR_00F2_300M),

    88

	MK(0x1F, STR_00F3_400M),

    89

	MK(0x27, STR_00F4_500M),

    90

    91

	MS(0xD7, STR_00EB_ROADS),

    92

	MK(0x0A, STR_00EC_RAILROADS),

    93

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    94

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    95

	MK(0x0F, STR_00EF_VEHICLES),

    96

	MKEND()

    97

};

    98

    99

static const LegendAndColour _legend_vehicles[] = {

   100

	MK(0xB8, STR_00F5_TRAINS),

   101

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

   102

	MK(0x98, STR_00F7_SHIPS),

   103

	MK(0x0F, STR_00F8_AIRCRAFT),

   104

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

   105

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   106

	MKEND()

   107

};

   108

   109

static const LegendAndColour _legend_routes[] = {

   110

	MK(0xD7, STR_00EB_ROADS),

   111

	MK(0x0A, STR_00EC_RAILROADS),

   112

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   113

	MS(0x56, STR_011B_RAILROAD_STATION),

   114

   115

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   116

	MK(0xBF, STR_011D_BUS_STATION),

   117

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   118

	MK(0x98, STR_011F_DOCK),

   119

	MKEND()

   120

};

   121

   122

static const LegendAndColour _legend_vegetation[] = {

   123

	MK(0x52, STR_0120_ROUGH_LAND),

   124

	MK(0x54, STR_0121_GRASS_LAND),

   125

	MK(0x37, STR_0122_BARE_LAND),

   126

	MK(0x25, STR_0123_FIELDS),

   127

	MK(0x57, STR_0124_TREES),

   128

	MK(0xD0, STR_00FC_FOREST),

   129

	MS(0x0A, STR_0125_ROCKS),

   130

   131

	MK(0xC2, STR_012A_DESERT),

   132

	MK(0x98, STR_012B_SNOW),

   133

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   134

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   135

	MKEND()

   136

};

   137

   138

static const LegendAndColour _legend_land_owners[] = {

   139

	MK(0xCA, STR_0126_WATER),

   140

	MK(0x54, STR_0127_NO_OWNER),

   141

	MK(0xB4, STR_0128_TOWNS),

   142

	MK(0x20, STR_0129_INDUSTRIES),

   143

	MKEND()

   144

};

   145

#undef MK

   146

#undef MS

   147

#undef MKEND

   148

   149

/** Allow room for all industries, plus a terminator entry

   150

 * This is required in order to have the indutry slots all filled up */

   151

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   152

/* For connecting industry type to position in industries list(small map legend) */

   153

static uint _industry_to_list_pos[NUM_INDUSTRYTYPES];

   154

   155

/**

   156

 * Fills an array for the industries legends.

   157

 */

   158

void BuildIndustriesLegend()

   159

{

   160

	const IndustrySpec *indsp;

   161

	uint j = 0;

   162

	uint free_slot, diff;

   163

   164

	/* Add each name */

   165

	for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {

   166

		indsp = GetIndustrySpec(i);

   167

		if (indsp->enabled) {

   168

			_legend_from_industries[j].legend = indsp->name;

   169

			_legend_from_industries[j].colour = indsp->map_colour;

   170

			_legend_from_industries[j].type = i;

   171

			_legend_from_industries[j].show_on_map = true;

   172

			_legend_from_industries[j].col_break = false;

   173

			_legend_from_industries[j].end = false;

   174

   175

			/* Store widget number for this industry type */

   176

			_industry_to_list_pos[i] = j;

   177

			j++;

   178

		}

   179

	}

   180

	/* Terminate the list */

   181

	_legend_from_industries[j].end = true;

   182

   183

	/* Store number of enabled industries */

   184

	_smallmap_industry_count = j;

   185

   186

	_industries_per_column = _smallmap_industry_count / 3;

   187

	free_slot = _smallmap_industry_count % 3;

   188

   189

	/* recalculate column break for first two columns(i) */

   190

	diff = 0;

   191

	for (int i = 1; i <= 2; i++) {

   192

		if (free_slot > 0) diff = diff + 1;

   193

		_legend_from_industries[i * _industries_per_column + diff].col_break = true;

   194

		if (free_slot > 0) free_slot--;

   195

	}

   196

   197

}

   198

   199

static const LegendAndColour * const _legend_table[] = {

   200

	_legend_land_contours,

   201

	_legend_vehicles,

   202

	_legend_from_industries,

   203

	_legend_routes,

   204

	_legend_vegetation,

   205

	_legend_land_owners,

   206

};

   207

   208

#define MKCOLOR(x) TO_LE32X(x)

   209

   210

/**

   211

 * Height encodings; MAX_TILE_HEIGHT + 1 levels, from 0 to MAX_TILE_HEIGHT

   212

 */

   213

static const uint32 _map_height_bits[] = {

   214

	MKCOLOR(0x5A5A5A5A),

   215

	MKCOLOR(0x5A5B5A5B),

   216

	MKCOLOR(0x5B5B5B5B),

   217

	MKCOLOR(0x5B5C5B5C),

   218

	MKCOLOR(0x5C5C5C5C),

   219

	MKCOLOR(0x5C5D5C5D),

   220

	MKCOLOR(0x5D5D5D5D),

   221

	MKCOLOR(0x5D5E5D5E),

   222

	MKCOLOR(0x5E5E5E5E),

   223

	MKCOLOR(0x5E5F5E5F),

   224

	MKCOLOR(0x5F5F5F5F),

   225

	MKCOLOR(0x5F1F5F1F),

   226

	MKCOLOR(0x1F1F1F1F),

   227

	MKCOLOR(0x1F271F27),

   228

	MKCOLOR(0x27272727),

   229

	MKCOLOR(0x27272727),

   230

};

   231

assert_compile(lengthof(_map_height_bits) == MAX_TILE_HEIGHT + 1);

   232

   233

struct AndOr {

   234

	uint32 mor;

   235

	uint32 mand;

   236

};

   237

   238

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

   239

{

   240

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

   241

}

   242

   243

   244

static const AndOr _smallmap_contours_andor[] = {

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

};

   258

   259

static const AndOr _smallmap_vehicles_andor[] = {

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

};

   273

   274

static const AndOr _smallmap_vegetation_andor[] = {

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

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

   287

};

   288

   289

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

   290

   291

/**

   292

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

   293

 * function looks exactly the same for all types

   294

 *

   295

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

   296

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

   297

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

   298

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

   299

 * @param reps Number of lines to draw

   300

 * @param mask ?

   301

 * @param proc Pointer to the colour function

   302

 * @see GetSmallMapPixels(TileIndex)

   303

 */

   304

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

   305

{

   306

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   307

	void *dst_ptr_abs_end = blitter->MoveTo(_screen.dst_ptr, 0, _screen.height);

   308

	void *dst_ptr_end = blitter->MoveTo(dst_ptr_abs_end, -4, 0);

   309

   310

	do {

   311

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

   312

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

   313

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

   314

			if (dst < _screen.dst_ptr) continue;

   315

			if (dst >= dst_ptr_abs_end) continue;

   316

   317

			uint32 val = proc(TileXY(xc, yc)) & mask;

   318

			uint8 *val8 = (uint8 *)&val;

   319

   320

			if (dst <= dst_ptr_end) {

   321

				blitter->SetPixelIfEmpty(dst, 0, 0, val8[0]);

   322

				blitter->SetPixelIfEmpty(dst, 1, 0, val8[1]);

   323

				blitter->SetPixelIfEmpty(dst, 2, 0, val8[2]);

   324

				blitter->SetPixelIfEmpty(dst, 3, 0, val8[3]);

   325

			} else {

   326

				/* It happens that there are only 1, 2 or 3 pixels left to fill, so in that special case, write till the end of the video-buffer */

   327

				int i = 0;

   328

				do {

   329

					blitter->SetPixelIfEmpty(dst, 0, 0, val8[i]);

   330

				} while (i++, dst = blitter->MoveTo(dst, 1, 0), dst < dst_ptr_abs_end);

   331

			}

   332

		}

   333

	/* switch to next tile in the column */

   334

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

   335

}

   336

   337

   338

static inline TileType GetEffectiveTileType(TileIndex tile)

   339

{

   340

	TileType t = GetTileType(tile);

   341

   342

	if (t == MP_TUNNELBRIDGE) {

   343

		TransportType tt = GetTunnelBridgeTransportType(tile);

   344

   345

		switch (tt) {

   346

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   347

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   348

			default:             t = MP_WATER;   break;

   349

		}

   350

	}

   351

	return t;

   352

}

   353

   354

/**

   355

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

   356

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

   357

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

   358

 */

   359

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   360

{

   361

	TileType t = GetEffectiveTileType(tile);

   362

   363

	return

   364

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

   365

}

   366

   367

/**

   368

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

   369

 *

   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 "Vehicles"

   372

 */

   373

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   374

{

   375

	TileType t = GetEffectiveTileType(tile);

   376

   377

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

   378

}

   379

   380

/**

   381

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

   382

 *

   383

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

   384

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

   385

 */

   386

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   387

{

   388

	TileType t = GetEffectiveTileType(tile);

   389

   390

	if (t == MP_INDUSTRY) {

   391

		/* If industry is allowed to be seen, use its color on the map */

   392

		if (_legend_from_industries[_industry_to_list_pos[GetIndustryByTile(tile)->type]].show_on_map) {

   393

			return GetIndustrySpec(GetIndustryByTile(tile)->type)->map_colour * 0x01010101;

   394

		} else {

   395

			/* otherwise, return the color of the clear tiles, which will make it disappear */

   396

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

   397

		}

   398

	}

   399

   400

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

   401

}

   402

   403

/**

   404

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

   405

 *

   406

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

   407

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

   408

 */

   409

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   410

{

   411

	TileType t = GetEffectiveTileType(tile);

   412

	uint32 bits;

   413

   414

	if (t == MP_STATION) {

   415

		switch (GetStationType(tile)) {

   416

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

   417

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

   418

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

   419

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

   420

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

   421

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

   422

		}

   423

	} else {

   424

		/* ground color */

   425

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

   426

	}

   427

	return bits;

   428

}

   429

   430

   431

static const uint32 _vegetation_clear_bits[] = {

   432

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

   433

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

   434

	MKCOLOR(0x0A0A0A0A), ///< rocks

   435

	MKCOLOR(0x25252525), ///< fields

   436

	MKCOLOR(0x98989898), ///< snow

   437

	MKCOLOR(0xC2C2C2C2), ///< desert

   438

	MKCOLOR(0x54545454), ///< unused

   439

	MKCOLOR(0x54545454), ///< unused

   440

};

   441

   442

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   443

{

   444

	TileType t = GetEffectiveTileType(tile);

   445

	uint32 bits;

   446

   447

	switch (t) {

   448

		case MP_CLEAR:

   449

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

   450

				bits = MKCOLOR(0x37373737);

   451

			} else {

   452

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   453

			}

   454

			break;

   455

   456

		case MP_INDUSTRY:

   457

			bits = GetIndustrySpec(GetIndustryByTile(tile)->type)->check_proc == CHECK_FOREST ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   458

			break;

   459

   460

		case MP_TREES:

   461

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   462

				bits = (_settings_game.game_creation.landscape == LT_ARCTIC) ? MKCOLOR(0x98575798) : MKCOLOR(0xC25757C2);

   463

			} else {

   464

				bits = MKCOLOR(0x54575754);

   465

			}

   466

			break;

   467

   468

		default:

   469

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

   470

			break;

   471

	}

   472

   473

	return bits;

   474

}

   475

   476

   477

static uint32 _owner_colors[OWNER_END + 1];

   478

   479

/**

   480

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

   481

 *

   482

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

   483

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

   484

 */

   485

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   486

{

   487

	Owner o;

   488

   489

	switch (GetTileType(tile)) {

   490

		case MP_INDUSTRY: o = OWNER_END;          break;