1

/* $Id$ */

     2

     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 "station_map.h"

    12

#include "table/strings.h"

    13

#include "table/sprites.h"

    15

#include "map.h"

    16

#include "tile.h"

    17

#include "gui.h"

    18

#include "tree_map.h"

    19

#include "tunnel_map.h"

    20

#include "window.h"

    21

#include "gfx.h"

    22

#include "viewport.h"

    23

#include "player.h"

    24

#include "vehicle.h"

    25

#include "town.h"

    26

#include "sound.h"

    27

#include "variables.h"

    28

    29

static const Widget _smallmap_widgets[] = {

    30

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

    31

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

    32

{ WWT_STICKYBOX,     RESIZE_LR,    13,   434,   445,     0,    13, 0x0,                     STR_STICKY_BUTTON},

    33

{     WWT_PANEL,     RESIZE_RB,    13,     0,   445,    14,   257, 0x0,                     STR_NULL},

    34

{     WWT_INSET,     RESIZE_RB,    13,     2,   443,    16,   255, 0x0,                     STR_NULL},

    35

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   258,   279, SPR_IMG_SHOW_COUNTOURS,  STR_0191_SHOW_LAND_CONTOURS_ON_MAP},

    36

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   258,   279, SPR_IMG_SHOW_VEHICLES,   STR_0192_SHOW_VEHICLES_ON_MAP},

    37

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   258,   279, SPR_IMG_INDUSTRY,        STR_0193_SHOW_INDUSTRIES_ON_MAP},

    38

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   280,   301, SPR_IMG_SHOW_ROUTES,     STR_0194_SHOW_TRANSPORT_ROUTES_ON},

    39

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   280,   301, SPR_IMG_PLANTTREES,      STR_0195_SHOW_VEGETATION_ON_MAP},

    40

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   280,   301, SPR_IMG_COMPANY_GENERAL, STR_0196_SHOW_LAND_OWNERS_ON_MAP},

    41

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   258,   279, SPR_IMG_SMALLMAP,        STR_SMALLMAP_CENTER},

    42

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   280,   301, SPR_IMG_TOWN,            STR_0197_TOGGLE_TOWN_NAMES_ON_OFF},

    43

{     WWT_PANEL,    RESIZE_RTB,    13,     0,   357,   258,   301, 0x0,                     STR_NULL},

    44

{     WWT_PANEL,    RESIZE_RTB,    13,     0,   433,   302,   313, 0x0,                     STR_NULL},

    45

{ WWT_RESIZEBOX,   RESIZE_LRTB,    13,   434,   445,   302,   313, 0x0,                     STR_RESIZE_BUTTON},

    46

{  WIDGETS_END},

    47

};

    48

    49

static int _smallmap_type;

    50

static bool _smallmap_show_towns = true;

    51

    52

#define MK(a,b) a, b

    53

#define MKEND() 0xFFFF

    54

#define MS(a,b) (a | 0x100), b

    55

    56

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

    57

static const uint16 _legend_land_contours[] = {

    58

	MK(0x5A, STR_00F0_100M),

    59

	MK(0x5C, STR_00F1_200M),

    60

	MK(0x5E, STR_00F2_300M),

    61

	MK(0x1F, STR_00F3_400M),

    62

	MK(0x27, STR_00F4_500M),

    63

    64

	MS(0xD7, STR_00EB_ROADS),

    65

	MK(0x0A, STR_00EC_RAILROADS),

    66

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    67

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    68

	MK(0x0F, STR_00EF_VEHICLES),

    69

	MKEND()

    70

};

    71

    72

static const uint16 _legend_vehicles[] = {

    73

	MK(0xB8, STR_00F5_TRAINS),

    74

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    75

	MK(0x98, STR_00F7_SHIPS),

    76

	MK(0x0F, STR_00F8_AIRCRAFT),

    77

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

    78

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    79

	MKEND()

    80

};

    81

    82

static const uint16 _legend_industries_normal[] = {

    83

	MK(0xD7, STR_00FA_COAL_MINE),

    84

	MK(0xB8, STR_00FB_POWER_STATION),

    85

	MK(0x56, STR_00FC_FOREST),

    86

	MK(0xC2, STR_00FD_SAWMILL),

    87

	MK(0xBF, STR_00FE_OIL_REFINERY),

    88

	MK(0x0F, STR_0105_BANK),

    89

    90

	MS(0x30, STR_00FF_FARM),

    91

	MK(0xAE, STR_0100_FACTORY),

    92

	MK(0x98, STR_0102_OIL_WELLS),

    93

	MK(0x37, STR_0103_IRON_ORE_MINE),

    94

	MK(0x0A, STR_0104_STEEL_MILL),

    95

	MKEND()

    96

};

    97

    98

static const uint16 _legend_industries_hilly[] = {

    99

	MK(0xD7, STR_00FA_COAL_MINE),

   100

	MK(0xB8, STR_00FB_POWER_STATION),

   101

	MK(0x56, STR_00FC_FOREST),

   102

	MK(0x0A, STR_0106_PAPER_MILL),

   103

	MK(0xBF, STR_00FE_OIL_REFINERY),

   104

	MK(0x37, STR_0108_FOOD_PROCESSING_PLANT),

   105

	MS(0x30, STR_00FF_FARM),

   106

   107

	MK(0xAE, STR_0101_PRINTING_WORKS),

   108

	MK(0x98, STR_0102_OIL_WELLS),

   109

	MK(0xC2, STR_0107_GOLD_MINE),

   110

	MK(0x0F, STR_0105_BANK),

   111

	MKEND()

   112

};

   113

   114

static const uint16 _legend_industries_desert[] = {

   115

	MK(0xBF, STR_00FE_OIL_REFINERY),

   116

	MK(0x98, STR_0102_OIL_WELLS),

   117

	MK(0x0F, STR_0105_BANK),

   118

	MK(0xB8, STR_0109_DIAMOND_MINE),

   119

	MK(0x37, STR_0108_FOOD_PROCESSING_PLANT),

   120

	MK(0x0A, STR_010A_COPPER_ORE_MINE),

   121

	MK(0x30, STR_00FF_FARM),

   122

	MS(0x56, STR_010B_FRUIT_PLANTATION),

   123

   124

	MK(0x27, STR_010C_RUBBER_PLANTATION),

   125

	MK(0x25, STR_010D_WATER_SUPPLY),

   126

	MK(0xD0, STR_010E_WATER_TOWER),

   127

	MK(0xAE, STR_0100_FACTORY),

   128

	MK(0xC2, STR_010F_LUMBER_MILL),

   129

	MKEND()

   130

};

   131

   132

static const uint16 _legend_industries_candy[] = {

   133

	MK(0x30, STR_0110_COTTON_CANDY_FOREST),

   134

	MK(0xAE, STR_0111_CANDY_FACTORY),

   135

	MK(0x27, STR_0112_BATTERY_FARM),

   136

	MK(0x37, STR_0113_COLA_WELLS),

   137

	MK(0xD0, STR_0114_TOY_SHOP),

   138

	MK(0x0A, STR_0115_TOY_FACTORY),

   139

	MS(0x25, STR_0116_PLASTIC_FOUNTAINS),

   140

   141

	MK(0xB8, STR_0117_FIZZY_DRINK_FACTORY),

   142

	MK(0x98, STR_0118_BUBBLE_GENERATOR),

   143

	MK(0xC2, STR_0119_TOFFEE_QUARRY),

   144

	MK(0x0F, STR_011A_SUGAR_MINE),

   145

	MKEND()

   146

};

   147

   148

static const uint16 _legend_routes[] = {

   149

	MK(0xD7, STR_00EB_ROADS),

   150

	MK(0x0A, STR_00EC_RAILROADS),

   151

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   152

	MS(0x56, STR_011B_RAILROAD_STATION),

   153

   154

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   155

	MK(0xBF, STR_011D_BUS_STATION),

   156

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   157

	MK(0x98, STR_011F_DOCK),

   158

	MKEND()

   159

};

   160

   161

static const uint16 _legend_vegetation[] = {

   162

	MK(0x52, STR_0120_ROUGH_LAND),

   163

	MK(0x54, STR_0121_GRASS_LAND),

   164

	MK(0x37, STR_0122_BARE_LAND),

   165

	MK(0x25, STR_0123_FIELDS),

   166

	MK(0x57, STR_0124_TREES),

   167

	MK(0xD0, STR_00FC_FOREST),

   168

	MS(0x0A, STR_0125_ROCKS),

   169

   170

	MK(0xC2, STR_012A_DESERT),

   171

	MK(0x98, STR_012B_SNOW),

   172

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   173

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   174

	MKEND()

   175

};

   176

   177

static const uint16 _legend_land_owners[] = {

   178

	MK(0xCA, STR_0126_WATER),

   179

	MK(0x54, STR_0127_NO_OWNER),

   180

	MK(0xB4, STR_0128_TOWNS),

   181

	MK(0x20, STR_0129_INDUSTRIES),

   182

	MKEND()

   183

};

   184

#undef MK

   185

#undef MS

   186

#undef MKEND

   187

   188

   189

enum { IND_OFFS = 6 };

   190

static const uint16 * const _legend_table[] = {

   191

	_legend_land_contours,

   192

	_legend_vehicles,

   193

	NULL,

   194

	_legend_routes,

   195

	_legend_vegetation,

   196

	_legend_land_owners,

   197

   198

	_legend_industries_normal,

   199

	_legend_industries_hilly,

   200

	_legend_industries_desert,

   201

	_legend_industries_candy,

   202

};

   203

   204

#if defined(OTTD_ALIGNMENT)

   205

	static inline void WRITE_PIXELS(Pixel* d, uint32 val)

   206

	{

   207

#	if defined(TTD_BIG_ENDIAN)

   208

		d[0] = GB(val, 24, 8);

   209

		d[1] = GB(val, 16, 8);

   210

		d[2] = GB(val,  8, 8);

   211

		d[3] = GB(val,  0, 8);

   212

#	elif defined(TTD_LITTLE_ENDIAN)

   213

		d[0] = GB(val,  0, 8);

   214

		d[1] = GB(val,  8, 8);

   215

		d[2] = GB(val, 16, 8);

   216

		d[3] = GB(val, 24, 8);

   217

#	endif

   218

	}

   219

   220

/* need to use OR, otherwise we will overwrite the wrong pixels at the edges :( */

   221

	static inline void WRITE_PIXELS_OR(Pixel *d, uint32 val)

   222

	{

   223

#	if defined(TTD_BIG_ENDIAN)

   224

		d[0] |= GB(val, 24, 8);

   225

		d[1] |= GB(val, 16, 8);

   226

		d[2] |= GB(val,  8, 8);

   227

		d[3] |= GB(val,  0, 8);

   228

#	elif defined(TTD_LITTLE_ENDIAN)

   229

		d[0] |= GB(val,  0, 8);

   230

		d[1] |= GB(val,  8, 8);

   231

		d[2] |= GB(val, 16, 8);

   232

		d[3] |= GB(val, 24, 8);

   233

#	endif

   234

	}

   235

#else

   236

#	define WRITE_PIXELS(dst, val)   *(uint32*)(dst) = (val);

   237

#	define WRITE_PIXELS_OR(dst,val) *(uint32*)(dst) |= (val);

   238

#endif

   239

   240

#define MKCOLOR(x) TO_LE32X(x)

   241

   242

/* Height encodings; 16 levels XXX - needs updating for more/finer heights! */

   243

static const uint32 _map_height_bits[16] = {

   244

	MKCOLOR(0x5A5A5A5A),

   245

	MKCOLOR(0x5A5B5A5B),

   246

	MKCOLOR(0x5B5B5B5B),

   247

	MKCOLOR(0x5B5C5B5C),

   248

	MKCOLOR(0x5C5C5C5C),

   249

	MKCOLOR(0x5C5D5C5D),

   250

	MKCOLOR(0x5D5D5D5D),

   251

	MKCOLOR(0x5D5E5D5E),

   252

	MKCOLOR(0x5E5E5E5E),

   253

	MKCOLOR(0x5E5F5E5F),

   254

	MKCOLOR(0x5F5F5F5F),

   255

	MKCOLOR(0x5F1F5F1F),

   256

	MKCOLOR(0x1F1F1F1F),

   257

	MKCOLOR(0x1F271F27),

   258

	MKCOLOR(0x27272727),

   259

	MKCOLOR(0x27272727),

   260

};

   261

   262

struct AndOr {

   263

	uint32 mor;

   264

	uint32 mand;

   265

};

   266

   267

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

   268

{

   269

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

   270

}

   271

   272

   273

static const AndOr _smallmap_contours_andor[] = {

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

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

   286

};

   287

   288

static const AndOr _smallmap_vehicles_andor[] = {

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

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

   298

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

   299

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

   300

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

   301

};

   302

   303

static const AndOr _smallmap_vegetation_andor[] = {

   304

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

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

};

   317

   318

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

   319

   320

/**

   321

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

   322

 * function looks exactly the same for all types

   323

 *

   324

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

   325

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

   326

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

   327

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

   328

 * @param reps Number of lines to draw

   329

 * @param mask ?

   330

 * @param proc Pointer to the colour function

   331

 * @see GetSmallMapPixels(TileIndex)

   332

 */

   333

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

   334

{

   335

	Pixel *dst_ptr_end = _screen.dst_ptr + _screen.width * _screen.height - _screen.width;

   336

   337

	do {

   339

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

   341

			if (dst > _screen.dst_ptr && dst < dst_ptr_end)

   342

				WRITE_PIXELS_OR(dst, proc(TileXY(xc, yc)) & mask);

   343

		}

   345

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

   346

}

   347

   348

   349

static inline TileType GetEffectiveTileType(TileIndex tile)

   350

{

   351

	TileType t = GetTileType(tile);

   352

   353

	if (t == MP_TUNNELBRIDGE) {

   354

		TransportType tt;

   355

   356

		if (IsTunnel(tile)) {

   357

			tt = GetTunnelTransportType(tile);

   358

		} else {

   359

			tt = GetBridgeTransportType(tile);

   360

		}

   361

		switch (tt) {

   362

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   363

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   364

			default:             t = MP_WATER;   break;

   365

		}

   366

	}

   367

	return t;

   368

}

   369

   370

/**

   371

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

   372

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

   373

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

   374

 */

   375

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   376

{

   377

	TileType t = GetEffectiveTileType(tile);

   378

   379

	return

   380

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

   381

}

   382

   383

/**

   384

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

   385

 *

   386

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

   387

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

   388

 */

   389

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   390

{

   391

	TileType t = GetEffectiveTileType(tile);

   392

   393

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

   394

}

   395

   396

/**

   397

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

   398

 *

   399

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

   400

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

   401

 */

   402

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   403

{

   404

	TileType t = GetEffectiveTileType(tile);

   405

   406

	if (t == MP_INDUSTRY) {

   408

	}

   409

   410

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

   411

}

   412

   413

/**

   414

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

   415

 *

   416

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

   417

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

   418

 */

   419

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   420

{

   421

	TileType t = GetEffectiveTileType(tile);

   422

	uint32 bits;

   423

   424

	if (t == MP_STATION) {

   425

		switch (GetStationType(tile)) {

   426

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

   427

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

   428

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

   429

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

   430

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

   431

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

   432

		}

   433

	} else {

   435

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

   436

	}

   437

	return bits;

   438

}

   439

   440

   441

static const uint32 _vegetation_clear_bits[] = {

   442

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

   443

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

   444

	MKCOLOR(0x0A0A0A0A), ///< rocks

   445

	MKCOLOR(0x25252525), ///< fields

   446

	MKCOLOR(0x98989898), ///< snow

   447

	MKCOLOR(0xC2C2C2C2), ///< desert

   448

	MKCOLOR(0x54545454), ///< unused

   449

	MKCOLOR(0x54545454), ///< unused

   450

};

   451

   452

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   453

{

   454

	TileType t = GetEffectiveTileType(tile);

   455

	uint32 bits;

   456

   457

	switch (t) {

   458

		case MP_CLEAR:

   459

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

   460

				bits = MKCOLOR(0x37373737);

   461

			} else {

   462

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   463

			}

   464

			break;

   465

   466

		case MP_INDUSTRY:

   467

			bits = GetIndustryType(tile) == IT_FOREST ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   468

			break;

   469

   470

		case MP_TREES:

   471

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   472

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

   473

			} else {

   474

				bits = MKCOLOR(0x54575754);

   475

			}

   476

			break;

   477

   478

		default:

   479

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

   480

			break;

   481

	}

   482

   483

	return bits;

   484

}

   485

   486

   487

static uint32 _owner_colors[OWNER_END + 1];

   488

   489

/**

   490

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

   491

 *

   492

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

   493

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

   494

 */

   495

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)