1

/* $Id$ */

     2

     3

/** @file smallmap_gui.cpp */

     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 "table/strings.h"

    13

#include "table/sprites.h"

    14

#include "landscape.h"

    15

#include "gui.h"

    16

#include "window_gui.h"

    17

#include "tree_map.h"

    18

#include "tunnel_map.h"

    19

#include "viewport.h"

    20

#include "player.h"

    21

#include "town.h"

    22

#include "sound.h"

    23

#include "variables.h"

    24

#include "blitter/factory.hpp"

    25

#include "tunnelbridge_map.h"

    26

#include "strings_func.h"

    27

#include "zoom_func.h"

    28

#include "core/endian_func.hpp"

    30

    31

    32

static const Widget _smallmap_widgets[] = {

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

{  WIDGETS_END},

    53

};

    54

    55

static int _smallmap_type;

    56

static bool _smallmap_show_towns = true;

    57

/* number of used industries */

    58

static int _smallmap_industry_count;

    59

/* number of industries per column*/

    60

static uint _industries_per_column;

    61

    62

/** Macro for ordinary entry of LegendAndColor */

    63

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

    64

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

    65

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

    66

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

    67

 * It will have valid data, though */

    68

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

    69

    70

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

    71

struct LegendAndColour {

    72

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

    73

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

    74

	IndustryType type; ///< type of industry

    75

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

    76

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

    77

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

    78

};

    79

    80

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

    81

static const LegendAndColour _legend_land_contours[] = {

    82

	MK(0x5A, STR_00F0_100M),

    83

	MK(0x5C, STR_00F1_200M),

    84

	MK(0x5E, STR_00F2_300M),

    85

	MK(0x1F, STR_00F3_400M),

    86

	MK(0x27, STR_00F4_500M),

    87

    88

	MS(0xD7, STR_00EB_ROADS),

    89

	MK(0x0A, STR_00EC_RAILROADS),

    90

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    91

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    92

	MK(0x0F, STR_00EF_VEHICLES),

    93

	MKEND()

    94

};

    95

    96

static const LegendAndColour _legend_vehicles[] = {

    97

	MK(0xB8, STR_00F5_TRAINS),

    98

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    99

	MK(0x98, STR_00F7_SHIPS),

   100

	MK(0x0F, STR_00F8_AIRCRAFT),

   101

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

   102

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   103

	MKEND()

   104

};

   105

   106

static const LegendAndColour _legend_routes[] = {

   107

	MK(0xD7, STR_00EB_ROADS),

   108

	MK(0x0A, STR_00EC_RAILROADS),

   109

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   110

	MS(0x56, STR_011B_RAILROAD_STATION),

   111

   112

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   113

	MK(0xBF, STR_011D_BUS_STATION),

   114

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   115

	MK(0x98, STR_011F_DOCK),

   116

	MKEND()

   117

};

   118

   119

static const LegendAndColour _legend_vegetation[] = {

   120

	MK(0x52, STR_0120_ROUGH_LAND),

   121

	MK(0x54, STR_0121_GRASS_LAND),

   122

	MK(0x37, STR_0122_BARE_LAND),

   123

	MK(0x25, STR_0123_FIELDS),

   124

	MK(0x57, STR_0124_TREES),

   125

	MK(0xD0, STR_00FC_FOREST),

   126

	MS(0x0A, STR_0125_ROCKS),

   127

   128

	MK(0xC2, STR_012A_DESERT),

   129

	MK(0x98, STR_012B_SNOW),

   130

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   131

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   132

	MKEND()

   133

};

   134

   135

static const LegendAndColour _legend_land_owners[] = {

   136

	MK(0xCA, STR_0126_WATER),

   137

	MK(0x54, STR_0127_NO_OWNER),

   138

	MK(0xB4, STR_0128_TOWNS),

   139

	MK(0x20, STR_0129_INDUSTRIES),

   140

	MKEND()

   141

};

   142

#undef MK

   143

#undef MS

   144

#undef MKEND

   145

   146

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

   147

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

   148

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   149

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

   150

static uint _industry_to_list_pos[NUM_INDUSTRYTYPES];

   151

   152

/**

   153

 * Fills an array for the industries legends.

   154

 */

   155

void BuildIndustriesLegend()

   156

{

   157

	const IndustrySpec *indsp;

   158

	uint j = 0;

   159

	uint free_slot, diff;

   160

   161

	/* Add each name */

   162

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

   163

		indsp = GetIndustrySpec(i);

   164

		if (indsp->enabled) {

   165

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

   166

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

   167

			_legend_from_industries[j].type = i;

   168

			_legend_from_industries[j].show_on_map = true;

   169

			_legend_from_industries[j].col_break = false;

   170

			_legend_from_industries[j].end = false;

   171

   172

			/* Store widget number for this industry type */

   173

			_industry_to_list_pos[i] = j;

   174

			j++;

   175

		}

   176

	}

   177

	/* Terminate the list */

   178

	_legend_from_industries[j].end = true;

   179

   180

	/* Store number of enabled industries */

   181

	_smallmap_industry_count = j;

   182

   183

	_industries_per_column = _smallmap_industry_count / 3;

   184

	free_slot = _smallmap_industry_count % 3;

   185

   186

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

   187

	diff = 0;

   188

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

   189

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

   190

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

   191

		if (free_slot > 0) free_slot--;

   192

	}

   193

   194

}

   195

   196

static const LegendAndColour * const _legend_table[] = {

   197

	_legend_land_contours,

   198

	_legend_vehicles,

   199

	_legend_from_industries,

   200

	_legend_routes,

   201

	_legend_vegetation,

   202

	_legend_land_owners,

   203

};

   204

   205

#define MKCOLOR(x) TO_LE32X(x)

   206

   207

/**

   208

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

   209

 */

   210

static const uint32 _map_height_bits[] = {

   211

	MKCOLOR(0x5A5A5A5A),

   212

	MKCOLOR(0x5A5B5A5B),

   213

	MKCOLOR(0x5B5B5B5B),

   214

	MKCOLOR(0x5B5C5B5C),

   215

	MKCOLOR(0x5C5C5C5C),

   216

	MKCOLOR(0x5C5D5C5D),

   217

	MKCOLOR(0x5D5D5D5D),

   218

	MKCOLOR(0x5D5E5D5E),

   219

	MKCOLOR(0x5E5E5E5E),

   220

	MKCOLOR(0x5E5F5E5F),

   221

	MKCOLOR(0x5F5F5F5F),

   222

	MKCOLOR(0x5F1F5F1F),

   223

	MKCOLOR(0x1F1F1F1F),

   224

	MKCOLOR(0x1F271F27),

   225

	MKCOLOR(0x27272727),

   226

	MKCOLOR(0x27272727),

   227

};

   228

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

   229

   230

struct AndOr {

   231

	uint32 mor;

   232

	uint32 mand;

   233

};

   234

   235

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

   236

{

   237

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

   238

}

   239

   240

   241

static const AndOr _smallmap_contours_andor[] = {

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

};

   255

   256

static const AndOr _smallmap_vehicles_andor[] = {

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

};

   270

   271

static const AndOr _smallmap_vegetation_andor[] = {

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

};

   285

   286

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

   287

   288

/**

   289

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

   290

 * function looks exactly the same for all types

   291

 *

   292

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

   293

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

   294

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

   295

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

   296

 * @param reps Number of lines to draw

   297

 * @param mask ?

   298

 * @param proc Pointer to the colour function

   299

 * @see GetSmallMapPixels(TileIndex)

   300

 */

   301

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

   302

{

   303

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   304

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

   305

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

   306

   307

	do {

   308

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

   309

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

   310

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

   311

			if (dst < _screen.dst_ptr) continue;

   312

			if (dst >= dst_ptr_abs_end) continue;

   313

   314

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

   315

			uint8 *val8 = (uint8 *)&val;

   316

   317

			if (dst <= dst_ptr_end) {

   318

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

   319

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

   320

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

   321

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

   322

			} else {

   323

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

   324

				int i = 0;

   325

				do {

   326

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

   327

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

   328

			}

   329

		}

   330

	/* switch to next tile in the column */

   331

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

   332

}

   333

   334

   335

static inline TileType GetEffectiveTileType(TileIndex tile)

   336

{

   337

	TileType t = GetTileType(tile);

   338

   339

	if (t == MP_TUNNELBRIDGE) {

   340

		TransportType tt = GetTunnelBridgeTransportType(tile);

   341

   342

		switch (tt) {

   343

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   344

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   345

			default:             t = MP_WATER;   break;

   346

		}

   347

	}

   348

	return t;

   349

}

   350

   351

/**

   352

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

   353

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

   354

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

   355

 */

   356

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   357

{

   358

	TileType t = GetEffectiveTileType(tile);

   359

   360

	return

   361

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

   362

}

   363

   364

/**

   365

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

   366

 *

   367

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

   368

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

   369

 */

   370

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   371

{

   372

	TileType t = GetEffectiveTileType(tile);

   373

   374

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

   375

}

   376

   377

/**

   378

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

   379

 *

   380

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

   381

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

   382

 */

   383

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   384

{

   385

	TileType t = GetEffectiveTileType(tile);

   386

   387

	if (t == MP_INDUSTRY) {

   388

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

   389

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

   390

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

   391

		} else {

   392

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

   393

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

   394

		}

   395

	}

   396

   397

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

   398

}

   399

   400

/**

   401

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

   402

 *

   403

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

   404

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

   405

 */

   406

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   407

{

   408

	TileType t = GetEffectiveTileType(tile);

   409

	uint32 bits;

   410

   411

	if (t == MP_STATION) {

   412

		switch (GetStationType(tile)) {

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

		}

   420

	} else {

   421

		/* ground color */

   422

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

   423

	}

   424

	return bits;

   425

}

   426

   427

   428

static const uint32 _vegetation_clear_bits[] = {

   429

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

   430

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

   431

	MKCOLOR(0x0A0A0A0A), ///< rocks

   432

	MKCOLOR(0x25252525), ///< fields

   433

	MKCOLOR(0x98989898), ///< snow

   434

	MKCOLOR(0xC2C2C2C2), ///< desert

   435

	MKCOLOR(0x54545454), ///< unused

   436

	MKCOLOR(0x54545454), ///< unused

   437

};

   438

   439

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   440

{

   441

	TileType t = GetEffectiveTileType(tile);

   442

	uint32 bits;

   443

   444

	switch (t) {

   445

		case MP_CLEAR:

   446

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

   447

				bits = MKCOLOR(0x37373737);

   448

			} else {

   449

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   450

			}

   451

			break;

   452

   453

		case MP_INDUSTRY:

   454

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

   455

			break;

   456

   457

		case MP_TREES:

   458

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   459

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

   460

			} else {

   461

				bits = MKCOLOR(0x54575754);

   462

			}

   463

			break;

   464

   465

		default:

   466

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

   467

			break;

   468

	}

   469

   470

	return bits;

   471

}

   472

   473

   474

static uint32 _owner_colors[OWNER_END + 1];

   475

   476

/**

   477

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

   478

 *

   479

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

   480

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

   481

 */

   482

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   483

{

   484

	Owner o;

   485

   486

	switch (GetTileType(tile)) {

   487

		case MP_INDUSTRY: o = OWNER_END;          break;

   488

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   489

		default:          o = GetTileOwner(tile); break;

   490

	}

   491