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

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

    80

	Corner highest_corner = GetHighestSlopeCorner(*s);

    81

    82

	switch (f) {

    83

		case FOUNDATION_INCLINED_X:

    84

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

    85

			break;

    86

    87

		case FOUNDATION_INCLINED_Y:

    88

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

    89

			break;

    90

    91

		case FOUNDATION_STEEP_LOWER:

    92

			*s = SlopeWithOneCornerRaised(highest_corner);

    93

			break;

    94

    95

		case FOUNDATION_STEEP_HIGHER:

    96

			*s = SlopeWithThreeCornersRaised(OppositeCorner(highest_corner));

    97

			break;

    98

    99

		default: NOT_REACHED();

   100

	}

   101

	return dz;

   102

}

   103

   104

   105

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

   106

{

   129

	int z = 0;

   130

   132

	case SLOPE_W:

   133

		if (x - y >= 0)

   134

			z = (x - y) >> 1;

   135

		break;

   136

   137

	case SLOPE_S:

   138

		y ^= 0xF;

   139

		if ( (x - y) >= 0)

   140

			z = (x - y) >> 1;

   141

		break;

   142

   143

	case SLOPE_SW:

   144

		z = (x >> 1) + 1;

   145

		break;

   146

   147

	case SLOPE_E:

   148

		if (y - x >= 0)

   149

			z = (y - x) >> 1;

   150

		break;

   151

   152

	case SLOPE_EW:

   153

	case SLOPE_NS:

   154

	case SLOPE_ELEVATED:

   155

		z = 4;

   156

		break;

   157

   158

	case SLOPE_SE:

   159

		z = (y >> 1) + 1;

   160

		break;

   161

   162

	case SLOPE_WSE:

   163

		z = 8;

   164

		y ^= 0xF;

   165

		if (x - y < 0)

   166

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

   167

		break;

   168

   169

	case SLOPE_N:

   170

		y ^= 0xF;

   171

		if (y - x >= 0)

   172

			z = (y - x) >> 1;

   173

		break;

   174

   175

	case SLOPE_NW:

   176

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

   177

		break;

   178

   179

	case SLOPE_NWS:

   180

		z = 8;

   181

		if (x - y < 0)

   182

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

   183

		break;

   184

   185

	case SLOPE_NE:

   186

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

   187

		break;

   188

   189

	case SLOPE_ENW:

   190

		z = 8;

   191

		y ^= 0xF;

   192

		if (y - x < 0)

   193

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

   194

		break;

   195

   196

	case SLOPE_SEN:

   197

		z = 8;

   198

		if (y - x < 0)

   199

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

   200

		break;

   201

   202

	case SLOPE_STEEP_S:

   203

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

   204

		break;

   205

   206

	case SLOPE_STEEP_W:

   207

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

   208

		break;

   209

   210

	case SLOPE_STEEP_N:

   211

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

   212

		break;

   213

   214

	case SLOPE_STEEP_E:

   215

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

   216

		break;

   217

   218

		default: break;

   219

	}

   220

   221

	return z;

   222

}

   223

   224

uint GetSlopeZ(int x, int y)

   225

{

   226

	TileIndex tile = TileVirtXY(x, y);

   227

   228

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

   229

}

   230

   231

/**

   232

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

   233

 *

   236

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

   237

 *

   238

 * @param tileh The slope of the tile.

   239

 * @param edge The edge of interest.

   240

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

   241

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

   242

 */

   243

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

   244

{

   245

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

   246

		/*    corner     |          steep slope

   247

		 *  z1      z2   |       z1             z2        */

   248

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

   249

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

   250

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

   251

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

   252

	};

   253

   258

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

   259

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

   262

}

   263

   264

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   265

{

   266

	Slope tileh = GetTileSlope(tile, z);

   267

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

   268

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

   269

	return tileh;

   270

}

   271

   272

   273

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

   274

{

   275

	uint z;

   276

   277

	int z_W_here = z_here;

   278

	int z_N_here = z_here;

   279

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

   280

   281

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

   282

	int z_W = z;

   283

	int z_N = z;

   284

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

   285

   286

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

   287

}

   288

   289

   290

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

   291

{

   292

	uint z;

   293

   294

	int z_E_here = z_here;

   295

	int z_N_here = z_here;

   296

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

   297

   298

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

   299

	int z_E = z;

   300

	int z_N = z;

   301

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

   302

   303

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

   304

}

   305

   306

   307

void DrawFoundation(TileInfo *ti, Foundation f)

   308

{

   309

	if (!IsFoundation(f)) return;

   310

   311

	SpriteID sprite_base = SPR_SLOPES_VIRTUAL_BASE;

   312

	uint z;

   313

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

   314

   315

	if (!HasFoundationNW(ti->tile, slope, z)) sprite_base += SPR_SLOPES_NO_FOUNDATION_NW_OFFSET;

   316

	if (!HasFoundationNE(ti->tile, slope, z)) sprite_base += SPR_SLOPES_NO_FOUNDATION_NE_OFFSET;

   317

   318

	if (IsSteepSlope(ti->tileh)) {

   319

		SpriteID lower_base;

   320

   321

		/* Lower part of foundation

   322

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

   323

		 */

   324

		lower_base = sprite_base;

   325

		if (lower_base == SPR_SLOPES_VIRTUAL_BASE) lower_base = SPR_FOUNDATION_BASE;

   326

		AddSortableSpriteToDraw(

   327

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

   328

		);

   329

   330

		Corner highest_corner = GetHighestSlopeCorner(ti->tileh);

   331

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

   332

   333

		if (IsInclinedFoundation(f)) {

   334

			/* inclined foundation */

   335

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

   336

   337

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

   338

			OffsetGroundSprite(31, 9);

   339

		} else if (f >= FOUNDATION_STEEP_HIGHER) {

   340

			/* three corners raised:

   341

			 * Draw inclined foundations for both axes, that results in the needed image.

   342

			 */

   343

			SpriteID upper = sprite_base + SPR_SLOPES_INCLINED_OFFSET + highest_corner * 2;

   344

   345

			AddSortableSpriteToDraw(upper, PAL_NONE, ti->x, ti->y, 16, 16, 1, ti->z);

   346

			AddChildSpriteScreen(upper + 1, PAL_NONE, 31, 9);

   347

			OffsetGroundSprite(31, 9);

   348

		} else {

   349

			/* one corner raised */

   350

			OffsetGroundSprite(31, 1);

   351

		}

   352

	} else {

   353

		if (IsLeveledFoundation(f)) {

   354

			/* leveled foundation

   355

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

   356

			 */

   357

			if (sprite_base == SPR_SLOPES_VIRTUAL_BASE) sprite_base = SPR_FOUNDATION_BASE;

   358

   359

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

   360

			OffsetGroundSprite(31, 1);

   361

		} else {

   362

			/* inclined foundation */

   363

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

   364

   365

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

   366

			OffsetGroundSprite(31, 9);

   367

		}

   368

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

   369

	}

   370

}

   371

   372

void DoClearSquare(TileIndex tile)

   373

{

   374

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

   375

	MarkTileDirtyByTile(tile);

   376

}

   377

   378

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

   379

{

   380

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

   381

}

   382

   383

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

   384

{

   385

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

   386

}

   387

   388

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   389

{

   390

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

   391

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

   392

}

   393

   394

void AnimateTile(TileIndex tile)

   395

{

   396

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

   397

}

   398

   399

void ClickTile(TileIndex tile)

   400

{

   401

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

   402

}

   403

   404

void GetTileDesc(TileIndex tile, TileDesc *td)

   405

{

   406

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

   407

}

   408

   409

/**

   410

 * Has a snow line table already been loaded.

   411

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

   412

 */

   413

bool IsSnowLineSet(void)

   414

{

   415

	return _snow_line != NULL;

   416

}

   417

   418

/**

   419

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

   420

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

   421

 */

   422

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

   423

{

   424

	_snow_line = CallocT<SnowLine>(1);

   425

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

   426

   427

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

   428

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

   429

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

   430

		}

   431

	}

   432

}

   433

   434

/**

   435

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

   436

 * @return the snow line height.

   437

 */

   438

byte GetSnowLine(void)

   439

{

   440

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

   441

   442

	YearMonthDay ymd;

   443

	ConvertDateToYMD(_date, &ymd);

   444

	return _snow_line->table[ymd.month][ymd.day];

   445

}

   446

   447

/**

   448

 * Get the highest possible snow line height, either variable or static.

   449

 * @return the highest snow line height.

   450

 */

   451

byte HighestSnowLine(void)

   452

{

   453

	return _snow_line == NULL ? _opt.snow_line : _snow_line->highest_value;

   454

}

   455

   456

/**

   457

 * Clear the variable snow line table and free the memory.

   458

 */

   459

void ClearSnowLine(void)

   460

{

   461

	free(_snow_line);

   462

	_snow_line = NULL;

   463

}

   464

   465

/** Clear a piece of landscape

   466

 * @param tile tile to clear

   467

 * @param flags of operation to conduct

   468

 * @param p1 unused

   469

 * @param p2 unused

   470

 */

   471

CommandCost CmdLandscapeClear(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   472

{

   473

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   474

   475

	return _tile_type_procs[GetTileType(tile)]->clear_tile_proc(tile, flags);

   476

}

   477

   478

/** Clear a big piece of landscape

   479

 * @param tile end tile of area dragging

   480

 * @param p1 start tile of area dragging

   481

 * @param flags of operation to conduct

   482

 * @param p2 unused

   483

 */

   484

CommandCost CmdClearArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   485

{

   486

	CommandCost cost, ret, money;

   487

	int ex;

   488

	int ey;

   489

	int sx, sy;

   490

	int x, y;

   491

	bool success = false;

   492