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

const Slope _inclined_tileh[] = {

    60

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

    61

	SLOPE_E,   SLOPE_N,   SLOPE_W,   SLOPE_S,

    62

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    63

};

    64

    65

SnowLine *_snow_line = NULL;

    66

    67

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

    68

{

    69

	int z = 0;

    70

    71

	switch (corners) {

    72

	case SLOPE_W:

    73

		if (x - y >= 0)

    74

			z = (x - y) >> 1;

    75

		break;

    76

    77

	case SLOPE_S:

    78

		y ^= 0xF;

    79

		if ( (x - y) >= 0)

    80

			z = (x - y) >> 1;

    81

		break;

    82

    83

	case SLOPE_SW:

    84

		z = (x >> 1) + 1;

    85

		break;

    86

    87

	case SLOPE_E:

    88

		if (y - x >= 0)

    89

			z = (y - x) >> 1;

    90

		break;

    91

    92

	case SLOPE_EW:

    93

	case SLOPE_NS:

    94

	case SLOPE_ELEVATED:

    95

		z = 4;

    96

		break;

    97

    98

	case SLOPE_SE:

    99

		z = (y >> 1) + 1;

   100

		break;

   101

   102

	case SLOPE_WSE:

   103

		z = 8;

   104

		y ^= 0xF;

   105

		if (x - y < 0)

   106

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

   107

		break;

   108

   109

	case SLOPE_N:

   110

		y ^= 0xF;

   111

		if (y - x >= 0)

   112

			z = (y - x) >> 1;

   113

		break;

   114

   115

	case SLOPE_NW:

   116

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

   117

		break;

   118

   119

	case SLOPE_NWS:

   120

		z = 8;

   121

		if (x - y < 0)

   122

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

   123

		break;

   124

   125

	case SLOPE_NE:

   126

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

   127

		break;

   128

   129

	case SLOPE_ENW:

   130

		z = 8;

   131

		y ^= 0xF;

   132

		if (y - x < 0)

   133

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

   134

		break;

   135

   136

	case SLOPE_SEN:

   137

		z = 8;

   138

		if (y - x < 0)

   139

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

   140

		break;

   141

   142

	case SLOPE_STEEP_S:

   143

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

   144

		break;

   145

   146

	case SLOPE_STEEP_W:

   147

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

   148

		break;

   149

   150

	case SLOPE_STEEP_N:

   151

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

   152

		break;

   153

   154

	case SLOPE_STEEP_E:

   155

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

   156

		break;

   157

   158

		default: break;

   159

	}

   160

   161

	return z;

   162

}

   163

   164

uint GetSlopeZ(int x, int y)

   165

{

   166

	TileIndex tile = TileVirtXY(x, y);

   167

   168

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

   169

}

   170

   171

   172

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   173

{

   174

	Slope tileh = GetTileSlope(tile, z);

   175

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

   176

   177

	/* Flatter slope -> higher base height */

   178

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

   179

	return slope;

   180

}

   181

   182

   183

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

   184

{

   185

	uint z;

   186

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

   187

   188

	return

   189

		(

   190

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

   191

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

   192

		) || (

   193

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

   194

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

   195

		);

   196

}

   197

   198

   199

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

   200

{

   201

	uint z;

   202

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

   203

   204

	return

   205

		(

   206

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

   207

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

   208

		) || (

   209

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

   210

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

   211

		);

   212

}

   213

   214

   215

void DrawFoundation(TileInfo *ti, uint f)

   216

{

   217

	SpriteID sprite_base = SPR_SLOPES_BASE - 15;

   218

	Slope slope;

   219

	uint z;

   220

   221

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

   222

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

   223

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

   224

   225

	if (IsSteepSlope(ti->tileh)) {

   226

		SpriteID lower_base;

   227

   228

		/* Lower part of foundation */

   229

		lower_base = sprite_base;

   230

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

   231

		AddSortableSpriteToDraw(

   232

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

   233

		);

   234

		ti->z += TILE_HEIGHT;

   235

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

   236

		if (f < 15 + 8) {

   237

			/* inclined */

   238

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

   239

			OffsetGroundSprite(31, 9);

   240

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

   241

			/* three corners raised */

   242

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

   243

   244

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

   245

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

   246

			OffsetGroundSprite(31, 9);

   247

		} else {

   248

			/* one corner raised */

   249

			OffsetGroundSprite(31, 1);

   250

		}

   251

	} else {

   252

		if (f < 15) {

   253

			/* leveled foundation

   254

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

   255

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

   256

   257

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

   258

			ti->z += TILE_HEIGHT;

   259

			ti->tileh = SLOPE_FLAT;

   260

			OffsetGroundSprite(31, 1);

   261

		} else {

   262

			/* inclined foundation */

   263

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

   264

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

   265

			OffsetGroundSprite(31, 9);

   266

		}

   267

	}

   268

}

   269

   270

void DoClearSquare(TileIndex tile)

   271

{

   272

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

   273

	MarkTileDirtyByTile(tile);

   274

}

   275

   276

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

   277

{

   278

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

   279

}

   280

   281

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

   282

{

   283

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

   284

}

   285

   286

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   287

{

   288

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

   289

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

   290

}

   291

   292

void AnimateTile(TileIndex tile)

   293

{

   294

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

   295

}

   296

   297

void ClickTile(TileIndex tile)

   298

{

   299

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

   300

}

   301

   302

void GetTileDesc(TileIndex tile, TileDesc *td)

   303

{

   304

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

   305

}

   306

   307

/**

   308

 * Has a snow line table already been loaded.

   309

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

   310

 */

   311

bool IsSnowLineSet(void)

   312

{

   313

	return _snow_line != NULL;

   314

}

   315

   316

/**

   317

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

   318

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

   319

 */

   320

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

   321

{

   322

	_snow_line = CallocT<SnowLine>(1);

   323

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

   324

   325

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

   326

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

   327

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

   328

		}

   329

	}

   330

}

   331

   332

/**

   333

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

   334

 * @return the snow line height.

   335

 */

   336

byte GetSnowLine(void)

   337

{

   338

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

   339

   340

	YearMonthDay ymd;

   341

	ConvertDateToYMD(_date, &ymd);

   342

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

   343

}

   344

   345

/**

   346

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

   347

 * @return the highest snow line height.

   348

 */

   349

byte HighestSnowLine(void)

   350

{

   351

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

   352

}

   353

   354

/**

   355

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

   356

 */

   357

void ClearSnowLine(void)

   358

{

   359

	free(_snow_line);

   360

	_snow_line = NULL;

   361

}

   362

   363

/** Clear a piece of landscape

   364

 * @param tile tile to clear

   365

 * @param flags of operation to conduct

   366

 * @param p1 unused

   367

 * @param p2 unused

   368

 */

   369

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

   370

{

   371

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   372

   373

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

   374

}

   375

   376

/** Clear a big piece of landscape

   377

 * @param tile end tile of area dragging

   378

 * @param p1 start tile of area dragging

   379

 * @param flags of operation to conduct

   380

 * @param p2 unused

   381

 */

   382

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

   383

{

   384

	CommandCost cost, ret, money;

   385

	int ex;

   386

	int ey;

   387

	int sx, sy;

   388

	int x, y;

   389

	bool success = false;

   390

   391

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

   392

   393

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   394

   395

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

   396

	ex = TileX(tile);

   397

	ey = TileY(tile);

   398

	sx = TileX(p1);

   399

	sy = TileY(p1);

   400

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

   401

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

   402

   403

	money.AddCost(GetAvailableMoneyForCommand());

   404

   405

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

   406

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

   407

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

   408

			if (CmdFailed(ret)) continue;

   409

			success = true;

   410

   411

			if (flags & DC_EXEC) {

   412

				money.AddCost(-ret.GetCost());

   413

				if (ret.GetCost() > 0 && money.GetCost() < 0) {

   414

					_additional_cash_required = ret.GetCost();

   415

					return cost;

   416

				}

   417

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

   418

   419

				/* draw explosion animation... */

   420

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

   421

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

   422

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

   423

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

   424

					);

   425

				}

   426

			}

   427

			cost.AddCost(ret);

   428

		}

   429

	}

   430

   431

	return (success) ? cost : CMD_ERROR;

   432

}

   433

   434

   435

#define TILELOOP_BITS 4

   436

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   437

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

   438

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

   439

   440

void RunTileLoop()

   441

{

   442

	TileIndex tile;

   443

	uint count;

   444

   445

	tile = _cur_tileloop_tile;

   446

   447

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

   448

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

   449

	do {

   450

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

   451

   452

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

   453

			tile += TILELOOP_SIZE; // no overflow

   454

		} else {

   455

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

   456

		}

   457

	} while (--count);

   458

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

   459

   460

	tile += 9;

   461

	if (tile & TILELOOP_CHKMASK)

   462

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

   463

	_cur_tileloop_tile = tile;

   464

}

   465

   466

void InitializeLandscape()

   467

{

   468

	uint maxx = MapMaxX();

   469

	uint maxy = MapMaxY();

   470

	uint sizex = MapSizeX();

   471

	uint x;

   472

	uint y;

   473

   474

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

   475

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

   476

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

   477

			SetTileHeight(sizex * y + x, 0);

   478

			SetTropicZone(sizex * y + x, TROPICZONE_INVALID);

   479

			ClearBridgeMiddle(sizex * y + x);

   480

		}

   481

		MakeVoid(sizex * y + x);

   482

	}

   483

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

   484

}

   485

   486

void ConvertGroundTilesIntoWaterTiles()

   487

{

   488

	TileIndex tile;

   489

	uint z;

   490

	Slope slope;

   491

   492

	for (tile = 0; tile < MapSize(); ++tile) {