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

    12

#include "table/strings.h"

    13

#include "strings.h"

    14

#include "table/sprites.h"

    15

#include "landscape.h"

    16

#include "map.h"

    17

#include "tile.h"

    18

#include "gui.h"

    19

#include "tree_map.h"

    20

#include "tunnel_map.h"

    21

#include "window.h"

    22

#include "gfx.h"

    23

#include "viewport.h"

    24

#include "player.h"

    25

#include "vehicle.h"

    26

#include "town.h"

    27

#include "sound.h"

    28

#include "variables.h"

    29

#include "blitter/factory.hpp"

    30

    31

static const Widget _smallmap_widgets[] = {

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

{  WIDGETS_END},

    49

};

    50

    51

static int _smallmap_type;

    52

static bool _smallmap_show_towns = true;

    53

    54

/** Macro for ordinary entry of LegendAndColor */

    55

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

    56

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

    57

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

    58

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

    59

 * It will have valid data, though */

    60

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

    61

    62

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

    63

struct LegendAndColour {

    64

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

    65

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

    66

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

    67

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

    68

};

    69

    70

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

    71

static const LegendAndColour _legend_land_contours[] = {

    72

	MK(0x5A, STR_00F0_100M),

    73

	MK(0x5C, STR_00F1_200M),

    74

	MK(0x5E, STR_00F2_300M),

    75

	MK(0x1F, STR_00F3_400M),

    76

	MK(0x27, STR_00F4_500M),

    77

    78

	MS(0xD7, STR_00EB_ROADS),

    79

	MK(0x0A, STR_00EC_RAILROADS),

    80

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    81

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    82

	MK(0x0F, STR_00EF_VEHICLES),

    83

	MKEND()

    84

};

    85

    86

static const LegendAndColour _legend_vehicles[] = {

    87

	MK(0xB8, STR_00F5_TRAINS),

    88

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    89

	MK(0x98, STR_00F7_SHIPS),

    90

	MK(0x0F, STR_00F8_AIRCRAFT),

    91

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

    92

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    93

	MKEND()

    94

};

    95

    96

static const LegendAndColour _legend_routes[] = {

    97

	MK(0xD7, STR_00EB_ROADS),

    98

	MK(0x0A, STR_00EC_RAILROADS),

    99

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   100

	MS(0x56, STR_011B_RAILROAD_STATION),

   101

   102

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   103

	MK(0xBF, STR_011D_BUS_STATION),

   104

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   105

	MK(0x98, STR_011F_DOCK),

   106

	MKEND()

   107

};

   108

   109

static const LegendAndColour _legend_vegetation[] = {

   110

	MK(0x52, STR_0120_ROUGH_LAND),

   111

	MK(0x54, STR_0121_GRASS_LAND),

   112

	MK(0x37, STR_0122_BARE_LAND),

   113

	MK(0x25, STR_0123_FIELDS),

   114

	MK(0x57, STR_0124_TREES),

   115

	MK(0xD0, STR_00FC_FOREST),

   116

	MS(0x0A, STR_0125_ROCKS),

   117

   118

	MK(0xC2, STR_012A_DESERT),

   119

	MK(0x98, STR_012B_SNOW),

   120

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   121

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   122

	MKEND()

   123

};

   124

   125

static const LegendAndColour _legend_land_owners[] = {

   126

	MK(0xCA, STR_0126_WATER),

   127

	MK(0x54, STR_0127_NO_OWNER),

   128

	MK(0xB4, STR_0128_TOWNS),

   129

	MK(0x20, STR_0129_INDUSTRIES),

   130

	MKEND()

   131

};

   132

#undef MK

   133

#undef MS

   134

#undef MKEND

   135

   136

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

   137

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

   138

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   139

   140

/**

   141

 * Fills an array for the industries legends.

   142

 */

   143

void BuildIndustriesLegend()

   144

{

   145

	const IndustrySpec *indsp;

   146

	uint j = 0;

   147

   148

	/* Add each name */

   149

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

   150

		indsp = GetIndustrySpec(i);

   151

		if (indsp->enabled) {

   152

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

   153

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

   154

			_legend_from_industries[j].col_break = (j % 6) == 0;  // break is performed on the 7th item

   155

			_legend_from_industries[j].end = false;

   156

			j++;

   157

		}

   158

	}

   159

	/* Terminate the list */

   160

	_legend_from_industries[j].end = true;

   161

}

   162

   163

static const LegendAndColour * const _legend_table[] = {

   164

	_legend_land_contours,

   165

	_legend_vehicles,

   166

	_legend_from_industries,

   167

	_legend_routes,

   168

	_legend_vegetation,

   169

	_legend_land_owners,

   170

};

   171

   172

#define MKCOLOR(x) TO_LE32X(x)

   173

   174

/**

   175

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

   176

 */

   177

static const uint32 _map_height_bits[] = {

   178

	MKCOLOR(0x5A5A5A5A),

   179

	MKCOLOR(0x5A5B5A5B),

   180

	MKCOLOR(0x5B5B5B5B),

   181

	MKCOLOR(0x5B5C5B5C),

   182

	MKCOLOR(0x5C5C5C5C),

   183

	MKCOLOR(0x5C5D5C5D),

   184

	MKCOLOR(0x5D5D5D5D),

   185

	MKCOLOR(0x5D5E5D5E),

   186

	MKCOLOR(0x5E5E5E5E),

   187

	MKCOLOR(0x5E5F5E5F),

   188

	MKCOLOR(0x5F5F5F5F),

   189

	MKCOLOR(0x5F1F5F1F),

   190

	MKCOLOR(0x1F1F1F1F),

   191

	MKCOLOR(0x1F271F27),

   192

	MKCOLOR(0x27272727),

   193

	MKCOLOR(0x27272727),

   194

};

   195

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

   196

   197

struct AndOr {

   198

	uint32 mor;

   199

	uint32 mand;

   200

};

   201

   202

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

   203

{

   204

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

   205

}

   206

   207

   208

static const AndOr _smallmap_contours_andor[] = {

   209

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

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

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

   221

};

   222

   223

static const AndOr _smallmap_vehicles_andor[] = {

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

};

   237

   238

static const AndOr _smallmap_vegetation_andor[] = {

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

};

   252

   253

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

   254

   255

/**

   256

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

   257

 * function looks exactly the same for all types

   258

 *

   259

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

   260

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

   261

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

   262

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

   263

 * @param reps Number of lines to draw

   264

 * @param mask ?

   265

 * @param proc Pointer to the colour function

   266

 * @see GetSmallMapPixels(TileIndex)

   267

 */

   268

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

   269

{

   270

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   271

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

   272

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

   273

   274

	do {

   275

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

   276

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

   277

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

   278

			if (dst < _screen.dst_ptr) continue;

   279

			if (dst >= dst_ptr_abs_end) continue;

   280

   281

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

   282

			uint8 *val8 = (uint8 *)&val;

   283

   284

			if (dst <= dst_ptr_end) {

   285

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

   286

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

   287

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

   288

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

   289

			} else {

   290

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

   291

				int i = 0;

   292

				do {

   293

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

   294

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

   295

			}

   296

		}

   297

	/* switch to next tile in the column */

   298

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

   299

}

   300

   301

   302

static inline TileType GetEffectiveTileType(TileIndex tile)

   303

{

   304

	TileType t = GetTileType(tile);

   305

   306

	if (t == MP_TUNNELBRIDGE) {

   307

		TransportType tt;

   308

   309

		if (IsTunnel(tile)) {

   310

			tt = GetTunnelTransportType(tile);

   311

		} else {

   312

			tt = GetBridgeTransportType(tile);

   313

		}

   314

		switch (tt) {

   315

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   316

			case TRANSPORT_ROAD: t = MP_ROAD;    break;

   317

			default:             t = MP_WATER;   break;

   318

		}

   319

	}

   320

	return t;

   321

}

   322

   323

/**

   324

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

   325

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

   326

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

   327

 */

   328

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   329

{

   330

	TileType t = GetEffectiveTileType(tile);

   331

   332

	return

   333

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

   334

}

   335

   336

/**

   337

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

   338

 *

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

   341

 */

   342

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   343

{

   344

	TileType t = GetEffectiveTileType(tile);

   345

   346

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

   347

}

   348

   349

/**

   350

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

   351

 *

   352

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

   353

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

   354

 */

   355

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   356

{

   357

	TileType t = GetEffectiveTileType(tile);

   358

   359

	if (t == MP_INDUSTRY) {

   360

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

   361

	}

   362

   363

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

   364

}

   365

   366

/**

   367

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

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

   371

 */

   372

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   373

{

   374

	TileType t = GetEffectiveTileType(tile);

   375

	uint32 bits;

   376

   377

	if (t == MP_STATION) {

   378

		switch (GetStationType(tile)) {

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

		}

   386

	} else {

   387

		/* ground color */

   388

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

   389

	}

   390

	return bits;

   391

}

   392

   393

   394

static const uint32 _vegetation_clear_bits[] = {

   395

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

   396

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

   397

	MKCOLOR(0x0A0A0A0A), ///< rocks

   398

	MKCOLOR(0x25252525), ///< fields

   399

	MKCOLOR(0x98989898), ///< snow

   400

	MKCOLOR(0xC2C2C2C2), ///< desert

   401

	MKCOLOR(0x54545454), ///< unused

   402

	MKCOLOR(0x54545454), ///< unused

   403

};

   404

   405

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   406

{

   407

	TileType t = GetEffectiveTileType(tile);

   408

	uint32 bits;

   409

   410

	switch (t) {

   411

		case MP_CLEAR:

   412

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

   413

				bits = MKCOLOR(0x37373737);

   414

			} else {

   415

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   416

			}

   417

			break;

   418

   419

		case MP_INDUSTRY:

   420

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

   421

			break;

   422

   423

		case MP_TREES:

   424

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   425

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

   426

			} else {

   427

				bits = MKCOLOR(0x54575754);

   428

			}

   429

			break;

   430

   431

		default:

   432

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

   433

			break;

   434

	}

   435

   436

	return bits;

   437

}

   438

   439

   440

static uint32 _owner_colors[OWNER_END + 1];

   441

   442

/**

   443

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

   444

 *

   445

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

   446

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

   447

 */

   448

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   449

{

   450

	Owner o;

   451

   452

	switch (GetTileType(tile)) {

   453

		case MP_INDUSTRY: o = OWNER_END;          break;

   454

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   455

		default:          o = GetTileOwner(tile); break;

   456

	}

   457

   458

	return _owner_colors[o];

   459

}

   460

   461

   462

static const uint32 _smallmap_mask_left[3] = {

   463

	MKCOLOR(0xFF000000),

   464

	MKCOLOR(0xFFFF0000),

   465

	MKCOLOR(0xFFFFFF00),

   466

};

   467

   468

static const uint32 _smallmap_mask_right[] = {

   469

	MKCOLOR(0x000000FF),

   470

	MKCOLOR(0x0000FFFF),

   471

	MKCOLOR(0x00FFFFFF),

   472

};

   473

   474

/* each tile has 4 x pixels and 1 y pixel */

   475

   476

static GetSmallMapPixels *_smallmap_draw_procs[] = {

   477

	GetSmallMapContoursPixels,

   478

	GetSmallMapVehiclesPixels,

   479

	GetSmallMapIndustriesPixels,

   480

	GetSmallMapRoutesPixels,

   481

	GetSmallMapVegetationPixels,

   482

	GetSmallMapOwnerPixels,

   483

};

   484

   485

static const byte _vehicle_type_colors[6] = {

   486

	184, 191, 152, 15, 215, 184

   487

};

   488

   489

   490

static void DrawVertMapIndicator(int x, int y, int x2, int y2)

   491

{

   492

	GfxFillRect(x, y,      x2, y + 3, 69);

   493

	GfxFillRect(x, y2 - 3, x2, y2,    69);