1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     6

#include "gui.h"

     7

#include "window.h"

     8

#include "gfx.h"

     9

#include "viewport.h"

    10

#include "player.h"

    11

#include "vehicle.h"

    12

#include "town.h"

    13

#include "sound.h"

    14

    15

static const Widget _smallmap_widgets[] = {

    16

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

    17

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

    18

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

    19

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

    20

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

    21

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   258,   279, 0x2E2,				STR_0191_SHOW_LAND_CONTOURS_ON_MAP},

    22

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   258,   279, 0x2E3,				STR_0192_SHOW_VEHICLES_ON_MAP},

    23

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   258,   279, 0x2E5,				STR_0193_SHOW_INDUSTRIES_ON_MAP},

    24

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   380,   401,   280,   301, 0x2E4,				STR_0194_SHOW_TRANSPORT_ROUTES_ON},

    25

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   402,   423,   280,   301, 0x2E6,				STR_0195_SHOW_VEGETATION_ON_MAP},

    26

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   424,   445,   280,   301, 0x2E7,				STR_0196_SHOW_LAND_OWNERS_ON_MAP},

    27

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   258,   279, 0x0,					STR_NULL},

    28

{     WWT_IMGBTN,   RESIZE_LRTB,    13,   358,   379,   280,   301, 0xFED,				STR_0197_TOGGLE_TOWN_NAMES_ON_OFF},

    29

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

    30

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

    31

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

    32

{   WIDGETS_END},

    33

};

    34

    35

static int _smallmap_type;

    36

static bool _smallmap_show_towns = true;

    37

    38

#define MK(a,b) a,b

    39

#define MKEND() 0xffff

    40

#define MS(a,b) (a|0x100),b

    41

    42

static const uint16 _legend_land_contours[] = {

    43

	MK(0x5A,STR_00F0_100M),

    44

	MK(0x5C,STR_00F1_200M),

    45

	MK(0x5E,STR_00F2_300M),

    46

	MK(0x1F,STR_00F3_400M),

    47

	MK(0x27,STR_00F4_500M),

    48

    49

	MS(0xD7,STR_00EB_ROADS),

    50

	MK(0x0A,STR_00EC_RAILROADS),

    51

	MK(0x98,STR_00ED_STATIONS_AIRPORTS_DOCKS),

    52

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    53

	MK(0x0F,STR_00EF_VEHICLES),

    54

	MKEND()

    55

};

    56

    57

static const uint16 _legend_vehicles[] = {

    58

	MK(0xB8,STR_00F5_TRAINS),

    59

	MK(0xBF,STR_00F6_ROAD_VEHICLES),

    60

	MK(0x98,STR_00F7_SHIPS),

    61

	MK(0x0F,STR_00F8_AIRCRAFT),

    62

	MS(0xD7,STR_00F9_TRANSPORT_ROUTES),

    63

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

    64

	MKEND()

    65

};

    66

    67

static const uint16 _legend_industries_normal[] = {

    68

	MK(0xD7,STR_00FA_COAL_MINE),

    69

	MK(0xB8,STR_00FB_POWER_STATION),

    70

	MK(0x56,STR_00FC_FOREST),

    71

	MK(0xC2,STR_00FD_SAWMILL),

    72

	MK(0xBF,STR_00FE_OIL_REFINERY),

    73

	MK(0x0F,STR_0105_BANK),

    74

    75

	MS(0x30,STR_00FF_FARM),

    76

	MK(0xAE,STR_0100_FACTORY),

    77

	MK(0x98,STR_0102_OIL_WELLS),

    78

	MK(0x37,STR_0103_IRON_ORE_MINE),

    79

	MK(0x0A,STR_0104_STEEL_MILL),

    80

	MKEND()

    81

};

    82

    83

static const uint16 _legend_industries_hilly[] = {

    84

	MK(0xD7,STR_00FA_COAL_MINE),

    85

	MK(0xB8,STR_00FB_POWER_STATION),

    86

	MK(0x56,STR_00FC_FOREST),

    87

	MK(0x0A,STR_0106_PAPER_MILL),

    88

	MK(0xBF,STR_00FE_OIL_REFINERY),

    89

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

    90

	MS(0x30,STR_00FF_FARM),

    91

    92

	MK(0xAE,STR_0101_PRINTING_WORKS),

    93

	MK(0x98,STR_0102_OIL_WELLS),

    94

	MK(0xC2,STR_0107_GOLD_MINE),

    95

	MK(0x0F,STR_0105_BANK),

    96

	MKEND()

    97

};

    98

    99

static const uint16 _legend_industries_desert[] = {

   100

	MK(0xBF,STR_00FE_OIL_REFINERY),

   101

	MK(0x98,STR_0102_OIL_WELLS),

   102

	MK(0x0F,STR_0105_BANK),

   103

	MK(0xB8,STR_0109_DIAMOND_MINE),

   104

	MK(0x37,STR_0108_FOOD_PROCESSING_PLANT),

   105

	MK(0x0A,STR_010A_COPPER_ORE_MINE),

   106

	MK(0x30,STR_00FF_FARM),

   107

	MS(0x56,STR_010B_FRUIT_PLANTATION),

   108

   109

	MK(0x27,STR_010C_RUBBER_PLANTATION),

   110

	MK(0x25,STR_010D_WATER_SUPPLY),

   111

	MK(0xD0,STR_010E_WATER_TOWER),

   112

	MK(0xAE,STR_0100_FACTORY),

   113

	MK(0xC2,STR_010F_LUMBER_MILL),

   114

	MKEND()

   115

};

   116

   117

static const uint16 _legend_industries_candy[] = {

   118

	MK(0x30,STR_0110_COTTON_CANDY_FOREST),

   119

	MK(0xAE,STR_0111_CANDY_FACTORY),

   120

	MK(0x27,STR_0112_BATTERY_FARM),

   121

	MK(0x37,STR_0113_COLA_WELLS),

   122

	MK(0xD0,STR_0114_TOY_SHOP),

   123

	MK(0x0A,STR_0115_TOY_FACTORY),

   124

	MS(0x25,STR_0116_PLASTIC_FOUNTAINS),

   125

   126

	MK(0xB8,STR_0117_FIZZY_DRINK_FACTORY),

   127

	MK(0x98,STR_0118_BUBBLE_GENERATOR),

   128

	MK(0xC2,STR_0119_TOFFEE_QUARRY),

   129

	MK(0x0F,STR_011A_SUGAR_MINE),

   130

	MKEND()

   131

};

   132

   133

static const uint16 _legend_routes[] = {

   134

	MK(0xD7,STR_00EB_ROADS),

   135

	MK(0x0A,STR_00EC_RAILROADS),

   136

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   137

	MS(0x56,STR_011B_RAILROAD_STATION),

   138

   139

	MK(0xC2,STR_011C_TRUCK_LOADING_BAY),

   140

	MK(0xBF,STR_011D_BUS_STATION),

   141

	MK(0xB8,STR_011E_AIRPORT_HELIPORT),

   142

	MK(0x98,STR_011F_DOCK),

   143

	MKEND()

   144

};

   145

   146

static const uint16 _legend_vegetation[] = {

   147

	MK(0x52,STR_0120_ROUGH_LAND),

   148

	MK(0x54,STR_0121_GRASS_LAND),

   149

	MK(0x37,STR_0122_BARE_LAND),

   150

	MK(0x25,STR_0123_FIELDS),

   151

	MK(0x57,STR_0124_TREES),

   152

	MK(0xD0,STR_00FC_FOREST),

   153

	MS(0x0A,STR_0125_ROCKS),

   154

   155

	MK(0xC2,STR_012A_DESERT),

   156

	MK(0x98,STR_012B_SNOW),

   157

	MK(0xD7,STR_00F9_TRANSPORT_ROUTES),

   158

	MK(0xB5,STR_00EE_BUILDINGS_INDUSTRIES),

   159

	MKEND()

   160

};

   161

   162

static const uint16 _legend_land_owners[] = {

   163

	MK(0xCA,STR_0126_WATER),

   164

	MK(0x54,STR_0127_NO_OWNER),

   165

	MK(0xB4,STR_0128_TOWNS),

   166

	MK(0x20,STR_0129_INDUSTRIES),

   167

	MKEND()

   168

};

   169

#undef MK

   170

#undef MS

   171

#undef MKEND

   172

   173

   174

enum { IND_OFFS = 6 };

   175

static const uint16 * const _legend_table[] = {

   176

	_legend_land_contours,

   177

	_legend_vehicles,

   178

	NULL,

   179

	_legend_routes,

   180

	_legend_vegetation,

   181

	_legend_land_owners,

   182

   183

	_legend_industries_normal,

   184

	_legend_industries_hilly,

   185

	_legend_industries_desert,

   186

	_legend_industries_candy,

   187

};

   188

   189

#if defined(TTD_ALIGNMENT_4)

   190

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

   191

	{

   192

		byte *d = (byte*)dst;

   193

#	if defined(TTD_BIG_ENDIAN)

   194

		d[0] = (byte)(val >> 24);

   195

		d[1] = (byte)(val >> 16);

   196

		d[2] = (byte)(val >> 8);

   197

		d[3] = (byte)(val >> 0);

   198

#	elif defined(TTD_LITTLE_ENDIAN)

   199

		d[0] = (byte)(val >> 0);

   200

		d[1] = (byte)(val >> 8);

   201

		d[2] = (byte)(val >> 16);

   202

		d[3] = (byte)(val >> 24);

   203

#	endif

   204

	}

   205

   206

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

   207

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

   208

	{

   209

		byte *d = (byte*)dst;

   210

#	if defined(TTD_BIG_ENDIAN)

   211

		d[0] |= (byte)(val >> 24);

   212

		d[1] |= (byte)(val >> 16);

   213

		d[2] |= (byte)(val >> 8);

   214

		d[3] |= (byte)(val >> 0);

   215

#	elif defined(TTD_LITTLE_ENDIAN)

   216

		d[0] |= (byte)(val >> 0);

   217

		d[1] |= (byte)(val >> 8);

   218

		d[2] |= (byte)(val >> 16);

   219

		d[3] |= (byte)(val >> 24);

   220

#	endif

   221

	}

   222

#else

   223

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

   224

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

   225

#endif

   226

   227

#if defined(TTD_BIG_ENDIAN)

   228

#	define MKCOLOR(x) BSWAP32(x)

   229

#elif defined(TTD_LITTLE_ENDIAN)

   230

#	define MKCOLOR(x) (x)

   231

#endif

   232

   233

static const uint32 _map_height_bits[16] = {

   234

	MKCOLOR(0x5A5A5A5A),

   235

	MKCOLOR(0x5A5B5A5B),

   236

	MKCOLOR(0x5B5B5B5B),

   237

	MKCOLOR(0x5B5C5B5C),

   238

	MKCOLOR(0x5C5C5C5C),

   239

	MKCOLOR(0x5C5D5C5D),

   240

	MKCOLOR(0x5D5D5D5D),

   241

	MKCOLOR(0x5D5E5D5E),

   242

	MKCOLOR(0x5E5E5E5E),

   243

	MKCOLOR(0x5E5F5E5F),

   244

	MKCOLOR(0x5F5F5F5F),

   245

	MKCOLOR(0x5F1F5F1F),

   246

	MKCOLOR(0x1F1F1F1F),

   247

	MKCOLOR(0x1F271F27),

   248

	MKCOLOR(0x27272727),

   249

	MKCOLOR(0x27272727),

   250

};

   251

   252

static const uint32 _smallmap_contours_andor[12][2] = {

   253

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

   254

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

   255

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

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

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

   263

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

   264

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

   265

};

   266

   267

static const uint32 _smallmap_vehicles_andor[12][2] = {

   268

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

   269

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

   270

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

   271

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

   272

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

   273

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

   274

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

   275

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

   276

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

   277

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

   278

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

   279

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

   280

};

   281

   282

static const uint32 _smallmap_vegetation_andor[12][2] = {

   283

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

   284

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

   285

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

   286

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

   287

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

   288

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

   289

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

   290

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

   291

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

   292

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

   293

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

   294

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

   295

};

   296

   297

static inline uint32 GetSmallMapCountoursPixels(uint tile)

   298

{

   299

	uint t;

   300

   301

	t = TileType(tile);

   302

	if (t == MP_TUNNELBRIDGE) {

   303

		t = _map5[tile];

   304

		if ((t & 0x80) == 0) t>>=1;

   305

		if ((t & 6) == 0) {

   306

			t = MP_RAILWAY;

   307

		} else if ((t & 6) == 2) {

   308

			t = MP_STREET;

   309

		} else {

   310

			t = MP_WATER;

   311

		}

   312

	}

   313

   314

	return (_map_height_bits[TileHeight(tile)] & _smallmap_contours_andor[t][1]) | _smallmap_contours_andor[t][0];

   315

}

   316

   317

static void DrawSmallMapContours(byte *dst, uint xc, uint yc, int pitch, int reps, uint32 mask)

   318

{

   319

	do {

   320

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

   321

		    if (dst > _screen.dst_ptr && dst < (_screen.dst_ptr + _screen.width * _screen.height - _screen.width) )

   322

		        WRITE_PIXELS_OR( dst, GetSmallMapCountoursPixels(TILE_XY(xc,yc)) & mask );

   323

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

   324

}

   325

   326

   327

static inline uint32 GetSmallMapVehiclesPixels(uint tile)

   328

{

   329

	uint t;

   330

   331

	t = TileType(tile);

   332

	if (t == MP_TUNNELBRIDGE) {

   333

		t = _map5[tile];

   334

		if ((t & 0x80) == 0) t>>=1;

   335

		if ((t & 6) == 0) {

   336

			t = MP_RAILWAY;

   337

		} else if ((t & 6) == 2) {

   338

			t = MP_STREET;

   339

		} else {

   340

			t = MP_WATER;

   341

		}

   342

	}

   343

	return (MKCOLOR(0x54545454) & _smallmap_vehicles_andor[t][1]) | _smallmap_vehicles_andor[t][0];

   344

}

   345

   346

   347

static void DrawSmallMapVehicles(byte *dst, uint xc, uint yc, int pitch, int reps, uint32 mask)

   348

{

   349

	do {

   350

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

   351

			WRITE_PIXELS_OR( dst, GetSmallMapVehiclesPixels(TILE_XY(xc,yc)) & mask );

   352

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

   353

}

   354

   355

static const byte _industry_smallmap_colors[175] = {

   356

	215,215,215,215,215,215,215,184,

   357

	184,184,184,194,194,194,194,194,

   358

	 86, 86,191,191,191,191,191,191,

   359

	152,152,152,152,152,152,152,152,

   360

	152, 48, 48, 48, 48, 48, 48,174,

   361

	174,174,174,174,174,174,174, 10,

   362

	 10, 10, 10, 10, 10, 10, 10, 10,

   363

	 10, 10, 15, 15, 55, 55, 55, 55,

   364

	 10, 10, 10, 10, 10, 10, 10, 10,

   365

	194,194,194,194,194,194,194,194,

   366

	194,194,194,194,194,194,194,194,

   367

	194, 15, 15,184,184,184,184,184,

   368

	184,184,184,184, 55, 55, 55, 55,

   369

	 55, 55, 55, 55, 55, 55, 55, 55,

   370

	 55, 55, 55, 55, 86, 39, 37, 37,

   371

	208,174,174,174,174,194,194,194,

   372

	194, 48, 48,174,174,174,174, 39,

   373

	 39, 55,208,208,208,208, 10, 10,

   374

	 10, 10, 10, 10, 37, 37, 37, 37,

   375

	 37, 37, 37, 37,184,184,184,184,

   376

	152,152,152,152,194,194,194, 15,

   377

	 15, 15, 15, 15, 15, 15, 15,

   378

};

   379

   380

static inline uint32 GetSmallMapIndustriesPixels(uint tile)

   381

{

   382

	int t;

   383

   384

	t = TileType(tile);

   385

	if (t == MP_INDUSTRY) {

   386

		byte color = _industry_smallmap_colors[_map5[tile]];

   387

		return color + (color << 8) + (color << 16) + (color << 24);

   388

	} else {

   389

		if (t == MP_TUNNELBRIDGE) {

   390

			t = _map5[tile];

   391

			if ((t & 0x80) == 0) t>>=1;

   392

			if ((t & 6) == 0) {

   393

				t = MP_RAILWAY;

   394

			} else if ((t & 6) == 2) {

   395

				t = MP_STREET;

   396

			} else {

   397

				t = MP_WATER;

   398

			}

   399

		}

   400

		return ((MKCOLOR(0x54545454) & _smallmap_vehicles_andor[t][1]) | _smallmap_vehicles_andor[t][0]);

   401

	}

   402

}

   403

   404

static void DrawSmallMapIndustries(byte *dst, uint xc, uint yc, int pitch, int reps, uint32 mask)

   405

{

   406

	do {

   407

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

   408

			WRITE_PIXELS_OR(dst, GetSmallMapIndustriesPixels(TILE_XY(xc,yc)) & mask);

   409

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

   410

}

   411

   412

static inline uint32 GetSmallMapRoutesPixels(uint tile)

   413

{

   414

	int t;

   415

	uint32 bits;

   416

   417

	t = TileType(tile);

   418

	if (t == MP_STATION) {

   419

		byte m5 = _map5[tile];

   420

		(bits = MKCOLOR(0x56565656), m5 < 8) ||			//   8 - railroad station (green)

   421

		(bits = MKCOLOR(0xB8B8B8B8), m5 < 0x43) ||	//  67 - airport (red)

   422

		(bits = MKCOLOR(0xC2C2C2C2), m5 < 0x47) ||	//  71 - truck loading bay (orange)

   423

		(bits = MKCOLOR(0xBFBFBFBF), m5 < 0x4B) ||	//  75 - bus station (yellow)

   424

		(bits = MKCOLOR(0x98989898), m5 < 0x53) ||	//  83 - docks (blue)

   425

		(bits = MKCOLOR(0xB8B8B8B8), m5 < 0x73) ||	// 115 - airport (red) (new airports)

   426

		(bits = MKCOLOR(0xFFFFFFFF), true);					// all others

   427

	} else {

   428

		if (t == MP_TUNNELBRIDGE) {

   429

			t = _map5[tile];

   430

			if ((t & 0x80) == 0) t>>=1;

   431

			if ((t & 6) == 0) {

   432

				t = MP_RAILWAY;

   433

			} else if ((t & 6) == 2) {

   434

				t = MP_STREET;

   435

			} else {

   436

				t = MP_WATER;

   437

			}

   438

		}

   439

		// ground color

   440

		bits = ((MKCOLOR(0x54545454) & _smallmap_contours_andor[t][1]) | _smallmap_contours_andor[t][0]);

   441

	}

   442

	return bits;

   443

}

   444

   445

static void DrawSmallMapRoutes(byte *dst, uint xc, uint yc, int pitch, int reps, uint32 mask)

   446

{

   447

	do {

   448

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

   449

			WRITE_PIXELS_OR(dst, GetSmallMapRoutesPixels(TILE_XY(xc,yc)) & mask);

   450

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

   451

}

   452

   453

static const uint32 _vegetation_clear_bits[4 + 7] = {

   454

	MKCOLOR(0x37373737),

   455

	MKCOLOR(0x37373737),

   456

	MKCOLOR(0x37373737),

   457

	MKCOLOR(0x54545454),

   458

   459

	MKCOLOR(0x52525252),

   460

	MKCOLOR(0x0A0A0A0A),

   461

	MKCOLOR(0x25252525),

   462

	MKCOLOR(0x98989898),

   463

	MKCOLOR(0xC2C2C2C2),

   464

	MKCOLOR(0x54545454),

   465

	MKCOLOR(0x54545454),

   466

};

   467

   468

static inline uint32 GetSmallMapVegetationPixels(uint tile)

   469

{

   470

	int i,t;

   471

	uint32 bits;

   472

   473

	t = TileType(tile);

   474

	if (t == MP_CLEAR) {

   475

		i = (_map5[tile] & 0x1F) - 4;

   476

		if (i >= 0) i = (i >> 2);

   477

		bits = _vegetation_clear_bits[i + 4];

   478

	} else if (t == MP_INDUSTRY) {

   479

		bits = IS_BYTE_INSIDE(_map5[tile], 0x10, 0x12) ? MKCOLOR(0xD0D0D0D0) : MKCOLOR(0xB5B5B5B5);

   480

	} else if (t == MP_TREES) {

   481

		bits = MKCOLOR(0x54575754);

   482

		if ((_map2[tile] & 0x30) == 0x20)

   483

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

   484

	} else {

   485

		if (t == MP_TUNNELBRIDGE) {

   486

			t = _map5[tile];

   487

			if ((t & 0x80) == 0) t>>=1;

   488

			if ((t & 6) == 0) {

   489

				t = MP_RAILWAY;

   490

			} else if ((t & 6) == 2) {

   491

				t = MP_STREET;

   492

			} else {

   493

				t = MP_WATER;

   494

			}

   495

		}

   496

		bits = ((MKCOLOR(0x54545454) & _smallmap_vehicles_andor[t][1]) | _smallmap_vehicles_andor[t][0]);

   497

	}

   498

   499

	return bits;

   500

}

   501

   502

   503

static void DrawSmallMapVegetation(byte *dst, uint xc, uint yc, int pitch, int reps, uint32 mask)

   504

{

   505

	do {

   506

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

   507

			WRITE_PIXELS_OR(dst, GetSmallMapVegetationPixels(TILE_XY(xc,yc)) & mask);

   508

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

   509

}

   510

   511

   512

static uint32 _owner_colors[256];

   513

   514

static inline uint32 GetSmallMapOwnerPixels(uint tile)

   515

{

   516

	int t;

   517

   518

	t = TileType(tile);

   519

	if (t == MP_HOUSE || _map_owner[tile] == OWNER_TOWN) {

   520

		t = 0x80;

   521

	} else if (t == MP_INDUSTRY) {

   522

		t = 0xff;