1

/* $Id$ */

     2

     3

/** @file landscape.cpp Functions related to the landscape (slopes etc.). */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "heightmap.h"

     9

#include "clear_map.h"

    10

#include "spritecache.h"

    11

#include <stdarg.h>

    12

#include "viewport_func.h"

    13

#include "command_func.h"

    14

#include "landscape.h"

    15

#include "variables.h"

    16

#include "void_map.h"

    17

#include "water_map.h"

    18

#include "tgp.h"

    19

#include "genworld.h"

    20

#include "tile_cmd.h"

    21

#include "core/alloc_func.hpp"

    22

#include "fios.h"

    23

#include "window_func.h"

    24

#include "functions.h"

    25

#include "date_func.h"

    26

#include "vehicle_func.h"

    27

#include "settings_type.h"

    28

#include "water.h"

    29

#include "effectvehicle_func.h"

    30

#include "landscape_type.h"

    31

    32

#include "table/sprites.h"

    33

    34

extern const TileTypeProcs

    35

	_tile_type_clear_procs,

    36

	_tile_type_rail_procs,

    37

	_tile_type_road_procs,

    38

	_tile_type_town_procs,

    39

	_tile_type_trees_procs,

    40

	_tile_type_station_procs,

    41

	_tile_type_water_procs,

    42

	_tile_type_dummy_procs,

    43

	_tile_type_industry_procs,

    44

	_tile_type_tunnelbridge_procs,

    45

	_tile_type_unmovable_procs;

    46

    47

const TileTypeProcs * const _tile_type_procs[16] = {

    48

	&_tile_type_clear_procs,

    49

	&_tile_type_rail_procs,

    50

	&_tile_type_road_procs,

    51

	&_tile_type_town_procs,

    52

	&_tile_type_trees_procs,

    53

	&_tile_type_station_procs,

    54

	&_tile_type_water_procs,

    55

	&_tile_type_dummy_procs,

    56

	&_tile_type_industry_procs,

    57

	&_tile_type_tunnelbridge_procs,

    58

	&_tile_type_unmovable_procs,

    59

};

    60

    61

/* landscape slope => sprite */

    62

const byte _tileh_to_sprite[32] = {

    63

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

    64

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

    65

};

    66

    67

SnowLine *_snow_line = NULL;

    68

    69

/**

    70

 * Applys a foundation to a slope.

    71

 *

    72

 * @pre      Foundation and slope must be valid combined.

    73

 * @param f  The #Foundation.

    74

 * @param s  The #Slope to modify.

    75

 * @return   Increment to the tile Z coordinate.

    76

 */

    77

uint ApplyFoundationToSlope(Foundation f, Slope *s)

    78

{

    79

	if (!IsFoundation(f)) return 0;

    80

    81

	if (IsLeveledFoundation(f)) {

    82

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

    83

		*s = SLOPE_FLAT;

    84

		return dz;

    85

	}

    86

    87

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

    88

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

    89

		return 0;

    90

	}

    91

    92

	if (IsSpecialRailFoundation(f)) {

    93

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

    94

		return 0;

    95

	}

    96

    97

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

    98

	Corner highest_corner = GetHighestSlopeCorner(*s);

    99

   100

	switch (f) {

   101

		case FOUNDATION_INCLINED_X:

   102

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

   103

			break;

   104

   105

		case FOUNDATION_INCLINED_Y:

   106

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

   107

			break;

   108

   109

		case FOUNDATION_STEEP_LOWER:

   110

			*s = SlopeWithOneCornerRaised(highest_corner);

   111

			break;

   112

   113

		case FOUNDATION_STEEP_BOTH:

   114

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

   115

			break;

   116

   117

		default: NOT_REACHED();

   118

	}

   119

	return dz;

   120

}

   121

   122

   123

/**

   124

 * Determines height at given coordinate of a slope

   125

 * @param x x coordinate

   126

 * @param y y coordinate

   127

 * @param corners slope to examine

   128

 * @return height of given point of given slope

   129

 */

   130

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

   131

{

   132

	if (IsHalftileSlope(corners)) {

   133

		switch (GetHalftileSlopeCorner(corners)) {

   134

			case CORNER_W:

   135

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

   136

				break;

   137

   138

			case CORNER_S:

   139

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

   140

				break;

   141

   142

			case CORNER_E:

   143

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

   144

				break;

   145

   146

			case CORNER_N:

   147

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

   148

				break;

   149

   150

			default: NOT_REACHED();

   151

		}

   152

	}

   153

   154

	int z = 0;

   155

   156

	switch (RemoveHalftileSlope(corners)) {

   157

		case SLOPE_W:

   158

			if (x - y >= 0) {

   159

				z = (x - y) >> 1;

   160

			}

   161

			break;

   162

   163

		case SLOPE_S:

   164

			y ^= 0xF;

   165

			if ((x - y) >= 0) {

   166

				z = (x - y) >> 1;

   167

			}

   168

			break;

   169

   170

		case SLOPE_SW:

   171

			z = (x >> 1) + 1;

   172

			break;

   173

   174

		case SLOPE_E:

   175

			if (y - x >= 0) {

   176

				z = (y - x) >> 1;

   177

			}

   178

			break;

   179

   180

		case SLOPE_EW:

   181

		case SLOPE_NS:

   182

		case SLOPE_ELEVATED:

   183

			z = 4;

   184

			break;

   185

   186

		case SLOPE_SE:

   187

			z = (y >> 1) + 1;

   188

			break;

   189

   190

		case SLOPE_WSE:

   191

			z = 8;

   192

			y ^= 0xF;

   193

			if (x - y < 0) {

   194

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

   195

			}

   196

			break;

   197

   198

		case SLOPE_N:

   199

			y ^= 0xF;

   200

			if (y - x >= 0) {

   201

				z = (y - x) >> 1;

   202

			}

   203

			break;

   204

   205

		case SLOPE_NW:

   206

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

   207

			break;

   208

   209

		case SLOPE_NWS:

   210

			z = 8;

   211

			if (x - y < 0) {

   212

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

   213

			}

   214

			break;

   215

   216

		case SLOPE_NE:

   217

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

   218

			break;

   219

   220

		case SLOPE_ENW:

   221

			z = 8;

   222

			y ^= 0xF;

   223

			if (y - x < 0) {

   224

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

   225

			}

   226

			break;

   227

   228

		case SLOPE_SEN:

   229

			z = 8;

   230

			if (y - x < 0) {

   231

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

   232

			}

   233

			break;

   234

   235

		case SLOPE_STEEP_S:

   236

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

   237

			break;

   238

   239

		case SLOPE_STEEP_W:

   240

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

   241

			break;

   242

   243

		case SLOPE_STEEP_N:

   244

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

   245

			break;

   246

   247

		case SLOPE_STEEP_E:

   248

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

   249

			break;

   250

   251

		default: break;

   252

	}

   253

   254

	return z;

   255

}

   256

   257

uint GetSlopeZ(int x, int y)

   258

{

   259

	TileIndex tile = TileVirtXY(x, y);

   260

   261

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

   262

}

   263

   264

/**

   265

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

   266

 *

   267

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

   268

 *

   269

 * @param tileh The slope.

   270

 * @param corner The corner.

   271

 * @return Z position of corner relative to TileZ.

   272

 */

   273

int GetSlopeZInCorner(Slope tileh, Corner corner)

   274

{

   275

	assert(!IsHalftileSlope(tileh));

   276

	return ((tileh & SlopeWithOneCornerRaised(corner)) != 0 ? TILE_HEIGHT : 0) + (tileh == SteepSlope(corner) ? TILE_HEIGHT : 0);

   277

}

   278

   279

/**

   280

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

   281

 *

   282

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

   283

 *

   284

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

   285

 *

   286

 * @param tileh The slope of the tile.

   287

 * @param edge The edge of interest.

   288

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

   289

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

   290

 */

   291

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

   292

{

   293

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

   294

		/*    corner     |          steep slope

   295

		 *  z1      z2   |       z1             z2        */

   296

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

   297

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

   298

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

   299

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

   300

	};

   301

   302

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

   303

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

   304

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

   305

   306

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

   307

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

   308

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

   309

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

   310

}

   311

   312

/**

   313

 * Get slope of a tile on top of a (possible) foundation

   314

 * If a tile does not have a foundation, the function returns the same as GetTileSlope.

   315

 *

   316

 * @param tile The tile of interest.

   317

 * @param z returns the z of the foundation slope. (Can be NULL, if not needed)

   318

 * @return The slope on top of the foundation.

   319

 */

   320

Slope GetFoundationSlope(TileIndex tile, uint* z)

   321

{

   322

	Slope tileh = GetTileSlope(tile, z);

   323

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

   324

	uint z_inc = ApplyFoundationToSlope(f, &tileh);

   325

	if (z != NULL) *z += z_inc;

   326

	return tileh;

   327

}

   328

   329

   330

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

   331

{

   332

	uint z;

   333

   334

	int z_W_here = z_here;

   335

	int z_N_here = z_here;

   336

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

   337

   338

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

   339

	int z_W = z;

   340

	int z_N = z;

   341

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

   342

   343

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

   344

}

   345

   346

   347

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

   348

{

   349

	uint z;

   350

   351

	int z_E_here = z_here;

   352

	int z_N_here = z_here;

   353

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

   354

   355

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

   356

	int z_E = z;

   357

	int z_N = z;

   358

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

   359

   360

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

   361

}

   362

   363

   364

void DrawFoundation(TileInfo *ti, Foundation f)

   365

{

   366

	if (!IsFoundation(f)) return;

   367

   368

	/* Two part foundations must be drawn separately */

   369

	assert(f != FOUNDATION_STEEP_BOTH);

   370

   371

	uint sprite_block = 0;

   372

	uint z;

   373

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

   374

   375

	/* Select the needed block of foundations sprites

   376

	 * Block 0: Walls at NW and NE edge

   377

	 * Block 1: Wall  at        NE edge

   378

	 * Block 2: Wall  at NW        edge

   379

	 * Block 3: No walls at NW or NE edge

   380

	 */

   381

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

   382

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

   383

   384

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

   385

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

   386

	SpriteID inclined_base = SPR_SLOPES_VIRTUAL_BASE + SPR_SLOPES_INCLINED_OFFSET + sprite_block * SPR_TRKFOUND_BLOCK_SIZE;

   387

	SpriteID halftile_base = SPR_HALFTILE_FOUNDATION_BASE + sprite_block * SPR_HALFTILE_BLOCK_SIZE;

   388

   389

	if (IsSteepSlope(ti->tileh)) {

   390

		if (!IsNonContinuousFoundation(f)) {

   391

			/* Lower part of foundation */

   392

			AddSortableSpriteToDraw(

   393

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

   394

			);

   395

		}

   396

   397

		Corner highest_corner = GetHighestSlopeCorner(ti->tileh);

   398

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

   399

   400

		if (IsInclinedFoundation(f)) {

   401

			/* inclined foundation */

   402

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

   403

   404

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

   405

			OffsetGroundSprite(31, 9);

   406

		} else if (IsLeveledFoundation(f)) {

   407

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

   408

			OffsetGroundSprite(31, 1);

   409

		} else if (f == FOUNDATION_STEEP_LOWER) {

   410

			/* one corner raised */

   411

			OffsetGroundSprite(31, 1);

   412

		} else {

   413

			/* halftile foundation */

   414

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

   415

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

   416

   417

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

   418

			OffsetGroundSprite(31, 9);

   419

		}

   420

	} else {

   421

		if (IsLeveledFoundation(f)) {

   422

			/* leveled foundation */

   423

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

   424

			OffsetGroundSprite(31, 1);

   425

		} else if (IsNonContinuousFoundation(f)) {

   426

			/* halftile foundation */

   427

			Corner halftile_corner = GetHalftileFoundationCorner(f);

   428

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

   429

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

   430

   431

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

   432

			OffsetGroundSprite(31, 9);

   433

		} else if (IsSpecialRailFoundation(f)) {

   434

			/* anti-zig-zag foundation */

   435

			SpriteID spr;

   436

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

   437

				/* half of leveled foundation under track corner */

   438

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

   439

			} else {

   440

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

   441

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

   442

			}

   443

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

   444

			OffsetGroundSprite(31, 9);

   445

		} else {

   446

			/* inclined foundation */

   447

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

   448

   449

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

   450

			OffsetGroundSprite(31, 9);

   451

		}

   452

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

   453

	}

   454

}

   455

   456

void DoClearSquare(TileIndex tile)

   457

{

   458

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

   459

	MarkTileDirtyByTile(tile);

   460

}

   461

   462

/** Returns information about trackdirs and signal states.

   463

 * If there is any trackbit at 'side', return all trackdirbits.

   464

 * For TRANSPORT_ROAD, return no trackbits if there is no roadbit (of given subtype) at given side.

   465

 * @param tile tile to get info about

   466

 * @param mode transport type

   467

 * @param sub_mode for TRANSPORT_ROAD, roadtypes to check

   468

 * @param side side we are entering from, INVALID_DIAGDIR to return all trackbits

   469

 * @return trackdirbits and other info depending on 'mode'

   470

 */

   471

TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)

   472

{

   473

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

   474

}

   475

   476

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

   477

{

   478

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

   479

}

   480

   481

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   482

{

   483

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

   484

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

   485

}

   486

   487

void AnimateTile(TileIndex tile)

   488

{

   489

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

   490

}

   491