1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "bridge_map.h"

     6

#include "heightmap.h"

     7

#include "clear_map.h"

     8

#include "date.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "player.h"

    12

#include "spritecache.h"

    13

#include "table/sprites.h"

    14

#include "tile.h"

    15

#include <stdarg.h>

    16

#include "viewport.h"

    17

#include "command.h"

    18

#include "landscape.h"

    19

#include "vehicle.h"

    20

#include "variables.h"

    21

#include "void_map.h"

    22

#include "water_map.h"

    23

#include "tgp.h"

    24

#include "genworld.h"

    25

    26

extern const TileTypeProcs

    27

	_tile_type_clear_procs,

    28

	_tile_type_rail_procs,

    29

	_tile_type_road_procs,

    30

	_tile_type_town_procs,

    31

	_tile_type_trees_procs,

    32

	_tile_type_station_procs,

    33

	_tile_type_water_procs,

    34

	_tile_type_dummy_procs,

    35

	_tile_type_industry_procs,

    36

	_tile_type_tunnelbridge_procs,

    37

	_tile_type_unmovable_procs;

    38

    39

const TileTypeProcs * const _tile_type_procs[16] = {

    40

	&_tile_type_clear_procs,

    41

	&_tile_type_rail_procs,

    42

	&_tile_type_road_procs,

    43

	&_tile_type_town_procs,

    44

	&_tile_type_trees_procs,

    45

	&_tile_type_station_procs,

    46

	&_tile_type_water_procs,

    47

	&_tile_type_dummy_procs,

    48

	&_tile_type_industry_procs,

    49

	&_tile_type_tunnelbridge_procs,

    50

	&_tile_type_unmovable_procs,

    51

};

    52

    53

/* landscape slope => sprite */

    54

const byte _tileh_to_sprite[32] = {

    55

	0, 1, 2, 3, 4, 5, 6,  7, 8, 9, 10, 11, 12, 13, 14, 0,

    56

	0, 0, 0, 0, 0, 0, 0, 16, 0, 0,  0, 17,  0, 15, 18, 0,

    57

};

    58

    59

SnowLine *_snow_line = NULL;

    60

    61

/**

    62

 * Applys a foundation to a slope.

    63

 *

    64

 * @pre      Foundation and slope must be valid combined.

    65

 * @param f  The #Foundation.

    66

 * @param s  The #Slope to modify.

    67

 * @return   Increment to the tile Z coordinate.

    68

 */

    69

uint ApplyFoundationToSlope(Foundation f, Slope *s)

    70

{

    71

    72

	if (!IsFoundation(f)) return 0;

    73

    74

	if (IsLeveledFoundation(f)) {

    75

		*s = SLOPE_FLAT;

    76

		return TILE_HEIGHT;

    77

	}

    78

    79

	if (f != FOUNDATION_STEEP_BOTH && IsNonContinuousFoundation(f)) {

    80

		*s = HalftileSlope(*s, GetHalftileFoundationCorner(f));

    81

		return 0;

    82

	}

    83

    84

	if (IsSpecialRailFoundation(f)) {

    85

		*s = SlopeWithThreeCornersRaised(OppositeCorner(GetRailFoundationCorner(f)));

    86

		return 0;

    87

	}

    88

    89

	uint dz = IsSteepSlope(*s) ? TILE_HEIGHT : 0;

    90

	Corner highest_corner = GetHighestSlopeCorner(*s);

    91

    92

	switch (f) {

    93

		case FOUNDATION_INCLINED_X:

    94

			*s = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ? SLOPE_SW : SLOPE_NE);

    95

			break;

    96

    97

		case FOUNDATION_INCLINED_Y:

    98

			*s = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ? SLOPE_SE : SLOPE_NW);

    99

			break;

   100

   101

		case FOUNDATION_STEEP_LOWER:

   102

			*s = SlopeWithOneCornerRaised(highest_corner);

   103

			break;

   104

   105

		case FOUNDATION_STEEP_BOTH:

   106

			*s = HalftileSlope(SlopeWithOneCornerRaised(highest_corner), highest_corner);

   107

			break;

   108

   109

		default: NOT_REACHED();

   110

	}

   111

	return dz;

   112

}

   113

   114

   115

uint GetPartialZ(int x, int y, Slope corners)

   116

{

   117

	if (IsHalftileSlope(corners)) {

   118

		switch (GetHalftileSlopeCorner(corners)) {

   119

			case CORNER_W:

   120

				if (x - y >= 0) return GetSlopeMaxZ(corners);

   121

				break;

   122

   123

			case CORNER_S:

   124

				if (x - (y ^ 0xF) >= 0) return GetSlopeMaxZ(corners);

   125

				break;

   126

   127

			case CORNER_E:

   128

				if (y - x >= 0) return GetSlopeMaxZ(corners);

   129

				break;

   130

   131

			case CORNER_N:

   132

				if ((y ^ 0xF) - x >= 0) return GetSlopeMaxZ(corners);

   133

				break;

   134

   135

			default: NOT_REACHED();

   136

		}

   137

	}

   138

   139

	int z = 0;

   140

   141

	switch (corners & ~SLOPE_HALFTILE_MASK) {

   142

	case SLOPE_W:

   143

		if (x - y >= 0)

   144

			z = (x - y) >> 1;

   145

		break;

   146

   147

	case SLOPE_S:

   148

		y ^= 0xF;

   149

		if ( (x - y) >= 0)

   150

			z = (x - y) >> 1;

   151

		break;

   152

   153

	case SLOPE_SW:

   154

		z = (x >> 1) + 1;

   155

		break;

   156

   157

	case SLOPE_E:

   158

		if (y - x >= 0)

   159

			z = (y - x) >> 1;

   160

		break;

   161

   162

	case SLOPE_EW:

   163

	case SLOPE_NS:

   164

	case SLOPE_ELEVATED:

   165

		z = 4;

   166

		break;

   167

   168

	case SLOPE_SE:

   169

		z = (y >> 1) + 1;

   170

		break;

   171

   172

	case SLOPE_WSE:

   173

		z = 8;

   174

		y ^= 0xF;

   175

		if (x - y < 0)

   176

			z += (x - y) >> 1;

   177

		break;

   178

   179

	case SLOPE_N:

   180

		y ^= 0xF;

   181

		if (y - x >= 0)

   182

			z = (y - x) >> 1;

   183

		break;

   184

   185

	case SLOPE_NW:

   186

		z = (y ^ 0xF) >> 1;

   187

		break;

   188

   189

	case SLOPE_NWS:

   190

		z = 8;

   191

		if (x - y < 0)

   192

			z += (x - y) >> 1;

   193

		break;

   194

   195

	case SLOPE_NE:

   196

		z = (x ^ 0xF) >> 1;

   197

		break;

   198

   199

	case SLOPE_ENW:

   200

		z = 8;

   201

		y ^= 0xF;

   202

		if (y - x < 0)

   203

			z += (y - x) >> 1;

   204

		break;

   205

   206

	case SLOPE_SEN:

   207

		z = 8;

   208

		if (y - x < 0)

   209

			z += (y - x) >> 1;

   210

		break;

   211

   212

	case SLOPE_STEEP_S:

   213

		z = 1 + ((x + y) >> 1);

   214

		break;

   215

   216

	case SLOPE_STEEP_W:

   217

		z = 1 + ((x + (y ^ 0xF)) >> 1);

   218

		break;

   219

   220

	case SLOPE_STEEP_N:

   221

		z = 1 + (((x ^ 0xF) + (y ^ 0xF)) >> 1);

   222

		break;

   223

   224

	case SLOPE_STEEP_E:

   225

		z = 1 + (((x ^ 0xF) + y) >> 1);

   226

		break;

   227

   228

		default: break;

   229

	}

   230

   231

	return z;

   232

}

   233

   234

uint GetSlopeZ(int x, int y)

   235

{

   236

	TileIndex tile = TileVirtXY(x, y);

   237

   238

	return _tile_type_procs[GetTileType(tile)]->get_slope_z_proc(tile, x, y);

   239

}

   240

   241

/**

   242

 * Determine the Z height of a corner relative to TileZ.

   243

 *

   244

 * @pre The slope must not be a halftile slope.

   245

 *

   246

 * @param tileh The slope.

   247

 * @param corner The corner.

   248

 * @return Z position of corner relative to TileZ.

   249

 */

   250

int GetSlopeZInCorner(Slope tileh, Corner corner)

   251

{

   252

	assert(!IsHalftileSlope(tileh));

   253

	static const int _corner_slopes[4][2] = {

   254

		{ SLOPE_W, SLOPE_STEEP_W }, { SLOPE_S, SLOPE_STEEP_S }, { SLOPE_E, SLOPE_STEEP_E }, { SLOPE_N, SLOPE_STEEP_N }

   255

	};

   256

	return ((tileh & _corner_slopes[corner][0]) != 0 ? TILE_HEIGHT : 0) + (tileh == _corner_slopes[corner][1] ? TILE_HEIGHT : 0);

   257

}

   258

   259

/**

   260

 * Determine the Z height of the corners of a specific tile edge

   261

 *

   262

 * @note If a tile has a non-continuous halftile foundation, a corner can have different heights wrt. it's edges.

   263

 *

   264

 * @pre z1 and z2 must be initialized (typ. with TileZ). The corner heights just get added.

   265

 *

   266

 * @param tileh The slope of the tile.

   267

 * @param edge The edge of interest.

   268

 * @param z1 Gets incremented by the height of the first corner of the edge. (near corner wrt. the camera)

   269

 * @param z2 Gets incremented by the height of the second corner of the edge. (far corner wrt. the camera)

   270

 */

   271

void GetSlopeZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)

   272

{

   273

	static const Slope corners[4][4] = {

   274

		/*    corner     |          steep slope

   275

		 *  z1      z2   |       z1             z2        */

   276

		{SLOPE_E, SLOPE_N, SLOPE_STEEP_E, SLOPE_STEEP_N}, // DIAGDIR_NE, z1 = E, z2 = N

   277

		{SLOPE_S, SLOPE_E, SLOPE_STEEP_S, SLOPE_STEEP_E}, // DIAGDIR_SE, z1 = S, z2 = E

   278

		{SLOPE_S, SLOPE_W, SLOPE_STEEP_S, SLOPE_STEEP_W}, // DIAGDIR_SW, z1 = S, z2 = W

   279

		{SLOPE_W, SLOPE_N, SLOPE_STEEP_W, SLOPE_STEEP_N}, // DIAGDIR_NW, z1 = W, z2 = N

   280

	};

   281

   282

	int halftile_test = (IsHalftileSlope(tileh) ? SlopeWithOneCornerRaised(GetHalftileSlopeCorner(tileh)) : 0);

   283

	if (halftile_test == corners[edge][0]) *z2 += TILE_HEIGHT; // The slope is non-continuous in z2. z2 is on the upper side.

   284

	if (halftile_test == corners[edge][1]) *z1 += TILE_HEIGHT; // The slope is non-continuous in z1. z1 is on the upper side.

   285

   286

	if ((tileh & corners[edge][0]) != 0) *z1 += TILE_HEIGHT; // z1 is raised

   287

	if ((tileh & corners[edge][1]) != 0) *z2 += TILE_HEIGHT; // z2 is raised

   288

	if ((tileh & ~SLOPE_HALFTILE_MASK) == corners[edge][2]) *z1 += TILE_HEIGHT; // z1 is highest corner of a steep slope

   289

	if ((tileh & ~SLOPE_HALFTILE_MASK) == corners[edge][3]) *z2 += TILE_HEIGHT; // z2 is highest corner of a steep slope

   290

}

   291

   292

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   293

{

   294

	Slope tileh = GetTileSlope(tile, z);

   295

	Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);

   296

	*z += ApplyFoundationToSlope(f, &tileh);

   297

	return tileh;

   298

}

   299

   300

   301

static bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)

   302

{

   303

	uint z;

   304

   305

	int z_W_here = z_here;

   306

	int z_N_here = z_here;

   307

	GetSlopeZOnEdge(slope_here, DIAGDIR_NW, &z_W_here, &z_N_here);

   308

   309

	Slope slope = GetFoundationSlope(TILE_ADDXY(tile, 0, -1), &z);

   310

	int z_W = z;

   311

	int z_N = z;

   312

	GetSlopeZOnEdge(slope, DIAGDIR_SE, &z_W, &z_N);

   313

   314

	return (z_N_here > z_N) || (z_W_here > z_W);

   315

}

   316

   317

   318

static bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)

   319

{

   320

	uint z;

   321

   322

	int z_E_here = z_here;

   323

	int z_N_here = z_here;

   324

	GetSlopeZOnEdge(slope_here, DIAGDIR_NE, &z_E_here, &z_N_here);

   325

   326

	Slope slope = GetFoundationSlope(TILE_ADDXY(tile, -1, 0), &z);

   327

	int z_E = z;

   328

	int z_N = z;

   329

	GetSlopeZOnEdge(slope, DIAGDIR_SW, &z_E, &z_N);

   330

   331

	return (z_N_here > z_N) || (z_E_here > z_E);

   332

}

   333

   334

   335

void DrawFoundation(TileInfo *ti, Foundation f)

   336

{

   337

	if (!IsFoundation(f)) return;

   338

   339

	/* Two part foundations must be drawn separately */

   340

	assert(f != FOUNDATION_STEEP_BOTH);

   341

   342

	uint sprite_block = 0;

   343

	uint z;

   344

	Slope slope = GetFoundationSlope(ti->tile, &z);

   345

   346

	/* Select the needed block of foundations sprites

   347

	 * Block 0: Walls at NW and NE edge

   348

	 * Block 1: Wall  at        NE edge

   349

	 * Block 2: Wall  at NW        edge

   350

	 * Block 3: No walls at NW or NE edge

   351

	 */

   352

	if (!HasFoundationNW(ti->tile, slope, z)) sprite_block += 1;

   353

	if (!HasFoundationNE(ti->tile, slope, z)) sprite_block += 2;

   354

   355

	/* Use the original slope sprites if NW and NE borders should be visible */

   356

	SpriteID leveled_base = (sprite_block == 0 ? (int)SPR_FOUNDATION_BASE : (SPR_SLOPES_VIRTUAL_BASE + sprite_block * SPR_TRKFOUND_BLOCK_SIZE));

   357

	SpriteID inclined_base = SPR_SLOPES_VIRTUAL_BASE + SPR_SLOPES_INCLINED_OFFSET + sprite_block * SPR_TRKFOUND_BLOCK_SIZE;

   358

	SpriteID halftile_base = SPR_HALFTILE_FOUNDATION_BASE + sprite_block * SPR_HALFTILE_BLOCK_SIZE;

   359

   360

	if (IsSteepSlope(ti->tileh)) {

   361

		if (!IsNonContinuousFoundation(f)) {

   362

			/* Lower part of foundation */

   363

			AddSortableSpriteToDraw(

   364

				leveled_base + (ti->tileh & ~SLOPE_STEEP), PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z

   365

			);

   366

		}

   367

   368

		Corner highest_corner = GetHighestSlopeCorner(ti->tileh);

   369

		ti->z += ApplyFoundationToSlope(f, &ti->tileh);

   370

   371

		if (IsInclinedFoundation(f)) {

   372

			/* inclined foundation */

   373

			byte inclined = highest_corner * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);

   374

   375

			AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, ti->x, ti->y, 16, 16, 1, ti->z);

   376

			OffsetGroundSprite(31, 9);

   377

		} else if (f == FOUNDATION_STEEP_LOWER) {

   378

			/* one corner raised */

   379

			OffsetGroundSprite(31, 1);

   380

		} else {

   381

			/* halftile foundation */

   382

			int x_bb = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ? 8 : 0);

   383

			int y_bb = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ? 8 : 0);

   384

   385

			AddSortableSpriteToDraw(halftile_base + highest_corner, PAL_NONE, ti->x + x_bb, ti->y + y_bb, 8, 8, 7, ti->z + TILE_HEIGHT);

   386

			OffsetGroundSprite(31, 9);

   387

		}

   388

	} else {

   389

		if (IsLeveledFoundation(f)) {

   390

			/* leveled foundation */

   391

			AddSortableSpriteToDraw(leveled_base + ti->tileh, PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);

   392

			OffsetGroundSprite(31, 1);

   393

		} else if (IsNonContinuousFoundation(f)) {

   394

			/* halftile foundation */

   395

			Corner halftile_corner = GetHalftileFoundationCorner(f);

   396

			int x_bb = (((halftile_corner == CORNER_W) || (halftile_corner == CORNER_S)) ? 8 : 0);

   397

			int y_bb = (((halftile_corner == CORNER_S) || (halftile_corner == CORNER_E)) ? 8 : 0);

   398

   399

			AddSortableSpriteToDraw(halftile_base + halftile_corner, PAL_NONE, ti->x + x_bb, ti->y + y_bb, 8, 8, 7, ti->z);

   400

			OffsetGroundSprite(31, 9);

   401

		} else if (IsSpecialRailFoundation(f)) {

   402

			/* anti-zig-zag foundation */

   403

			SpriteID spr;

   404

			if (ti->tileh == SLOPE_NS || ti->tileh == SLOPE_EW) {

   405

				/* half of leveled foundation under track corner */

   406

				spr = leveled_base + SlopeWithThreeCornersRaised(GetRailFoundationCorner(f));

   407

			} else {

   408

				/* tile-slope = sloped along X/Y, foundation-slope = three corners raised */

   409

				spr = inclined_base + 2 * GetRailFoundationCorner(f) + ((ti->tileh == SLOPE_SW || ti->tileh == SLOPE_NE) ? 1 : 0);

   410

			}

   411

			AddSortableSpriteToDraw(spr, PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);

   412

			OffsetGroundSprite(31, 9);

   413

		} else {

   414

			/* inclined foundation */

   415

			byte inclined = GetHighestSlopeCorner(ti->tileh) * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);

   416

   417

			AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, ti->x, ti->y, 16, 16, 1, ti->z);

   418

			OffsetGroundSprite(31, 9);

   419

		}

   420

		ti->z += ApplyFoundationToSlope(f, &ti->tileh);

   421

	}

   422

}

   423

   424

void DoClearSquare(TileIndex tile)

   425

{

   426

	MakeClear(tile, CLEAR_GRASS, _generating_world ? 3 : 0);

   427

	MarkTileDirtyByTile(tile);

   428

}

   429

   430

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode)

   431

{

   432

	return _tile_type_procs[GetTileType(tile)]->get_tile_track_status_proc(tile, mode, sub_mode);

   433

}

   434

   435

void ChangeTileOwner(TileIndex tile, PlayerID old_player, PlayerID new_player)

   436

{

   437

	_tile_type_procs[GetTileType(tile)]->change_tile_owner_proc(tile, old_player, new_player);

   438

}

   439

   440

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   441

{

   442

	memset(ac, 0, sizeof(AcceptedCargo));

   443

	_tile_type_procs[GetTileType(tile)]->get_accepted_cargo_proc(tile, ac);

   444

}

   445

   446

void AnimateTile(TileIndex tile)

   447

{

   448

	_tile_type_procs[GetTileType(tile)]->animate_tile_proc(tile);

   449

}

   450

   451

void ClickTile(TileIndex tile)

   452

{

   453

	_tile_type_procs[GetTileType(tile)]->click_tile_proc(tile);

   454

}

   455

   456

void GetTileDesc(TileIndex tile, TileDesc *td)

   457

{

   458

	_tile_type_procs[GetTileType(tile)]->get_tile_desc_proc(tile, td);

   459

}

   460

   461

/**

   462

 * Has a snow line table already been loaded.

   463

 * @return true if the table has been loaded already.

   464

 */

   465

bool IsSnowLineSet(void)

   466

{

   467

	return _snow_line != NULL;

   468

}

   469

   470

/**

   471

 * Set a variable snow line, as loaded from a newgrf file.

   472

 * @param table the 12 * 32 byte table containing the snowline for each day

   473

 */

   474

void SetSnowLine(byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS])

   475

{

   476

	_snow_line = CallocT<SnowLine>(1);

   477

	memcpy(_snow_line->table, table, sizeof(_snow_line->table));

   478

   479

	for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {

   480

		for (uint j = 0; j < SNOW_LINE_DAYS; j++) {

   481

			_snow_line->highest_value = max(_snow_line->highest_value, table[i][j]);

   482

		}

   483

	}

   484

}

   485

   486

/**

   487

 * Get the current snow line, either variable or static.

   488

 * @return the snow line height.

   489

 */

   490

byte GetSnowLine(void)

   491

{

   492

	if (_snow_line == NULL) return _opt.snow_line;

   493