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

   137

   160

   161

static const LegendAndColour * const _legend_table[] = {

   162

	_legend_land_contours,

   163

	_legend_vehicles,

   165

	_legend_routes,

   166

	_legend_vegetation,

   167

	_legend_land_owners,

   168

};

   169

   170

#if defined(OTTD_ALIGNMENT)

   171

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

   172

	{

   173

#	if defined(TTD_BIG_ENDIAN)

   174

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

   175

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

   176

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

   177

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

   178

#	elif defined(TTD_LITTLE_ENDIAN)

   179

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

   180

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

   181

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

   182

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

   183

#	endif

   184

	}

   185

   186

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

   187

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

   188

	{

   189

#	if defined(TTD_BIG_ENDIAN)

   190

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

   191

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

   192

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

   193

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

   194

#	elif defined(TTD_LITTLE_ENDIAN)

   195

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

   196

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

   197

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

   198

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

   199

#	endif

   200

	}

   201

#else

   202

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

   203

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

   204

#endif

   205

   206

#define MKCOLOR(x) TO_LE32X(x)

   207

   208

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

   209

static const uint32 _map_height_bits[16] = {

   210

	MKCOLOR(0x5A5A5A5A),

   211

	MKCOLOR(0x5A5B5A5B),

   212

	MKCOLOR(0x5B5B5B5B),

   213

	MKCOLOR(0x5B5C5B5C),

   214

	MKCOLOR(0x5C5C5C5C),

   215

	MKCOLOR(0x5C5D5C5D),

   216

	MKCOLOR(0x5D5D5D5D),

   217

	MKCOLOR(0x5D5E5D5E),

   218

	MKCOLOR(0x5E5E5E5E),

   219

	MKCOLOR(0x5E5F5E5F),

   220

	MKCOLOR(0x5F5F5F5F),

   221

	MKCOLOR(0x5F1F5F1F),

   222

	MKCOLOR(0x1F1F1F1F),

   223

	MKCOLOR(0x1F271F27),

   224

	MKCOLOR(0x27272727),

   225

	MKCOLOR(0x27272727),

   226

};

   227

   228

struct AndOr {

   229

	uint32 mor;

   230

	uint32 mand;

   231

};

   232

   233

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

   234

{

   235

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

   236

}

   237

   238

   239

static const AndOr _smallmap_contours_andor[] = {

   240

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

   241

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

   242

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

   243

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

   244

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

   245

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

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

};

   253

   254

static const AndOr _smallmap_vehicles_andor[] = {

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

};

   268

   269

static const AndOr _smallmap_vegetation_andor[] = {

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

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

   281

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

   282

};

   283

   284

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

   285

   286

/**

   287

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

   288

 * function looks exactly the same for all types

   289

 *

   290

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

   291

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

   292

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

   293

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

   294

 * @param reps Number of lines to draw

   295

 * @param mask ?

   296

 * @param proc Pointer to the colour function

   297

 * @see GetSmallMapPixels(TileIndex)

   298

 */

   299

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

   300

{

   301

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

   302

   303

	do {

   304

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

   305

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

   306

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

   307

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

   308

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

   309

		}

   310

	/* switch to next tile in the column */

   311

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

   312

}

   313

   314

   315

static inline TileType GetEffectiveTileType(TileIndex tile)

   316

{

   317

	TileType t = GetTileType(tile);

   318

   319

	if (t == MP_TUNNELBRIDGE) {

   320

		TransportType tt;

   321

   322

		if (IsTunnel(tile)) {

   323

			tt = GetTunnelTransportType(tile);

   324

		} else {

   325

			tt = GetBridgeTransportType(tile);

   326

		}

   327

		switch (tt) {

   328

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   329

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   330

			default:             t = MP_WATER;   break;

   331

		}

   332

	}

   333

	return t;

   334

}

   335

   336

/**

   337

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

   338

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

   339

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

   340

 */

   341

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   342

{

   343

	TileType t = GetEffectiveTileType(tile);

   344

   345

	return

   346

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

   347

}

   348

   349

/**

   350

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

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

   354

 */

   355

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   356

{

   357

	TileType t = GetEffectiveTileType(tile);

   358

   359

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

   360

}

   361

   362

/**

   363

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

   364

 *

   365

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

   366

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

   367

 */

   368

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   369

{

   370

	TileType t = GetEffectiveTileType(tile);

   371

   372

	if (t == MP_INDUSTRY) {

   373

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

   374

	}

   375

   376

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

   377

}

   378

   379

/**

   380

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

   381

 *

   382

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

   383

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

   384

 */

   385

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   386

{

   387

	TileType t = GetEffectiveTileType(tile);

   388

	uint32 bits;

   389

   390

	if (t == MP_STATION) {

   391

		switch (GetStationType(tile)) {

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

		}

   399

	} else {

   400

		/* ground color */

   401

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

   402

	}

   403

	return bits;

   404

}

   405

   406

   407

static const uint32 _vegetation_clear_bits[] = {

   408

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

   409

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

   410

	MKCOLOR(0x0A0A0A0A), ///< rocks

   411

	MKCOLOR(0x25252525), ///< fields

   412

	MKCOLOR(0x98989898), ///< snow

   413

	MKCOLOR(0xC2C2C2C2), ///< desert

   414

	MKCOLOR(0x54545454), ///< unused

   415

	MKCOLOR(0x54545454), ///< unused

   416

};

   417

   418

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   419

{

   420

	TileType t = GetEffectiveTileType(tile);

   421

	uint32 bits;

   422

   423

	switch (t) {

   424

		case MP_CLEAR:

   425

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

   426

				bits = MKCOLOR(0x37373737);

   427

			} else {

   428

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   429

			}

   430

			break;

   431

   432

		case MP_INDUSTRY:

   433

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

   434

			break;

   435

   436

		case MP_TREES:

   437

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   438

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

   439

			} else {

   440

				bits = MKCOLOR(0x54575754);

   441

			}

   442

			break;

   443

   444

		default:

   445

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

   446

			break;

   447

	}

   448

   449

	return bits;

   450

}

   451

   452

   453

static uint32 _owner_colors[OWNER_END + 1];

   454

   455

/**

   456

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

   457

 *

   458

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

   459

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

   460

 */

   461

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   462

{

   463

	Owner o;

   464

   465

	switch (GetTileType(tile)) {

   466

		case MP_INDUSTRY: o = OWNER_END;          break;

   467

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   468

		default:          o = GetTileOwner(tile); break;

   469

	}

   470

   471

	return _owner_colors[o];

   472

}

   473

   474

   475

static const uint32 _smallmap_mask_left[3] = {

   476

	MKCOLOR(0xFF000000),

   477

	MKCOLOR(0xFFFF0000),

   478

	MKCOLOR(0xFFFFFF00),

   479

};

   480

   481

static const uint32 _smallmap_mask_right[] = {

   482

	MKCOLOR(0x000000FF),

   483

	MKCOLOR(0x0000FFFF),

   484

	MKCOLOR(0x00FFFFFF),

   485

};

   486

   487

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

   488

   489

static GetSmallMapPixels *_smallmap_draw_procs[] = {

   490

	GetSmallMapContoursPixels,

   491

	GetSmallMapVehiclesPixels,

   492

	GetSmallMapIndustriesPixels,

   493

	GetSmallMapRoutesPixels,