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

    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

/** Macro for ordinary entry of LegendAndColor */

    53

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

    54

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

    55

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

    56

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

    57

 * It will have valid data, though */

    58

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

    59

    60

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

    61

struct LegendAndColour {

    62

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

    63

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

    64

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

    65

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

    66

};

    67

    68

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

    69

static const LegendAndColour _legend_land_contours[] = {

    70

	MK(0x5A, STR_00F0_100M),

    71

	MK(0x5C, STR_00F1_200M),

    72

	MK(0x5E, STR_00F2_300M),

    73

	MK(0x1F, STR_00F3_400M),

    74

	MK(0x27, STR_00F4_500M),

    75

    76

	MS(0xD7, STR_00EB_ROADS),

    77

	MK(0x0A, STR_00EC_RAILROADS),

    78

	MK(0x98, STR_00ED_STATIONS_AIRPORTS_DOCKS),

    79

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    80

	MK(0x0F, STR_00EF_VEHICLES),

    81

	MKEND()

    82

};

    83

    84

static const LegendAndColour _legend_vehicles[] = {

    85

	MK(0xB8, STR_00F5_TRAINS),

    86

	MK(0xBF, STR_00F6_ROAD_VEHICLES),

    87

	MK(0x98, STR_00F7_SHIPS),

    88

	MK(0x0F, STR_00F8_AIRCRAFT),

    89

	MS(0xD7, STR_00F9_TRANSPORT_ROUTES),

    90

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    91

	MKEND()

    92

};

    93

    94

static const LegendAndColour _legend_routes[] = {

    95

	MK(0xD7, STR_00EB_ROADS),

    96

	MK(0x0A, STR_00EC_RAILROADS),

    97

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

    98

	MS(0x56, STR_011B_RAILROAD_STATION),

    99

   100

	MK(0xC2, STR_011C_TRUCK_LOADING_BAY),

   101

	MK(0xBF, STR_011D_BUS_STATION),

   102

	MK(0xB8, STR_011E_AIRPORT_HELIPORT),

   103

	MK(0x98, STR_011F_DOCK),

   104

	MKEND()

   105

};

   106

   107

static const LegendAndColour _legend_vegetation[] = {

   108

	MK(0x52, STR_0120_ROUGH_LAND),

   109

	MK(0x54, STR_0121_GRASS_LAND),

   110

	MK(0x37, STR_0122_BARE_LAND),

   111

	MK(0x25, STR_0123_FIELDS),

   112

	MK(0x57, STR_0124_TREES),

   113

	MK(0xD0, STR_00FC_FOREST),

   114

	MS(0x0A, STR_0125_ROCKS),

   115

   116

	MK(0xC2, STR_012A_DESERT),

   117

	MK(0x98, STR_012B_SNOW),

   118

	MK(0xD7, STR_00F9_TRANSPORT_ROUTES),

   119

	MK(0xB5, STR_00EE_BUILDINGS_INDUSTRIES),

   120

	MKEND()

   121

};

   122

   123

static const LegendAndColour _legend_land_owners[] = {

   124

	MK(0xCA, STR_0126_WATER),

   125

	MK(0x54, STR_0127_NO_OWNER),

   126

	MK(0xB4, STR_0128_TOWNS),

   127

	MK(0x20, STR_0129_INDUSTRIES),

   128

	MKEND()

   129

};

   130

#undef MK

   131

#undef MS

   132

#undef MKEND

   133

   134

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

   135

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

   136

static LegendAndColour _legend_from_industries[NUM_INDUSTRYTYPES+1];

   137

   138

/**

   139

 * Fills an array for the industries legends.

   140

 */

   141

void BuildIndustriesLegend()

   142

{

   143

	const IndustrySpec *indsp;

   144

	uint j = 0;

   145

   146

	/* Add each name */

   147

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

   148

		indsp = GetIndustrySpec(i);

   149

		if (indsp->enabled) {

   150

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

   151

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

   152

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

   153

			_legend_from_industries[j].end = false;

   154

			j++;

   155

		}

   156

	}

   157

	/* Terminate the list */

   158

	_legend_from_industries[j].end = true;

   159

}

   160

   161

static const LegendAndColour * const _legend_table[] = {

   162

	_legend_land_contours,

   163

	_legend_vehicles,

   164

	_legend_from_industries,

   165

	_legend_routes,

   166

	_legend_vegetation,

   167

	_legend_land_owners,

   168

};

   169

   170

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

   171

{

   172

	uint8 *val8 = (uint8 *)&val;

   173

	_screen.renderer->SetPixel(d, 0, 0, val8[0]);

   174

	_screen.renderer->SetPixel(d, 1, 0, val8[1]);

   175

	_screen.renderer->SetPixel(d, 2, 0, val8[2]);

   176

	_screen.renderer->SetPixel(d, 3, 0, val8[3]);

   177

}

   178

   179

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

   180

{

   181

	uint8 *val8 = (uint8 *)&val;

   182

	_screen.renderer->SetPixelIfEmpty(d, 0, 0, val8[0]);

   183

	_screen.renderer->SetPixelIfEmpty(d, 1, 0, val8[1]);

   184

	_screen.renderer->SetPixelIfEmpty(d, 2, 0, val8[2]);

   185

	_screen.renderer->SetPixelIfEmpty(d, 3, 0, val8[3]);

   186

}

   187

   188

#define MKCOLOR(x) TO_LE32X(x)

   189

   190

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

   191

static const uint32 _map_height_bits[16] = {

   192

	MKCOLOR(0x5A5A5A5A),

   193

	MKCOLOR(0x5A5B5A5B),

   194

	MKCOLOR(0x5B5B5B5B),

   195

	MKCOLOR(0x5B5C5B5C),

   196

	MKCOLOR(0x5C5C5C5C),

   197

	MKCOLOR(0x5C5D5C5D),

   198

	MKCOLOR(0x5D5D5D5D),

   199

	MKCOLOR(0x5D5E5D5E),

   200

	MKCOLOR(0x5E5E5E5E),

   201

	MKCOLOR(0x5E5F5E5F),

   202

	MKCOLOR(0x5F5F5F5F),

   203

	MKCOLOR(0x5F1F5F1F),

   204

	MKCOLOR(0x1F1F1F1F),

   205

	MKCOLOR(0x1F271F27),

   206

	MKCOLOR(0x27272727),

   207

	MKCOLOR(0x27272727),

   208

};

   209

   210

struct AndOr {

   211

	uint32 mor;

   212

	uint32 mand;

   213

};

   214

   215

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

   216

{

   217

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

   218

}

   219

   220

   221

static const AndOr _smallmap_contours_andor[] = {

   222

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

   223

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

   224

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

   225

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

   226

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

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

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

   234

};

   235

   236

static const AndOr _smallmap_vehicles_andor[] = {

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

};

   250

   251

static const AndOr _smallmap_vegetation_andor[] = {

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

};

   265

   266

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

   267

   268

/**

   269

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

   270

 * function looks exactly the same for all types

   271

 *

   272

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

   273

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

   274

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

   275

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

   276

 * @param reps Number of lines to draw

   277

 * @param mask ?

   278

 * @param proc Pointer to the colour function

   279

 * @see GetSmallMapPixels(TileIndex)

   280

 */

   281

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

   282

{

   283

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

   284

   285

	do {

   286

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

   287

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

   288

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

   289

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

   290

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

   291

		}

   292

	/* switch to next tile in the column */

   293

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

   294

}

   295

   296

   297

static inline TileType GetEffectiveTileType(TileIndex tile)

   298

{

   299

	TileType t = GetTileType(tile);

   300

   301

	if (t == MP_TUNNELBRIDGE) {

   302

		TransportType tt;

   303

   304

		if (IsTunnel(tile)) {

   305

			tt = GetTunnelTransportType(tile);

   306

		} else {

   307

			tt = GetBridgeTransportType(tile);

   308

		}

   309

		switch (tt) {

   310

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   311

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   312

			default:             t = MP_WATER;   break;

   313

		}

   314

	}

   315

	return t;

   316

}

   317

   318

/**

   319

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

   320

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

   321

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

   322

 */

   323

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   324

{

   325

	TileType t = GetEffectiveTileType(tile);

   326

   327

	return

   328

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

   329

}

   330

   331

/**

   332

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

   333

 *

   334

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

   335

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

   336

 */

   337

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   338

{

   339

	TileType t = GetEffectiveTileType(tile);

   340

   341

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

   342

}

   343

   344

/**

   345

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

   346

 *

   347

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

   348

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

   349

 */

   350

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   351

{

   352

	TileType t = GetEffectiveTileType(tile);

   353

   354

	if (t == MP_INDUSTRY) {

   355

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

   356

	}

   357

   358

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

   359

}

   360

   361

/**

   362

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

   363

 *

   364

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

   365

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

   366

 */

   367

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   368

{

   369

	TileType t = GetEffectiveTileType(tile);

   370

	uint32 bits;

   371

   372

	if (t == MP_STATION) {

   373

		switch (GetStationType(tile)) {

   374

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

   375

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

   376

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

   377

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

   378

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

   379

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

   380

		}

   381

	} else {

   382

		/* ground color */

   383

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

   384

	}

   385

	return bits;

   386

}

   387

   388

   389

static const uint32 _vegetation_clear_bits[] = {

   390

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

   391

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

   392

	MKCOLOR(0x0A0A0A0A), ///< rocks

   393

	MKCOLOR(0x25252525), ///< fields

   394

	MKCOLOR(0x98989898), ///< snow

   395

	MKCOLOR(0xC2C2C2C2), ///< desert

   396

	MKCOLOR(0x54545454), ///< unused

   397

	MKCOLOR(0x54545454), ///< unused

   398

};

   399

   400

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   401

{

   402

	TileType t = GetEffectiveTileType(tile);

   403

	uint32 bits;

   404

   405

	switch (t) {

   406

		case MP_CLEAR:

   407

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

   408

				bits = MKCOLOR(0x37373737);

   409

			} else {

   410

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   411

			}

   412

			break;

   413

   414

		case MP_INDUSTRY:

   415

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

   416

			break;

   417

   418

		case MP_TREES:

   419

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   420

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

   421

			} else {

   422

				bits = MKCOLOR(0x54575754);

   423

			}

   424

			break;

   425

   426

		default:

   427

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

   428

			break;

   429

	}

   430

   431

	return bits;

   432

}

   433

   434

   435

static uint32 _owner_colors[OWNER_END + 1];

   436

   437

/**

   438

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

   439

 *

   440

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

   441

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

   442

 */

   443

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   444

{

   445

	Owner o;

   446

   447

	switch (GetTileType(tile)) {

   448

		case MP_INDUSTRY: o = OWNER_END;          break;

   449

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   450

		default:          o = GetTileOwner(tile); break;

   451

	}

   452

   453

	return _owner_colors[o];

   454

}

   455

   456

   457

static const uint32 _smallmap_mask_left[3] = {

   458

	MKCOLOR(0xFF000000),

   459

	MKCOLOR(0xFFFF0000),

   460

	MKCOLOR(0xFFFFFF00),

   461

};

   462

   463

static const uint32 _smallmap_mask_right[] = {

   464

	MKCOLOR(0x000000FF),

   465

	MKCOLOR(0x0000FFFF),

   466

	MKCOLOR(0x00FFFFFF),

   467

};

   468

   469

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

   470

   471

static GetSmallMapPixels *_smallmap_draw_procs[] = {

   472

	GetSmallMapContoursPixels,

   473

	GetSmallMapVehiclesPixels,

   474

	GetSmallMapIndustriesPixels,

   475

	GetSmallMapRoutesPixels,

   476

	GetSmallMapVegetationPixels,

   477

	GetSmallMapOwnerPixels,

   478

};

   479

   480

static const byte _vehicle_type_colors[6] = {

   481

	184, 191, 152, 15, 215, 184

   482

};

   483

   484

   485

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

   486

{

   487

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

   488

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

   489

}

   490

   491

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

   492

{

   493

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