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

    14

#include "landscape.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

#include "blitter/factory.hpp"

    29

    30

static const Widget _smallmap_widgets[] = {

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

{  WIDGETS_END},

    48

};

    49

    50

static int _smallmap_type;

    51

static bool _smallmap_show_towns = true;

    52

    53

/** Macro for ordinary entry of LegendAndColor */

    54

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

    55

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

    56

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

    57

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

    58

 * It will have valid data, though */

    59

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

    60

    61

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

    62

struct LegendAndColour {

    63

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

    64

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

    65

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

    66

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

    67

};

    68

    69

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

    70

static const LegendAndColour _legend_land_contours[] = {

    71

	MK(0x5A, STR_00F0_100M),

    72

	MK(0x5C, STR_00F1_200M),

    73

	MK(0x5E, STR_00F2_300M),

    74

	MK(0x1F, STR_00F3_400M),

    75

	MK(0x27, STR_00F4_500M),

    76

    77

	MS(0xD7, STR_00EB_ROADS),

    78

	MK(0x0A, STR_00EC_RAILROADS),

    79

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    80

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    81

	MK(0x0F, STR_00EF_VEHICLES),

    82

	MKEND()

    83

};

    84

    85

static const LegendAndColour _legend_vehicles[] = {

    86

	MK(0xB8, STR_00F5_TRAINS),

    87

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    88

	MK(0x98, STR_00F7_SHIPS),

    89

	MK(0x0F, STR_00F8_AIRCRAFT),

    90

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

    91

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    92

	MKEND()

    93

};

    94

    95

static const LegendAndColour _legend_routes[] = {

    96

	MK(0xD7, STR_00EB_ROADS),

    97

	MK(0x0A, STR_00EC_RAILROADS),

    98

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    99

	MS(0x56, STR_011B_RAILROAD_STATION),

   100

   101

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   102

	MK(0xBF, STR_011D_BUS_STATION),

   103

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   104

	MK(0x98, STR_011F_DOCK),

   105

	MKEND()

   106

};

   107

   108

static const LegendAndColour _legend_vegetation[] = {

   109

	MK(0x52, STR_0120_ROUGH_LAND),

   110

	MK(0x54, STR_0121_GRASS_LAND),

   111

	MK(0x37, STR_0122_BARE_LAND),

   112

	MK(0x25, STR_0123_FIELDS),

   113

	MK(0x57, STR_0124_TREES),

   114

	MK(0xD0, STR_00FC_FOREST),

   115

	MS(0x0A, STR_0125_ROCKS),

   116

   117

	MK(0xC2, STR_012A_DESERT),

   118

	MK(0x98, STR_012B_SNOW),

   119

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   120

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   121

	MKEND()

   122

};

   123

   124

static const LegendAndColour _legend_land_owners[] = {

   125

	MK(0xCA, STR_0126_WATER),

   126

	MK(0x54, STR_0127_NO_OWNER),

   127

	MK(0xB4, STR_0128_TOWNS),

   128

	MK(0x20, STR_0129_INDUSTRIES),

   129

	MKEND()

   130

};

   131

#undef MK

   132

#undef MS

   133

#undef MKEND

   134

   135

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

   136

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

   137

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   138

   139

/**

   140

 * Fills an array for the industries legends.

   141

 */

   142

void BuildIndustriesLegend()

   143

{

   144

	const IndustrySpec *indsp;

   145

	uint j = 0;

   146

   147

	/* Add each name */

   148

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

   149

		indsp = GetIndustrySpec(i);

   150

		if (indsp->enabled) {

   151

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

   152

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

   153

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

   154

			_legend_from_industries[j].end = false;

   155

			j++;

   156

		}

   157

	}

   158

	/* Terminate the list */

   159

	_legend_from_industries[j].end = true;

   160

}

   161

   162

static const LegendAndColour * const _legend_table[] = {

   163

	_legend_land_contours,

   164

	_legend_vehicles,

   165

	_legend_from_industries,

   166

	_legend_routes,

   167

	_legend_vegetation,

   168

	_legend_land_owners,

   169

};

   170

   171

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

   172

{

   173

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   174

	uint8 *val8 = (uint8 *)&val;

   175

   176

	blitter->SetPixel(d, 0, 0, val8[0]);

   177

	blitter->SetPixel(d, 1, 0, val8[1]);

   178

	blitter->SetPixel(d, 2, 0, val8[2]);

   179

	blitter->SetPixel(d, 3, 0, val8[3]);

   180

}

   181

   182

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

   183

{

   184

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   185

	uint8 *val8 = (uint8 *)&val;

   186

   187

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

   188

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

   189

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

   190

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

   191

}

   192

   193

#define MKCOLOR(x) TO_LE32X(x)

   194

   195

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

   196

static const uint32 _map_height_bits[16] = {

   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

   215

struct AndOr {

   216

	uint32 mor;

   217

	uint32 mand;

   218

};

   219

   220

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

   221

{

   222

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

   223

}

   224

   225

   226

static const AndOr _smallmap_contours_andor[] = {

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

};

   240

   241

static const AndOr _smallmap_vehicles_andor[] = {

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

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

   254

};

   255

   256

static const AndOr _smallmap_vegetation_andor[] = {

   257

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

   258

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

   259

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

   260

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

   261

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

   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

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

   272

   273

/**

   274

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

   275

 * function looks exactly the same for all types

   276

 *

   277

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

   278

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

   279

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

   280

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

   281

 * @param reps Number of lines to draw

   282

 * @param mask ?

   283

 * @param proc Pointer to the colour function

   284

 * @see GetSmallMapPixels(TileIndex)

   285

 */

   286

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

   287

{

   288

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   289

	void *dst_ptr_end = blitter->MoveTo(_screen.dst_ptr, _screen.width, _screen.height - 1);

   290

   291

	do {

   292

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

   293

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

   294

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

   295

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

   296

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

   297

		}

   298

	/* switch to next tile in the column */

   299

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

   300

}

   301

   302

   303

static inline TileType GetEffectiveTileType(TileIndex tile)

   304

{

   305

	TileType t = GetTileType(tile);

   306

   307

	if (t == MP_TUNNELBRIDGE) {

   308

		TransportType tt;

   309

   310

		if (IsTunnel(tile)) {

   311

			tt = GetTunnelTransportType(tile);

   312

		} else {

   313

			tt = GetBridgeTransportType(tile);

   314

		}

   315

		switch (tt) {

   316

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   317

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   318

			default:             t = MP_WATER;   break;

   319

		}

   320

	}

   321

	return t;

   322

}

   323

   324

/**

   325

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

   326

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

   327

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

   328

 */

   329

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   330

{

   331

	TileType t = GetEffectiveTileType(tile);

   332

   333

	return

   334

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

   335

}

   336

   337

/**

   338

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

   339

 *

   340

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

   341

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

   342

 */

   343

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   344

{

   345

	TileType t = GetEffectiveTileType(tile);

   346

   347

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

   348

}

   349

   350

/**

   351

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

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

   355

 */

   356

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   357

{

   358

	TileType t = GetEffectiveTileType(tile);

   359

   360

	if (t == MP_INDUSTRY) {

   361

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

   362

	}

   363

   364

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

   365

}

   366

   367

/**

   368

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

   369

 *

   370

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

   371

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

   372

 */

   373

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   374

{

   375

	TileType t = GetEffectiveTileType(tile);

   376

	uint32 bits;

   377

   378

	if (t == MP_STATION) {

   379

		switch (GetStationType(tile)) {

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

		}

   387

	} else {

   388

		/* ground color */

   389

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

   390

	}

   391

	return bits;

   392

}

   393

   394

   395

static const uint32 _vegetation_clear_bits[] = {

   396

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

   397

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

   398

	MKCOLOR(0x0A0A0A0A), ///< rocks

   399

	MKCOLOR(0x25252525), ///< fields

   400

	MKCOLOR(0x98989898), ///< snow

   401

	MKCOLOR(0xC2C2C2C2), ///< desert

   402

	MKCOLOR(0x54545454), ///< unused

   403

	MKCOLOR(0x54545454), ///< unused

   404

};

   405

   406

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   407

{

   408

	TileType t = GetEffectiveTileType(tile);

   409

	uint32 bits;

   410

   411

	switch (t) {

   412

		case MP_CLEAR:

   413

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

   414

				bits = MKCOLOR(0x37373737);

   415

			} else {

   416

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   417

			}

   418

			break;

   419

   420

		case MP_INDUSTRY:

   421

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

   422

			break;

   423

   424

		case MP_TREES:

   425

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   426

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

   427

			} else {

   428

				bits = MKCOLOR(0x54575754);

   429

			}

   430

			break;

   431

   432

		default:

   433

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

   434

			break;

   435

	}

   436

   437

	return bits;

   438

}

   439

   440

   441

static uint32 _owner_colors[OWNER_END + 1];

   442

   443

/**

   444

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

   445

 *

   446

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

   447

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

   448

 */

   449

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   450

{

   451

	Owner o;

   452

   453

	switch (GetTileType(tile)) {

   454

		case MP_INDUSTRY: o = OWNER_END;          break;

   455

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   456

		default:          o = GetTileOwner(tile); break;

   457

	}

   458

   459

	return _owner_colors[o];

   460

}

   461

   462

   463

static const uint32 _smallmap_mask_left[3] = {

   464

	MKCOLOR(0xFF000000),

   465

	MKCOLOR(0xFFFF0000),

   466

	MKCOLOR(0xFFFFFF00),

   467

};

   468

   469

static const uint32 _smallmap_mask_right[] = {

   470

	MKCOLOR(0x000000FF),

   471

	MKCOLOR(0x0000FFFF),

   472

	MKCOLOR(0x00FFFFFF),

   473

};

   474

   475

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

   476

   477

static GetSmallMapPixels *_smallmap_draw_procs[] = {

   478

	GetSmallMapContoursPixels,

   479

	GetSmallMapVehiclesPixels,

   480

	GetSmallMapIndustriesPixels,

   481

	GetSmallMapRoutesPixels,

   482

	GetSmallMapVegetationPixels,

   483

	GetSmallMapOwnerPixels,

   484

};

   485

   486

static const byte _vehicle_type_colors[6] = {

   487

	184, 191, 152, 15, 215, 184

   488

};

   489

   490

   491

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

   492

{

   493

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