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,  COLOUR_BROWN,     0,    10,     0,    13, STR_00C5,                STR_018B_CLOSE_WINDOW},

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

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

    55

{  WIDGETS_END},

    56

};

    57

    58

/* number of used industries */

    59

static int _smallmap_industry_count;

    60

/* number of industries per column*/

    61

static uint _industries_per_column;

    62

    63

/** Macro for ordinary entry of LegendAndColor */

    64

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

    65

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

    66

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

    67

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

    68

 * It will have valid data, though */

    69

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

    70

    71

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

    72

struct LegendAndColour {

    73

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

    74

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

    75

	IndustryType type; ///< type of industry

    76

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

    77

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

    78

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

    79

};

    80

    81

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

    82

static const LegendAndColour _legend_land_contours[] = {

    83

	MK(0x5A, STR_00F0_100M),

    84

	MK(0x5C, STR_00F1_200M),

    85

	MK(0x5E, STR_00F2_300M),

    86

	MK(0x1F, STR_00F3_400M),

    87

	MK(0x27, STR_00F4_500M),

    88

    89

	MS(0xD7, STR_00EB_ROADS),

    90

	MK(0x0A, STR_00EC_RAILROADS),

    91

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    92

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    93

	MK(0x0F, STR_00EF_VEHICLES),

    94

	MKEND()

    95

};

    96

    97

static const LegendAndColour _legend_vehicles[] = {

    98

	MK(0xB8, STR_00F5_TRAINS),

    99

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

   100

	MK(0x98, STR_00F7_SHIPS),

   101

	MK(0x0F, STR_00F8_AIRCRAFT),

   102

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

   103

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   104

	MKEND()

   105

};

   106

   107

static const LegendAndColour _legend_routes[] = {

   108

	MK(0xD7, STR_00EB_ROADS),

   109

	MK(0x0A, STR_00EC_RAILROADS),

   110

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   111

	MS(0x56, STR_011B_RAILROAD_STATION),

   112

   113

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   114

	MK(0xBF, STR_011D_BUS_STATION),

   115

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   116

	MK(0x98, STR_011F_DOCK),

   117

	MKEND()

   118

};

   119

   120

static const LegendAndColour _legend_vegetation[] = {

   121

	MK(0x52, STR_0120_ROUGH_LAND),

   122

	MK(0x54, STR_0121_GRASS_LAND),

   123

	MK(0x37, STR_0122_BARE_LAND),

   124

	MK(0x25, STR_0123_FIELDS),

   125

	MK(0x57, STR_0124_TREES),

   126

	MK(0xD0, STR_00FC_FOREST),

   127

	MS(0x0A, STR_0125_ROCKS),

   128

   129

	MK(0xC2, STR_012A_DESERT),

   130

	MK(0x98, STR_012B_SNOW),

   131

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   132

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   133

	MKEND()

   134

};

   135

   136

static const LegendAndColour _legend_land_owners[] = {

   137

	MK(0xCA, STR_0126_WATER),

   138

	MK(0x54, STR_0127_NO_OWNER),

   139

	MK(0xB4, STR_0128_TOWNS),

   140

	MK(0x20, STR_0129_INDUSTRIES),

   141

	MKEND()

   142

};

   143

#undef MK

   144

#undef MS

   145

#undef MKEND

   146

   147

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

   148

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

   149

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   150

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

   151

static uint _industry_to_list_pos[NUM_INDUSTRYTYPES];

   152

   153

/**

   154

 * Fills an array for the industries legends.

   155

 */

   156

void BuildIndustriesLegend()

   157

{

   158

	const IndustrySpec *indsp;

   159

	uint j = 0;

   160

	uint free_slot, diff;

   161

   162

	/* Add each name */

   163

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

   164

		indsp = GetIndustrySpec(i);

   165

		if (indsp->enabled) {

   166

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

   167

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

   168

			_legend_from_industries[j].type = i;

   169

			_legend_from_industries[j].show_on_map = true;

   170

			_legend_from_industries[j].col_break = false;

   171

			_legend_from_industries[j].end = false;

   172

   173

			/* Store widget number for this industry type */

   174

			_industry_to_list_pos[i] = j;

   175

			j++;

   176

		}

   177

	}

   178

	/* Terminate the list */

   179

	_legend_from_industries[j].end = true;

   180

   181

	/* Store number of enabled industries */

   182

	_smallmap_industry_count = j;

   183

   184

	_industries_per_column = _smallmap_industry_count / 3;

   185

	free_slot = _smallmap_industry_count % 3;

   186

   187

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

   188

	diff = 0;

   189

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

   190

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

   191

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

   192

		if (free_slot > 0) free_slot--;

   193

	}

   194

   195

}

   196

   197

static const LegendAndColour * const _legend_table[] = {

   198

	_legend_land_contours,

   199

	_legend_vehicles,

   200

	_legend_from_industries,

   201

	_legend_routes,

   202

	_legend_vegetation,

   203

	_legend_land_owners,

   204

};

   205

   206

#define MKCOLOR(x) TO_LE32X(x)

   207

   208

/**

   209

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

   210

 */

   211

static const uint32 _map_height_bits[] = {

   212

	MKCOLOR(0x5A5A5A5A),

   213

	MKCOLOR(0x5A5B5A5B),

   214

	MKCOLOR(0x5B5B5B5B),

   215

	MKCOLOR(0x5B5C5B5C),

   216

	MKCOLOR(0x5C5C5C5C),

   217

	MKCOLOR(0x5C5D5C5D),

   218

	MKCOLOR(0x5D5D5D5D),

   219

	MKCOLOR(0x5D5E5D5E),

   220

	MKCOLOR(0x5E5E5E5E),

   221

	MKCOLOR(0x5E5F5E5F),

   222

	MKCOLOR(0x5F5F5F5F),

   223

	MKCOLOR(0x5F1F5F1F),

   224

	MKCOLOR(0x1F1F1F1F),

   225

	MKCOLOR(0x1F271F27),

   226

	MKCOLOR(0x27272727),

   227

	MKCOLOR(0x27272727),

   228

};

   229

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

   230

   231

struct AndOr {

   232

	uint32 mor;

   233

	uint32 mand;

   234

};

   235

   236

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

   237

{

   238

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

   239

}

   240

   241

   242

static const AndOr _smallmap_contours_andor[] = {

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

};

   256

   257

static const AndOr _smallmap_vehicles_andor[] = {

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

};

   271

   272

static const AndOr _smallmap_vegetation_andor[] = {

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

};

   286

   287

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

   288

   289

/**

   290

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

   291

 * function looks exactly the same for all types

   292

 *

   293

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

   294

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

   295

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

   296

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

   297

 * @param reps Number of lines to draw

   298

 * @param mask ?

   299

 * @param proc Pointer to the colour function

   300

 * @see GetSmallMapPixels(TileIndex)

   301

 */

   302

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

   303

{

   304

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   305

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

   306

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

   307

   308

	do {

   309

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

   310

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

   311

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

   312

			if (dst < _screen.dst_ptr) continue;

   313

			if (dst >= dst_ptr_abs_end) continue;

   314

   315

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

   316

			uint8 *val8 = (uint8 *)&val;

   317

   318

			if (dst <= dst_ptr_end) {

   319

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

   320

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

   321

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

   322

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

   323

			} else {

   324

				/* 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 */

   325

				int i = 0;

   326

				do {

   327

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

   328

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

   329

			}

   330

		}

   331

	/* switch to next tile in the column */

   332

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

   333

}

   334

   335

   336

static inline TileType GetEffectiveTileType(TileIndex tile)

   337

{

   338

	TileType t = GetTileType(tile);

   339

   340

	if (t == MP_TUNNELBRIDGE) {

   341

		TransportType tt = GetTunnelBridgeTransportType(tile);

   342

   343

		switch (tt) {

   344

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   345

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   346

			default:             t = MP_WATER;   break;

   347

		}

   348

	}

   349

	return t;

   350

}

   351

   352

/**

   353

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

   354

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

   355

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

   356

 */

   357

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   358

{

   359

	TileType t = GetEffectiveTileType(tile);

   360

   361

	return

   362

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

   363

}

   364

   365

/**

   366

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

   367

 *

   368

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

   369

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

   370

 */

   371

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   372

{

   373

	TileType t = GetEffectiveTileType(tile);

   374

   375

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

   376

}

   377

   378

/**

   379

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

   380

 *

   381

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

   382

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

   383

 */

   384

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   385

{

   386

	TileType t = GetEffectiveTileType(tile);

   387

   388

	if (t == MP_INDUSTRY) {

   389

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

   390

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

   391

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

   392

		} else {

   393

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

   394

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

   395

		}

   396

	}

   397

   398

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

   399

}

   400

   401

/**

   402

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

   403

 *

   404

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

   405

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

   406

 */

   407

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   408

{

   409

	TileType t = GetEffectiveTileType(tile);

   410

	uint32 bits;

   411

   412

	if (t == MP_STATION) {

   413

		switch (GetStationType(tile)) {

   414

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

   415

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

   416

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

   417

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

   418

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

   419

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

   420

		}

   421

	} else {

   422

		/* ground color */

   423

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

   424

	}

   425

	return bits;

   426

}

   427

   428

   429

static const uint32 _vegetation_clear_bits[] = {

   430

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

   431

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

   432

	MKCOLOR(0x0A0A0A0A), ///< rocks

   433

	MKCOLOR(0x25252525), ///< fields

   434

	MKCOLOR(0x98989898), ///< snow

   435

	MKCOLOR(0xC2C2C2C2), ///< desert

   436

	MKCOLOR(0x54545454), ///< unused

   437

	MKCOLOR(0x54545454), ///< unused

   438

};

   439

   440

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   441

{

   442

	TileType t = GetEffectiveTileType(tile);

   443

	uint32 bits;

   444

   445

	switch (t) {

   446

		case MP_CLEAR:

   447

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

   448

				bits = MKCOLOR(0x37373737);

   449

			} else {

   450

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   451

			}

   452

			break;

   453

   454

		case MP_INDUSTRY:

   455

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

   456

			break;

   457

   458

		case MP_TREES:

   459

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   460

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

   461

			} else {

   462

				bits = MKCOLOR(0x54575754);

   463

			}

   464

			break;

   465

   466

		default:

   467

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

   468

			break;

   469

	}

   470

   471

	return bits;

   472

}

   473

   474

   475

static uint32 _owner_colors[OWNER_END + 1];

   476

   477

/**

   478

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

   479

 *

   480

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

   481

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

   482

 */

   483

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   484

{

   485

	Owner o;

   486

   487

	switch (GetTileType(tile)) {

   488

		case MP_INDUSTRY: o = OWNER_END;          break;

   489

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   490

		default:          o = GetTileOwner(tile); break;