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},

    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

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

   173

{

   174

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   175

	uint8 *val8 = (uint8 *)&val;

   176

   177

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

   178

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

   179

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

   180

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

   181

}

   182

   183

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

   184

{

   185

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   186

	uint8 *val8 = (uint8 *)&val;

   187

   188

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

   189

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

   190

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

   191

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

   192

}

   193

   194

#define MKCOLOR(x) TO_LE32X(x)

   195

   196

/**

   197

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

   198

 */

   199

static const uint32 _map_height_bits[] = {

   200

	MKCOLOR(0x5A5A5A5A),

   201

	MKCOLOR(0x5A5B5A5B),

   202

	MKCOLOR(0x5B5B5B5B),

   203

	MKCOLOR(0x5B5C5B5C),

   204

	MKCOLOR(0x5C5C5C5C),

   205

	MKCOLOR(0x5C5D5C5D),

   206

	MKCOLOR(0x5D5D5D5D),

   207

	MKCOLOR(0x5D5E5D5E),

   208

	MKCOLOR(0x5E5E5E5E),

   209

	MKCOLOR(0x5E5F5E5F),

   210

	MKCOLOR(0x5F5F5F5F),

   211

	MKCOLOR(0x5F1F5F1F),

   212

	MKCOLOR(0x1F1F1F1F),

   213

	MKCOLOR(0x1F271F27),

   214

	MKCOLOR(0x27272727),

   215

	MKCOLOR(0x27272727),

   216

};

   217

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

   218

   219

struct AndOr {

   220

	uint32 mor;

   221

	uint32 mand;

   222

};

   223

   224

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

   225

{

   226

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

   227

}

   228

   229

   230

static const AndOr _smallmap_contours_andor[] = {

   231

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

   232

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

   233

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

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

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

   241

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

   242

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

   243

};

   244

   245

static const AndOr _smallmap_vehicles_andor[] = {

   246

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

   247

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

   248

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

   249

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

   250

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

   251

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

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

};

   259

   260

static const AndOr _smallmap_vegetation_andor[] = {

   261

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

   262

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

   263

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

   264

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

   265

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

   266

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

   267

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

   268

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

   269

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

   270

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

   271

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

   272

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

   273

};

   274

   275

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

   276

   277

/**

   278

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

   279

 * function looks exactly the same for all types

   280

 *

   281

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

   282

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

   283

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

   284

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

   285

 * @param reps Number of lines to draw

   286

 * @param mask ?

   287

 * @param proc Pointer to the colour function

   288

 * @see GetSmallMapPixels(TileIndex)

   289

 */

   290

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

   291

{

   292

	Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   293

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

   294

   295

	do {

   296

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

   297

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

   298

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

   299

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

   300

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

   301

		}

   302

	/* switch to next tile in the column */

   303

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

   304

}

   305

   306

   307

static inline TileType GetEffectiveTileType(TileIndex tile)

   308

{

   309

	TileType t = GetTileType(tile);

   310

   311

	if (t == MP_TUNNELBRIDGE) {

   312

		TransportType tt;

   313

   314

		if (IsTunnel(tile)) {

   315

			tt = GetTunnelTransportType(tile);

   316

		} else {

   317

			tt = GetBridgeTransportType(tile);

   318

		}

   319

		switch (tt) {

   320

			case TRANSPORT_RAIL: t = MP_RAILWAY; break;

   321

			case TRANSPORT_ROAD: t = MP_STREET;  break;

   322

			default:             t = MP_WATER;   break;

   323

		}

   324

	}

   325

	return t;

   326

}

   327

   328

/**

   329

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

   330

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

   331

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

   332

 */

   333

static inline uint32 GetSmallMapContoursPixels(TileIndex tile)

   334

{

   335

	TileType t = GetEffectiveTileType(tile);

   336

   337

	return

   338

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

   339

}

   340

   341

/**

   342

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

   343

 *

   344

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

   345

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

   346

 */

   347

static inline uint32 GetSmallMapVehiclesPixels(TileIndex tile)

   348

{

   349

	TileType t = GetEffectiveTileType(tile);

   350

   351

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

   352

}

   353

   354

/**

   355

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

   356

 *

   357

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

   358

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

   359

 */

   360

static inline uint32 GetSmallMapIndustriesPixels(TileIndex tile)

   361

{

   362

	TileType t = GetEffectiveTileType(tile);

   363

   364

	if (t == MP_INDUSTRY) {

   365

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

   366

	}

   367

   368

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

   369

}

   370

   371

/**

   372

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

   373

 *

   374

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

   375

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

   376

 */

   377

static inline uint32 GetSmallMapRoutesPixels(TileIndex tile)

   378

{

   379

	TileType t = GetEffectiveTileType(tile);

   380

	uint32 bits;

   381

   382

	if (t == MP_STATION) {

   383

		switch (GetStationType(tile)) {

   384

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

   385

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

   386

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

   387

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

   388

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

   389

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

   390

		}

   391

	} else {

   392

		/* ground color */

   393

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

   394

	}

   395

	return bits;

   396

}

   397

   398

   399

static const uint32 _vegetation_clear_bits[] = {

   400

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

   401

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

   402

	MKCOLOR(0x0A0A0A0A), ///< rocks

   403

	MKCOLOR(0x25252525), ///< fields

   404

	MKCOLOR(0x98989898), ///< snow

   405

	MKCOLOR(0xC2C2C2C2), ///< desert

   406

	MKCOLOR(0x54545454), ///< unused

   407

	MKCOLOR(0x54545454), ///< unused

   408

};

   409

   410

static inline uint32 GetSmallMapVegetationPixels(TileIndex tile)

   411

{

   412

	TileType t = GetEffectiveTileType(tile);

   413

	uint32 bits;

   414

   415

	switch (t) {

   416

		case MP_CLEAR:

   417

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

   418

				bits = MKCOLOR(0x37373737);

   419

			} else {

   420

				bits = _vegetation_clear_bits[GetClearGround(tile)];

   421

			}

   422

			break;

   423

   424

		case MP_INDUSTRY:

   425

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

   426

			break;

   427

   428

		case MP_TREES:

   429

			if (GetTreeGround(tile) == TREE_GROUND_SNOW_DESERT) {

   430

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

   431

			} else {

   432

				bits = MKCOLOR(0x54575754);

   433

			}

   434

			break;

   435

   436

		default:

   437

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

   438

			break;

   439

	}

   440

   441

	return bits;

   442

}

   443

   444

   445

static uint32 _owner_colors[OWNER_END + 1];

   446

   447

/**

   448

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

   449

 *

   450

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

   451

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

   452

 */

   453

static inline uint32 GetSmallMapOwnerPixels(TileIndex tile)

   454

{

   455

	Owner o;

   456

   457

	switch (GetTileType(tile)) {

   458

		case MP_INDUSTRY: o = OWNER_END;          break;

   459

		case MP_HOUSE:    o = OWNER_TOWN;         break;

   460

		default:          o = GetTileOwner(tile); break;

   461

	}

   462

   463

	return _owner_colors[o];

   464

}

   465

   466

   467

static const uint32 _smallmap_mask_left[3] = {

   468

	MKCOLOR(0xFF000000),

   469

	MKCOLOR(0xFFFF0000),

   470

	MKCOLOR(0xFFFFFF00),

   471

};

   472

   473

static const uint32 _smallmap_mask_right[] = {

   474

	MKCOLOR(0x000000FF),

   475

	MKCOLOR(0x0000FFFF),

   476

	MKCOLOR(0x00FFFFFF),

   477

};

   478

   479

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

   480

   481

static GetSmallMapPixels *_smallmap_draw_procs[] = {

   482

	GetSmallMapContoursPixels,

   483

	GetSmallMapVehiclesPixels,

   484

	GetSmallMapIndustriesPixels,

   485

	GetSmallMapRoutesPixels,

   486

	GetSmallMapVegetationPixels,

   487

	GetSmallMapOwnerPixels,

   488

};

   489

   490

static const byte _vehicle_type_colors[6] = {

   491

	184, 191, 152, 15, 215, 184

   492

};

   493