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 "company_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_PANEL,    RESIZE_RTB,  COLOUR_BROWN,     0,   261,   158,   201, 0x0,                     STR_NULL},

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    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

    61

/** Macro for ordinary entry of LegendAndColor */

    62

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

    63

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

    64

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

    65

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

    66

 * It will have valid data, though */

    67

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

    68

    69

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

    70

struct LegendAndColour {

    71

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

    72

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

    73

	IndustryType type; ///< type of industry

    74

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

    75

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

    76

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

    77

};

    78

    79

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

    80

static const LegendAndColour _legend_land_contours[] = {

    81

	MK(0x5A, STR_00F0_100M),

    82

	MK(0x5C, STR_00F1_200M),

    83

	MK(0x5E, STR_00F2_300M),

    84

	MK(0x1F, STR_00F3_400M),

    85

	MK(0x27, STR_00F4_500M),

    86

    87

	MS(0xD7, STR_00EB_ROADS),

    88

	MK(0x0A, STR_00EC_RAILROADS),

    89

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    90

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    91

	MK(0x0F, STR_00EF_VEHICLES),

    92

	MKEND()

    93

};

    94

    95

static const LegendAndColour _legend_vehicles[] = {

    96

	MK(0xB8, STR_00F5_TRAINS),

    97

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    98

	MK(0x98, STR_00F7_SHIPS),

    99

	MK(0x0F, STR_00F8_AIRCRAFT),

   100

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

   101

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   102

	MKEND()

   103

};

   104

   105

static const LegendAndColour _legend_routes[] = {

   106

	MK(0xD7, STR_00EB_ROADS),

   107

	MK(0x0A, STR_00EC_RAILROADS),

   108

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   109

	MS(0x56, STR_011B_RAILROAD_STATION),

   110

   111

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   112

	MK(0xBF, STR_011D_BUS_STATION),

   113

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   114

	MK(0x98, STR_011F_DOCK),

   115

	MKEND()

   116

};

   117

   118

static const LegendAndColour _legend_vegetation[] = {

   119

	MK(0x52, STR_0120_ROUGH_LAND),

   120

	MK(0x54, STR_0121_GRASS_LAND),

   121

	MK(0x37, STR_0122_BARE_LAND),

   122

	MK(0x25, STR_0123_FIELDS),

   123

	MK(0x57, STR_0124_TREES),

   124

	MK(0xD0, STR_00FC_FOREST),

   125

	MS(0x0A, STR_0125_ROCKS),

   126

   127

	MK(0xC2, STR_012A_DESERT),

   128

	MK(0x98, STR_012B_SNOW),

   129

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   130

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   131

	MKEND()

   132

};

   133

   134

static const LegendAndColour _legend_land_owners[] = {

   135

	MK(0xCA, STR_0126_WATER),

   136

	MK(0x54, STR_0127_NO_OWNER),

   137

	MK(0xB4, STR_0128_TOWNS),

   138

	MK(0x20, STR_0129_INDUSTRIES),

   139

	MKEND()

   140

};

   141

#undef MK

   142

#undef MS

   143

#undef MKEND

   144

   145

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

   146

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

   147

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   148

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

   149

static uint _industry_to_list_pos[NUM_INDUSTRYTYPES];

   150

   151

/**

   152

 * Fills an array for the industries legends.

   153

 */

   154

void BuildIndustriesLegend()

   155

{

   156

	const IndustrySpec *indsp;

   157

	uint j = 0;

   158

   159

	/* Add each name */

   160

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

   161

		indsp = GetIndustrySpec(i);

   162

		if (indsp->enabled) {

   163

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

   164

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

   165

			_legend_from_industries[j].type = i;

   166

			_legend_from_industries[j].show_on_map = true;

   167

			_legend_from_industries[j].col_break = false;

   168

			_legend_from_industries[j].end = false;

   169

   170

			/* Store widget number for this industry type */

   171

			_industry_to_list_pos[i] = j;

   172

			j++;

   173

		}

   174

	}

   175

	/* Terminate the list */

   176

	_legend_from_industries[j].end = true;

   177

   178

	/* Store number of enabled industries */

   179

	_smallmap_industry_count = j;

   180

}

   181

   182

static const LegendAndColour * const _legend_table[] = {

   183

	_legend_land_contours,

   184

	_legend_vehicles,

   185

	_legend_from_industries,

   186

	_legend_routes,

   187

	_legend_vegetation,

   188

	_legend_land_owners,

   189

};

   190

   191

#define MKCOLOR(x) TO_LE32X(x)

   192

   193

/**

   194

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

   195

 */

   196

static const uint32 _map_height_bits[] = {

   197

	MKCOLOR(0x5A5A5A5A),

   198

	MKCOLOR(0x5A5B5A5B),

   199

	MKCOLOR(0x5B5B5B5B),

   200

	MKCOLOR(0x5B5C5B5C),

   201

	MKCOLOR(0x5C5C5C5C),

   202

	MKCOLOR(0x5C5D5C5D),

   203

	MKCOLOR(0x5D5D5D5D),

   204

	MKCOLOR(0x5D5E5D5E),

   205

	MKCOLOR(0x5E5E5E5E),

   206

	MKCOLOR(0x5E5F5E5F),

   207

	MKCOLOR(0x5F5F5F5F),

   208

	MKCOLOR(0x5F1F5F1F),

   209

	MKCOLOR(0x1F1F1F1F),

   210

	MKCOLOR(0x1F271F27),

   211

	MKCOLOR(0x27272727),

   212

	MKCOLOR(0x27272727),

   213

};

   214

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

   215

   216

struct AndOr {

   217

	uint32 mor;

   218

	uint32 mand;

   219

};

   220

   221

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

   222

{

   223

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

   224

}

   225

   226

   227

static const AndOr _smallmap_contours_andor[] = {

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

};

   241

   242

static const AndOr _smallmap_vehicles_andor[] = {

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   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(0x00D7D700), MKCOLOR(0xFF0000FF)},

   255

};

   256

   257

static const AndOr _smallmap_vegetation_andor[] = {

   258

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

   259

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

   260

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

   261

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

   262

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

   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

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

   273

   274

/**

   275

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

   276

 * function looks exactly the same for all types

   277

 *

   278

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

   279

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

   280

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

   281

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

   282

 * @param reps Number of lines to draw

   283

 * @param mask ?

   284

 * @param proc Pointer to the colour function

   285

 * @see GetSmallMapPixels(TileIndex)

   286

 */

   287

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

   288

{

   289

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   290

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

   291

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

   292

   293

	do {

   294

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

   295

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

   296

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

   297

			if (dst < _screen.dst_ptr) continue;

   298

			if (dst >= dst_ptr_abs_end) continue;

   299

   300

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

   301

			uint8 *val8 = (uint8 *)&val;

   302

   303

			if (dst <= dst_ptr_end) {

   304

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

   305

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

   306

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

   307

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

   308

			} else {

   309

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

   310

				int i = 0;

   311

				do {

   312

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

   313

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

   314

			}

   315

		}

   316

	/* switch to next tile in the column */

   317

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

   318

}

   319

   320

   321

static inline TileType GetEffectiveTileType(TileIndex tile)

   322

{

   323

	TileType t = GetTileType(tile);

   324

   325

	if (t == MP_TUNNELBRIDGE) {

   326

		TransportType tt = GetTunnelBridgeTransportType(tile);

   327

   328

		switch (tt) {

   329

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   330

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   331

			default:             t = MP_WATER;   break;

   332

		}

   333

	}

   334

	return t;

   335

}

   336

   337

/**

   338

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

   339

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

   340

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

   341

 */

   342

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   343

{

   344

	TileType t = GetEffectiveTileType(tile);

   345

   346

	return

   347

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

   348

}

   349

   350

/**

   351

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

   352

 *

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

   355

 */

   356

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   357

{

   358

	TileType t = GetEffectiveTileType(tile);

   359

   360

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

   361

}

   362

   363

/**

   364

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

   365

 *

   366

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

   367

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

   368

 */

   369

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   370

{

   371

	TileType t = GetEffectiveTileType(tile);

   372

   373

	if (t == MP_INDUSTRY) {

   374

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

   375

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

   376

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

   377

		} else {

   378

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

   379

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

   380

		}

   381

	}

   382

   383

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

   384

}

   385

   386

/**

   387

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

   388

 *

   389

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

   390

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

   391

 */

   392

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   393

{

   394

	TileType t = GetEffectiveTileType(tile);

   395

	uint32 bits;

   396

   397

	if (t == MP_STATION) {

   398

		switch (GetStationType(tile)) {

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

		}

   406

	} else {

   407

		/* ground color */

   408

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

   409

	}

   410

	return bits;

   411

}

   412

   413

   414

static const uint32 _vegetation_clear_bits[] = {

   415

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

   416

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

   417

	MKCOLOR(0x0A0A0A0A), ///< rocks

   418

	MKCOLOR(0x25252525), ///< fields

   419

	MKCOLOR(0x98989898), ///< snow

   420

	MKCOLOR(0xC2C2C2C2), ///< desert

   421

	MKCOLOR(0x54545454), ///< unused

   422

	MKCOLOR(0x54545454), ///< unused

   423

};

   424

   425

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   426

{

   427

	TileType t = GetEffectiveTileType(tile);

   428

	uint32 bits;

   429

   430

	switch (t) {

   431

		case MP_CLEAR:

   432

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

   433

				bits = MKCOLOR(0x37373737);

   434

			} else {

   435

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   436

			}

   437

			break;

   438

   439

		case MP_INDUSTRY:

   440

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

   441

			break;

   442

   443

		case MP_TREES:

   444

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   445

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

   446

			} else {

   447

				bits = MKCOLOR(0x54575754);

   448

			}

   449

			break;

   450

   451

		default:

   452

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

   453

			break;

   454

	}

   455

   456

	return bits;

   457

}

   458

   459

   460

static uint32 _owner_colors[OWNER_END + 1];

   461

   462

/**

   463

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

   464

 *

   465

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

   466

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

   467

 */

   468

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   469

{

   470

	Owner o;

   471

   472

	switch (GetTileType(tile)) {

   473

		case MP_INDUSTRY: o = OWNER_END;          break;

   474

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   475

		default:          o = GetTileOwner(tile); break;

   476

		/* FIXME: For MP_ROAD there are multiple owners.

   477

		 * GetTileOwner returns the rail owner (level crossing) resp. the owner of ROADTYPE_ROAD (normal road),

   478

		 * even if there are no ROADTYPE_ROAD bits on the tile.

   479

		 */

   480

	}

   481

   482

	return _owner_colors[o];

   483

}

   484

   485

   486

static const uint32 _smallmap_mask_left[3] = {

   487

	MKCOLOR(0xFF000000),

   488

	MKCOLOR(0xFFFF0000),

   489

	MKCOLOR(0xFFFFFF00),

   490

};

   491