1

/* $Id$ */

     2

     3

/** @file smallmap_gui.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "functions.h"

     8

#include "bridge_map.h"

     9

#include "clear_map.h"

    10

#include "industry_map.h"

    11

#include "industry.h"

    12

#include "station_map.h"

    13

#include "table/strings.h"

    14

#include "strings.h"

    15

#include "table/sprites.h"

    16

#include "landscape.h"

    17

#include "map.h"

    18

#include "tile.h"

    19

#include "gui.h"

    21

#include "tree_map.h"

    22

#include "tunnel_map.h"

    23

#include "gfx.h"

    24

#include "viewport.h"

    25

#include "player.h"

    26

#include "vehicle.h"

    27

#include "town.h"

    28

#include "sound.h"

    29

#include "variables.h"

    30

#include "blitter/factory.hpp"

    31

#include "tunnelbridge_map.h"

    32

    33

    34

static const Widget _smallmap_widgets[] = {

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

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

    53

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

    54

{  WIDGETS_END},

    55

};

    56

    57

static int _smallmap_type;

    58

static bool _smallmap_show_towns = true;

    59

/* number of used industries */

    60

static int _smallmap_industry_count;

    61

/* number of industries per column*/

    62

static uint _industries_per_column;

    63

    64

/** Macro for ordinary entry of LegendAndColor */

    65

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

    66

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

    67

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

    68

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

    69

 * It will have valid data, though */

    70

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

    71

    72

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

    73

struct LegendAndColour {

    74

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

    75

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

    76

	IndustryType type; ///< type of industry

    77

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

    78

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

    79

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

    80

};

    81

    82

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

    83

static const LegendAndColour _legend_land_contours[] = {

    84

	MK(0x5A, STR_00F0_100M),

    85

	MK(0x5C, STR_00F1_200M),

    86

	MK(0x5E, STR_00F2_300M),

    87

	MK(0x1F, STR_00F3_400M),

    88

	MK(0x27, STR_00F4_500M),

    89

    90

	MS(0xD7, STR_00EB_ROADS),

    91

	MK(0x0A, STR_00EC_RAILROADS),

    92

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    93

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    94

	MK(0x0F, STR_00EF_VEHICLES),

    95

	MKEND()

    96

};

    97

    98

static const LegendAndColour _legend_vehicles[] = {

    99

	MK(0xB8, STR_00F5_TRAINS),

   100

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

   101

	MK(0x98, STR_00F7_SHIPS),

   102

	MK(0x0F, STR_00F8_AIRCRAFT),

   103

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

   104

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   105

	MKEND()

   106

};

   107

   108

static const LegendAndColour _legend_routes[] = {

   109

	MK(0xD7, STR_00EB_ROADS),

   110

	MK(0x0A, STR_00EC_RAILROADS),

   111

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   112

	MS(0x56, STR_011B_RAILROAD_STATION),

   113

   114

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   115

	MK(0xBF, STR_011D_BUS_STATION),

   116

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   117

	MK(0x98, STR_011F_DOCK),

   118

	MKEND()

   119

};

   120

   121

static const LegendAndColour _legend_vegetation[] = {

   122

	MK(0x52, STR_0120_ROUGH_LAND),

   123

	MK(0x54, STR_0121_GRASS_LAND),

   124

	MK(0x37, STR_0122_BARE_LAND),

   125

	MK(0x25, STR_0123_FIELDS),

   126

	MK(0x57, STR_0124_TREES),

   127

	MK(0xD0, STR_00FC_FOREST),

   128

	MS(0x0A, STR_0125_ROCKS),

   129

   130

	MK(0xC2, STR_012A_DESERT),

   131

	MK(0x98, STR_012B_SNOW),

   132

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   133

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   134

	MKEND()

   135

};

   136

   137

static const LegendAndColour _legend_land_owners[] = {

   138

	MK(0xCA, STR_0126_WATER),

   139

	MK(0x54, STR_0127_NO_OWNER),

   140

	MK(0xB4, STR_0128_TOWNS),

   141

	MK(0x20, STR_0129_INDUSTRIES),

   142

	MKEND()

   143

};

   144

#undef MK

   145

#undef MS

   146

#undef MKEND

   147

   148

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

   149

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

   150

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   151

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

   152

static uint _industry_to_list_pos[NUM_INDUSTRYTYPES];

   153

   154

/**

   155

 * Fills an array for the industries legends.

   156

 */

   157

void BuildIndustriesLegend()

   158

{

   159

	const IndustrySpec *indsp;

   160

	uint j = 0;

   161

	uint free_slot, diff;

   162

   163

	/* Add each name */

   164

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

   165

		indsp = GetIndustrySpec(i);

   166

		if (indsp->enabled) {

   167

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

   168

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

   169

			_legend_from_industries[j].type = i;

   170

			_legend_from_industries[j].show_on_map = true;

   171

			_legend_from_industries[j].col_break = false;

   172

			_legend_from_industries[j].end = false;

   173

   174

			/* Store widget number for this industry type */

   175

			_industry_to_list_pos[i] = j;

   176

			j++;

   177

		}

   178

	}

   179

	/* Terminate the list */

   180

	_legend_from_industries[j].end = true;

   181

   182

	/* Store number of enabled industries */

   183

	_smallmap_industry_count = j;

   184

   185

	_industries_per_column = _smallmap_industry_count / 3;

   186

	free_slot = _smallmap_industry_count % 3;

   187

   188

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

   189

	diff = 0;

   190

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

   191

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

   192

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

   193

		if (free_slot > 0) free_slot--;

   194

	}

   195

   196

}

   197

   198

static const LegendAndColour * const _legend_table[] = {

   199

	_legend_land_contours,

   200

	_legend_vehicles,

   201

	_legend_from_industries,

   202

	_legend_routes,

   203

	_legend_vegetation,

   204

	_legend_land_owners,

   205

};

   206

   207

#define MKCOLOR(x) TO_LE32X(x)

   208

   209

/**

   210

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

   211

 */

   212

static const uint32 _map_height_bits[] = {

   213

	MKCOLOR(0x5A5A5A5A),

   214

	MKCOLOR(0x5A5B5A5B),

   215

	MKCOLOR(0x5B5B5B5B),

   216

	MKCOLOR(0x5B5C5B5C),

   217

	MKCOLOR(0x5C5C5C5C),

   218

	MKCOLOR(0x5C5D5C5D),

   219

	MKCOLOR(0x5D5D5D5D),

   220

	MKCOLOR(0x5D5E5D5E),

   221

	MKCOLOR(0x5E5E5E5E),

   222

	MKCOLOR(0x5E5F5E5F),

   223

	MKCOLOR(0x5F5F5F5F),

   224

	MKCOLOR(0x5F1F5F1F),

   225

	MKCOLOR(0x1F1F1F1F),

   226

	MKCOLOR(0x1F271F27),

   227

	MKCOLOR(0x27272727),

   228

	MKCOLOR(0x27272727),

   229

};

   230

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

   231

   232

struct AndOr {

   233

	uint32 mor;

   234

	uint32 mand;

   235

};

   236

   237

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

   238

{

   239

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

   240

}

   241

   242

   243

static const AndOr _smallmap_contours_andor[] = {

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

};

   257

   258

static const AndOr _smallmap_vehicles_andor[] = {

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

};

   272

   273

static const AndOr _smallmap_vegetation_andor[] = {

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

};

   287

   288

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

   289

   290

/**

   291

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

   292

 * function looks exactly the same for all types

   293

 *

   294

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

   295

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

   296

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

   297

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

   298

 * @param reps Number of lines to draw

   299

 * @param mask ?

   300

 * @param proc Pointer to the colour function

   301

 * @see GetSmallMapPixels(TileIndex)

   302

 */

   303

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

   304

{

   305

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   306

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

   307

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

   308

   309

	do {

   310

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

   311

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

   312

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

   313

			if (dst < _screen.dst_ptr) continue;

   314

			if (dst >= dst_ptr_abs_end) continue;

   315

   316

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

   317

			uint8 *val8 = (uint8 *)&val;

   318

   319

			if (dst <= dst_ptr_end) {

   320

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

   321

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

   322

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

   323

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

   324

			} else {

   325

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

   326

				int i = 0;

   327

				do {

   328

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

   329

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

   330

			}

   331

		}

   332

	/* switch to next tile in the column */

   333

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

   334

}

   335

   336

   337

static inline TileType GetEffectiveTileType(TileIndex tile)

   338

{

   339

	TileType t = GetTileType(tile);

   340

   341

	if (t == MP_TUNNELBRIDGE) {

   342

		TransportType tt = GetTunnelBridgeTransportType(tile);

   343

   344

		switch (tt) {

   345

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   346

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   347

			default:             t = MP_WATER;   break;

   348

		}

   349

	}

   350

	return t;

   351

}

   352

   353

/**

   354

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

   355

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

   356

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

   357

 */

   358

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   359

{

   360

	TileType t = GetEffectiveTileType(tile);

   361

   362

	return

   363

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

   364

}

   365

   366

/**

   367

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

   368

 *

   369

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

   370

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

   371

 */

   372

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   373

{

   374

	TileType t = GetEffectiveTileType(tile);

   375

   376

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

   377

}

   378

   379

/**

   380

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

   381

 *

   382

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

   383

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

   384

 */

   385

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   386

{

   387

	TileType t = GetEffectiveTileType(tile);

   388

   389

	if (t == MP_INDUSTRY) {

   390

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

   391

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

   392

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

   393

		} else {

   394

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

   395

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

   396

		}

   397

	}

   398

   399

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

   400

}

   401

   402

/**

   403

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

   404

 *

   405

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

   406

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

   407

 */

   408

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   409

{

   410

	TileType t = GetEffectiveTileType(tile);

   411

	uint32 bits;

   412

   413

	if (t == MP_STATION) {

   414

		switch (GetStationType(tile)) {

   415

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

   416

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

   417

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

   418

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

   419

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

   420

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

   421

		}

   422

	} else {

   423

		/* ground color */

   424

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

   425

	}

   426

	return bits;

   427

}

   428

   429

   430

static const uint32 _vegetation_clear_bits[] = {

   431

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

   432

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

   433

	MKCOLOR(0x0A0A0A0A), ///< rocks

   434

	MKCOLOR(0x25252525), ///< fields

   435

	MKCOLOR(0x98989898), ///< snow

   436

	MKCOLOR(0xC2C2C2C2), ///< desert

   437

	MKCOLOR(0x54545454), ///< unused

   438

	MKCOLOR(0x54545454), ///< unused

   439

};

   440

   441

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   442

{

   443

	TileType t = GetEffectiveTileType(tile);

   444

	uint32 bits;

   445

   446

	switch (t) {

   447

		case MP_CLEAR:

   448

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

   449

				bits = MKCOLOR(0x37373737);

   450

			} else {

   451

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   452

			}

   453

			break;

   454

   455

		case MP_INDUSTRY:

   456

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

   457

			break;

   458

   459

		case MP_TREES:

   460

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   461

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

   462

			} else {

   463

				bits = MKCOLOR(0x54575754);

   464

			}

   465

			break;

   466

   467

		default:

   468

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

   469

			break;

   470

	}

   471

   472

	return bits;

   473

}

   474

   475

   476

static uint32 _owner_colors[OWNER_END + 1];

   477

   478

/**

   479

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

   480

 *

   481

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

   482

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

   483

 */

   484

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   485

{

   486

	Owner o;

   487

   488

	switch (GetTileType(tile)) {

   489

		case MP_INDUSTRY: o = OWNER_END;          break;

   490

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   491

		default:          o = GetTileOwner(tile); break;