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

#include "heightmap.h"

    26

    27

extern const TileTypeProcs

    28

	_tile_type_clear_procs,

    29

	_tile_type_rail_procs,

    30

	_tile_type_road_procs,

    31

	_tile_type_town_procs,

    32

	_tile_type_trees_procs,

    33

	_tile_type_station_procs,

    34

	_tile_type_water_procs,

    35

	_tile_type_dummy_procs,

    36

	_tile_type_industry_procs,

    37

	_tile_type_tunnelbridge_procs,

    38

	_tile_type_unmovable_procs;

    39

    40

const TileTypeProcs * const _tile_type_procs[16] = {

    41

	&_tile_type_clear_procs,

    42

	&_tile_type_rail_procs,

    43

	&_tile_type_road_procs,

    44

	&_tile_type_town_procs,

    45

	&_tile_type_trees_procs,

    46

	&_tile_type_station_procs,

    47

	&_tile_type_water_procs,

    48

	&_tile_type_dummy_procs,

    49

	&_tile_type_industry_procs,

    50

	&_tile_type_tunnelbridge_procs,

    51

	&_tile_type_unmovable_procs,

    52

};

    53

    54

/* landscape slope => sprite */

    55

const byte _tileh_to_sprite[32] = {

    56

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

    57

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

    58

};

    59

    60

const Slope _inclined_tileh[] = {

    61

	SLOPE_SW,  SLOPE_NW,  SLOPE_SW,  SLOPE_SE, SLOPE_NE, SLOPE_SE, SLOPE_NE, SLOPE_NW,

    62

	SLOPE_E,   SLOPE_N,   SLOPE_W,   SLOPE_S,

    63

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    64

};

    65

    66

SnowLine *_snow_line = NULL;

    67

    68

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

    69

{

    70

	int z = 0;

    71

    72

	switch (corners) {

    73

	case SLOPE_W:

    74

		if (x - y >= 0)

    75

			z = (x - y) >> 1;

    76

		break;

    77

    78

	case SLOPE_S:

    79

		y ^= 0xF;

    80

		if ( (x - y) >= 0)

    81

			z = (x - y) >> 1;

    82

		break;

    83

    84

	case SLOPE_SW:

    85

		z = (x >> 1) + 1;

    86

		break;

    87

    88

	case SLOPE_E:

    89

		if (y - x >= 0)

    90

			z = (y - x) >> 1;

    91

		break;

    92

    93

	case SLOPE_EW:

    94

	case SLOPE_NS:

    95

	case SLOPE_ELEVATED:

    96

		z = 4;

    97

		break;

    98

    99

	case SLOPE_SE:

   100

		z = (y >> 1) + 1;

   101

		break;

   102

   103

	case SLOPE_WSE:

   104

		z = 8;

   105

		y ^= 0xF;

   106

		if (x - y < 0)

   107

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

   108

		break;

   109

   110

	case SLOPE_N:

   111

		y ^= 0xF;

   112

		if (y - x >= 0)

   113

			z = (y - x) >> 1;

   114

		break;

   115

   116

	case SLOPE_NW:

   117

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

   118

		break;

   119

   120

	case SLOPE_NWS:

   121

		z = 8;

   122

		if (x - y < 0)

   123

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

   124

		break;

   125

   126

	case SLOPE_NE:

   127

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

   128

		break;

   129

   130

	case SLOPE_ENW:

   131

		z = 8;

   132

		y ^= 0xF;

   133

		if (y - x < 0)

   134

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

   135

		break;

   136

   137

	case SLOPE_SEN:

   138

		z = 8;

   139

		if (y - x < 0)

   140

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

   141

		break;

   142

   143

	case SLOPE_STEEP_S:

   144

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

   145

		break;

   146

   147

	case SLOPE_STEEP_W:

   148

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

   149

		break;

   150

   151

	case SLOPE_STEEP_N:

   152

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

   153

		break;

   154

   155

	case SLOPE_STEEP_E:

   156

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

   157

		break;

   158

   159

		default: break;

   160

	}

   161

   162

	return z;

   163

}

   164

   165

uint GetSlopeZ(int x, int y)

   166

{

   167

	TileIndex tile = TileVirtXY(x, y);

   168

   169

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

   170

}

   171

   172

   173

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   174

{

   175

	Slope tileh = GetTileSlope(tile, z);

   176

	Slope slope = _tile_type_procs[GetTileType(tile)]->get_slope_tileh_proc(tile, tileh);

   177

   178

	/* Flatter slope -> higher base height */

   179

	if (slope < tileh) *z += TILE_HEIGHT;

   180

	return slope;

   181

}

   182

   183

   184

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

   185

{

   186

	uint z;

   187

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

   188

   189

	return

   190

		(

   191

			z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_N ? TILE_HEIGHT : 0) >

   192

			z      + (slope      & SLOPE_E ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_E ? TILE_HEIGHT : 0)

   193

		) || (

   194

			z_here + (slope_here & SLOPE_W ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_W ? TILE_HEIGHT : 0) >

   195

			z      + (slope      & SLOPE_S ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_S ? TILE_HEIGHT : 0)

   196

		);

   197

}

   198

   199

   200

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

   201

{

   202

	uint z;

   203

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

   204

   205

	return

   206

		(

   207

			z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_N ? TILE_HEIGHT : 0) >

   208

			z      + (slope      & SLOPE_W ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_W ? TILE_HEIGHT : 0)

   209

		) || (

   210

			z_here + (slope_here & SLOPE_E ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_E ? TILE_HEIGHT : 0) >

   211

			z      + (slope      & SLOPE_S ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_S ? TILE_HEIGHT : 0)

   212

		);

   213

}

   214

   215

   216

void DrawFoundation(TileInfo *ti, uint f)

   217

{

   218

	SpriteID sprite_base = SPR_SLOPES_BASE - 15;

   219

	Slope slope;

   220

	uint z;

   221

   222

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

   223

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

   224

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

   225

   226

	if (IsSteepSlope(ti->tileh)) {

   227

		SpriteID lower_base;

   228

   229

		/* Lower part of foundation */

   230

		lower_base = sprite_base;

   231

		if (lower_base == SPR_SLOPES_BASE - 15) lower_base = SPR_FOUNDATION_BASE;

   232

		AddSortableSpriteToDraw(

   233

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

   234

		);

   235

		ti->z += TILE_HEIGHT;

   236

		ti->tileh = _inclined_tileh[f - 15];

   237

		if (f < 15 + 8) {

   238

			/* inclined */

   239

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

   240

			OffsetGroundSprite(31, 9);

   241

		} else if (f >= 15 + 8 + 4) {

   242

			/* three corners raised */

   243

			SpriteID upper = sprite_base + 15 + (f - 15 - 8 - 4) * 2;

   244

   245

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

   246

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

   247

			OffsetGroundSprite(31, 9);

   248

		} else {

   249

			/* one corner raised */

   250

			OffsetGroundSprite(31, 1);

   251

		}

   252

	} else {

   253

		if (f < 15) {

   254

			/* leveled foundation

   255

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

   256

			if (sprite_base  == SPR_SLOPES_BASE - 15) sprite_base = SPR_FOUNDATION_BASE;

   257

   258

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

   259

			ti->z += TILE_HEIGHT;

   260

			ti->tileh = SLOPE_FLAT;

   261

			OffsetGroundSprite(31, 1);

   262

		} else {

   263

			/* inclined foundation */

   264

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

   265

			ti->tileh = _inclined_tileh[f - 15];

   266

			OffsetGroundSprite(31, 9);

   267

		}

   268

	}

   269

}

   270

   271

void DoClearSquare(TileIndex tile)

   272

{

   273

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

   274

	MarkTileDirtyByTile(tile);

   275

}

   276

   277

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

   278

{

   279

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

   280

}

   281

   282

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

   283

{

   284

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

   285

}

   286

   287

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   288

{

   289

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

   290

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

   291

}

   292

   293

void AnimateTile(TileIndex tile)

   294

{

   295

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

   296

}

   297

   298

void ClickTile(TileIndex tile)

   299

{

   300

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

   301

}

   302

   303

void GetTileDesc(TileIndex tile, TileDesc *td)

   304

{

   305

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

   306

}

   307

   308

/**

   309

 * Has a snow line table already been loaded.

   310

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

   311

 */

   312

bool IsSnowLineSet(void)

   313

{

   314

	return _snow_line != NULL;

   315

}

   316

   317

/**

   318

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

   319

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

   320

 */

   321

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

   322

{

   323

	_snow_line = CallocT<SnowLine>(1);

   324

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

   325

   326

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

   327

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

   328

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

   329

		}

   330

	}

   331

}

   332

   333

/**

   334

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

   335

 * @return the snow line height.

   336

 */

   337

byte GetSnowLine(void)

   338

{

   339

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

   340

   341

	YearMonthDay ymd;

   342

	ConvertDateToYMD(_date, &ymd);

   343

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

   344

}

   345

   346

/**

   347

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

   348

 * @return the highest snow line height.

   349

 */

   350

byte HighestSnowLine(void)

   351

{

   352

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

   353

}

   354

   355

/**

   356

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

   357

 */

   358

void ClearSnowLine(void)

   359

{

   360

	free(_snow_line);

   361

	_snow_line = NULL;

   362

}

   363

   364

/** Clear a piece of landscape

   365

 * @param tile tile to clear

   366

 * @param flags of operation to conduct

   367

 * @param p1 unused

   368

 * @param p2 unused

   369

 */

   371

{

   372

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   373

   374

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

   375

}

   376

   377

/** Clear a big piece of landscape

   378

 * @param tile end tile of area dragging

   379

 * @param p1 start tile of area dragging

   380

 * @param flags of operation to conduct

   381

 * @param p2 unused

   382

 */

   384

{

   386

	int ex;

   387

	int ey;

   388

	int sx, sy;

   389

	int x, y;

   390

	bool success = false;

   391

   392

	if (p1 >= MapSize()) return CMD_ERROR;

   393

   394

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   395

   396

	/* make sure sx,sy are smaller than ex,ey */

   397

	ex = TileX(tile);

   398

	ey = TileY(tile);

   399

	sx = TileX(p1);

   400

	sy = TileY(p1);

   401

	if (ex < sx) Swap(ex, sx);

   402

	if (ey < sy) Swap(ey, sy);

   403

   404

	money = GetAvailableMoneyForCommand();

   405

	cost = 0;

   406

   407

	for (x = sx; x <= ex; ++x) {

   408

		for (y = sy; y <= ey; ++y) {

   409

			ret = DoCommand(TileXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);

   410

			if (CmdFailed(ret)) continue;

   411

			cost += ret;

   412

			success = true;

   413

   414

			if (flags & DC_EXEC) {

   415

				if (ret > 0 && (money -= ret) < 0) {

   416

					_additional_cash_required = ret;

   417

					return cost - ret;

   418

				}

   419

				DoCommand(TileXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   420

   421

				/* draw explosion animation... */

   422

				if ((x == sx || x == ex) && (y == sy || y == ey)) {

   423

					/* big explosion in each corner, or small explosion for single tiles */

   424

					CreateEffectVehicleAbove(x * TILE_SIZE + TILE_SIZE / 2, y * TILE_SIZE + TILE_SIZE / 2, 2,

   425

						sy == ey && sx == ex ? EV_EXPLOSION_SMALL : EV_EXPLOSION_LARGE

   426

					);

   427

				}

   428

			}

   429

		}

   430

	}

   431

   432

	return (success) ? cost : CMD_ERROR;

   433

}

   434

   435

   436

#define TILELOOP_BITS 4

   437

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   438

#define TILELOOP_ASSERTMASK ((TILELOOP_SIZE - 1) + ((TILELOOP_SIZE - 1) << MapLogX()))

   439

#define TILELOOP_CHKMASK (((1 << (MapLogX() - TILELOOP_BITS))-1) << TILELOOP_BITS)

   440

   441

void RunTileLoop()

   442

{

   443

	TileIndex tile;

   444

	uint count;

   445

   446

	tile = _cur_tileloop_tile;

   447

   448

	assert( (tile & ~TILELOOP_ASSERTMASK) == 0);

   449

	count = (MapSizeX() / TILELOOP_SIZE) * (MapSizeY() / TILELOOP_SIZE);

   450

	do {

   451

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

   452

   453

		if (TileX(tile) < MapSizeX() - TILELOOP_SIZE) {

   454

			tile += TILELOOP_SIZE; // no overflow

   455

		} else {

   456

			tile = TILE_MASK(tile - TILELOOP_SIZE * (MapSizeX() / TILELOOP_SIZE - 1) + TileDiffXY(0, TILELOOP_SIZE)); /* x would overflow, also increase y */

   457

		}

   458

	} while (--count);

   459

	assert( (tile & ~TILELOOP_ASSERTMASK) == 0);

   460

   461

	tile += 9;

   462

	if (tile & TILELOOP_CHKMASK)

   463

		tile = (tile + MapSizeX()) & TILELOOP_ASSERTMASK;

   464

	_cur_tileloop_tile = tile;

   465

}

   466

   467

void InitializeLandscape()

   468

{

   469

	uint maxx = MapMaxX();

   470

	uint maxy = MapMaxY();

   471

	uint sizex = MapSizeX();

   472

	uint x;

   473

	uint y;

   474

   475

	for (y = 0; y < maxy; y++) {

   476

		for (x = 0; x < maxx; x++) {

   477

			MakeClear(sizex * y + x, CLEAR_GRASS, 3);

   478

			SetTileHeight(sizex * y + x, 0);

   479

			SetTropicZone(sizex * y + x, TROPICZONE_INVALID);

   480

			ClearBridgeMiddle(sizex * y + x);

   481

		}

   482

		MakeVoid(sizex * y + x);

   483

	}

   484

	for (x = 0; x < sizex; x++) MakeVoid(sizex * y + x);

   485

}

   486

   487

void ConvertGroundTilesIntoWaterTiles()

   488

{

   489

	TileIndex tile;

   490

	uint z;

   491

	Slope slope;

   492

   493