1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "functions.h"

     7

#include "map.h"

     8

#include "player.h"

     9

#include "spritecache.h"

    10

#include "table/sprites.h"

    11

#include "tile.h"

    12

#include <stdarg.h>

    13

#include "viewport.h"

    14

#include "command.h"

    15

#include "vehicle.h"

    16

#include "variables.h"

    17

#include "void_map.h"

    18

#include "water_map.h"

    19

    20

extern const TileTypeProcs

    21

	_tile_type_clear_procs,

    22

	_tile_type_rail_procs,

    23

	_tile_type_road_procs,

    24

	_tile_type_town_procs,

    25

	_tile_type_trees_procs,

    26

	_tile_type_station_procs,

    27

	_tile_type_water_procs,

    28

	_tile_type_dummy_procs,

    29

	_tile_type_industry_procs,

    30

	_tile_type_tunnelbridge_procs,

    31

	_tile_type_unmovable_procs;

    32

    33

const TileTypeProcs * const _tile_type_procs[16] = {

    34

	&_tile_type_clear_procs,

    35

	&_tile_type_rail_procs,

    36

	&_tile_type_road_procs,

    37

	&_tile_type_town_procs,

    38

	&_tile_type_trees_procs,

    39

	&_tile_type_station_procs,

    40

	&_tile_type_water_procs,

    41

	&_tile_type_dummy_procs,

    42

	&_tile_type_industry_procs,

    43

	&_tile_type_tunnelbridge_procs,

    44

	&_tile_type_unmovable_procs,

    45

};

    46

    47

/* landscape slope => sprite */

    48

const byte _tileh_to_sprite[32] = {

    49

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

    50

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

    51

};

    52

    53

const byte _inclined_tileh[] = {

    54

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

    55

};

    56

    57

    58

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

    59

{

    60

	int z = 0;

    61

    62

	switch (corners) {

    63

	case SLOPE_W:

    64

		if (x - y >= 0)

    65

			z = (x - y) >> 1;

    66

		break;

    67

    68

	case SLOPE_S:

    69

		y^=0xF;

    70

		if ( (x - y) >= 0)

    71

			z = (x - y) >> 1;

    72

		break;

    73

    74

	case SLOPE_SW:

    75

		z = (x>>1) + 1;

    76

		break;

    77

    78

	case SLOPE_E:

    79

		if (y - x >= 0)

    80

			z = (y - x) >> 1;

    81

		break;

    82

    83

	case SLOPE_EW:

    84

	case SLOPE_NS:

    85

	case SLOPE_ELEVATED:

    86

		z = 4;

    87

		break;

    88

    89

	case SLOPE_SE:

    90

		z = (y>>1) + 1;

    91

		break;

    92

    93

	case SLOPE_WSE:

    94

		z = 8;

    95

		y^=0xF;

    96

		if (x - y < 0)

    97

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

    98

		break;

    99

   100

	case SLOPE_N:

   101

		y ^= 0xF;

   102

		if (y - x >= 0)

   103

			z = (y - x) >> 1;

   104

		break;

   105

   106

	case SLOPE_NW:

   107

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

   108

		break;

   109

   110

	case SLOPE_NWS:

   111

		z = 8;

   112

		if (x - y < 0)

   113

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

   114

		break;

   115

   116

	case SLOPE_NE:

   117

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

   118

		break;

   119

   120

	case SLOPE_ENW:

   121

		z = 8;

   122

		y ^= 0xF;

   123

		if (y - x < 0)

   124

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

   125

		break;

   126

   127

	case SLOPE_SEN:

   128

		z = 8;

   129

		if (y - x < 0)

   130

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

   131

		break;

   132

   133

	case SLOPE_STEEP_S:

   134

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

   135

		break;

   136

   137

	case SLOPE_STEEP_W:

   138

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

   139

		break;

   140

   141

	case SLOPE_STEEP_N:

   142

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

   143

		break;

   144

   145

	case SLOPE_STEEP_E:

   146

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

   147

		break;

   148

   149

		default: break;

   150

	}

   151

   152

	return z;

   153

}

   154

   155

uint GetSlopeZ(int x, int y)

   156

{

   157

	TileIndex tile = TileVirtXY(x, y);

   158

   159

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

   160

}

   161

   162

   163

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   164

{

   165

	Slope tileh = GetTileSlope(tile, z);

   166

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

   167

   168

	// Flatter slope -> higher base height

   169

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

   170

	return slope;

   171

}

   172

   173

   174

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

   175

{

   176

	uint z;

   177

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

   178

   179

	return

   180

		(z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) > z + (slope & SLOPE_E ? TILE_HEIGHT : 0)) ||

   181

		(z_here + (slope_here & SLOPE_W ? TILE_HEIGHT : 0) > z + (slope & SLOPE_S ? TILE_HEIGHT : 0));

   182

}

   183

   184

   185

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

   186

{

   187

	uint z;

   188

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

   189

   190

	return

   191

		(z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) > z + (slope & SLOPE_W ? TILE_HEIGHT : 0)) ||

   192

		(z_here + (slope_here & SLOPE_E ? TILE_HEIGHT : 0) > z + (slope & SLOPE_S ? TILE_HEIGHT : 0));

   193

}

   194

   195

   196

void DrawFoundation(TileInfo *ti, uint f)

   197

{

   198

	uint32 sprite_base = SPR_SLOPES_BASE - 15;

   199

	Slope slope;

   200

	uint z;

   201

   202

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

   203

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

   204

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

   205

   206

	if (f < 15) {

   207

		// leveled foundation

   208

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

   209

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

   210

   211

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

   212

		ti->z += TILE_HEIGHT;

   213

		ti->tileh = SLOPE_FLAT;

   214

		OffsetGroundSprite(31, 1);

   215

	} else {

   216

		// inclined foundation

   217

		if (IsSteepSlope(ti->tileh)) {

   218

			uint32 lower_base;

   219

   220

			// Lower part of foundation

   221

			lower_base = sprite_base;

   222

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

   223

			AddSortableSpriteToDraw(

   224

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

   225

			);

   226

			ti->z += TILE_HEIGHT;

   227

		}

   228

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

   229

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

   230

		OffsetGroundSprite(31, 9);

   231

	}

   232

}

   233

   234

void DoClearSquare(TileIndex tile)

   235

{

   236

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

   237

	MarkTileDirtyByTile(tile);

   238

}

   239

   240

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   241

{

   242

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

   243

}

   244

   245

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

   246

{

   247

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

   248

}

   249

   250

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   251

{

   252

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

   253

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

   254

}

   255

   256

void AnimateTile(TileIndex tile)

   257

{

   258

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

   259

}

   260

   261

void ClickTile(TileIndex tile)

   262

{

   263

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

   264

}

   265

   266

void GetTileDesc(TileIndex tile, TileDesc *td)

   267

{

   268

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

   269

}

   270

   271

/** Clear a piece of landscape

   272

 * @param tile tile to clear

   273

 * @param p1 unused

   274

 * @param p2 unused

   275

 */

   276

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

   277

{

   278

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   279

   280

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

   281

}

   282

   283

/** Clear a big piece of landscape

   284

 * @param tile end tile of area dragging

   285

 * @param p1 start tile of area dragging

   286

 * @param p2 unused

   287

 */

   288

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

   289

{

   290

	int32 cost, ret, money;

   291

	int ex;

   292

	int ey;

   293

	int sx,sy;

   294

	int x,y;

   295

	bool success = false;

   296

   297

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

   298

   299

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   300

   301

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

   302

	ex = TileX(tile);

   303

	ey = TileY(tile);

   304

	sx = TileX(p1);

   305

	sy = TileY(p1);

   306

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

   307

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

   308

   309

	money = GetAvailableMoneyForCommand();

   310

	cost = 0;

   311

   312

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

   313

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

   314

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

   315

			if (CmdFailed(ret)) continue;

   316

			cost += ret;

   317

			success = true;

   318

   319

			if (flags & DC_EXEC) {

   320

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

   321

					_additional_cash_required = ret;

   322

					return cost - ret;

   323

				}

   324

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

   325

   326

				// draw explosion animation...

   327

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

   328

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

   329

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

   330

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

   331

					);

   332

				}

   333

			}

   334

		}

   335

	}

   336

   337

	return (success) ? cost : CMD_ERROR;

   338

}

   339

   340

   341

#define TILELOOP_BITS 4

   342

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   343

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

   344

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

   345

   346

void RunTileLoop(void)

   347

{

   348

	TileIndex tile;

   349

	uint count;

   350

   351

	tile = _cur_tileloop_tile;

   352

   353

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

   354

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

   355

	do {

   356

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

   357

   358

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

   359

			tile += TILELOOP_SIZE; /* no overflow */

   360

		} else {

   361

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

   362

		}

   363

	} while (--count);

   364

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

   365

   366

	tile += 9;

   367

	if (tile & TILELOOP_CHKMASK)

   368

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

   369

	_cur_tileloop_tile = tile;

   370

}

   371

   372

void InitializeLandscape(void)

   373

{

   374

	uint maxx = MapMaxX();

   375

	uint maxy = MapMaxY();

   376

	uint sizex = MapSizeX();

   377

	uint x;

   378

	uint y;

   379

   380

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

   381

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

   382

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

   383

			SetTileHeight(sizex * y + x, 0);

   384

		}

   385

		MakeVoid(sizex * y + x);

   386

	}

   387

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

   388

}

   389

   390

void ConvertGroundTilesIntoWaterTiles(void)

   391

{

   392

	TileIndex tile;

   393

   394

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

   395

		if (IsTileType(tile, MP_CLEAR) && GetTileMaxZ(tile) == 0) {

   396

			MakeWater(tile);

   397

		}

   398

	}

   399

}

   400

   401

static const byte _genterrain_tbl_1[5] = { 10, 22, 33, 37, 4 };

   402

static const byte _genterrain_tbl_2[5] = { 0, 0, 0, 0, 33 };

   403

   404

static void GenerateTerrain(int type, int flag)

   405

{

   406

	uint32 r;

   407

	uint x;

   408

	uint y;

   409

	uint w;

   410

	uint h;

   411

	const Sprite* template;

   412

	const byte *p;

   413

	Tile* tile;

   414

	byte direction;

   415

   416

	r = Random();

   417

	template = GetSprite((((r >> 24) * _genterrain_tbl_1[type]) >> 8) + _genterrain_tbl_2[type] + 4845);

   418

   419

	x = r & MapMaxX();

   420

	y = (r >> MapLogX()) & MapMaxY();

   421

   422

   423

	if (x < 2 || y < 2) return;

   424

   425

	direction = GB(r, 22, 2);

   426

	if (direction & 1) {

   427

		w = template->height;

   428

		h = template->width;

   429

	} else {

   430

		w = template->width;

   431

		h = template->height;

   432

	}

   433

	p = template->data;

   434

   435

	if (flag & 4) {

   436

		uint xw = x * MapSizeY();

   437

		uint yw = y * MapSizeX();

   438

		uint bias = (MapSizeX() + MapSizeY()) * 16;

   439

   440

		switch (flag & 3) {

   441

			case 0:

   442

				if (xw + yw > MapSize() - bias) return;

   443

				break;

   444

   445

			case 1:

   446

				if (yw < xw + bias) return;

   447

				break;

   448

   449

			case 2:

   450

				if (xw + yw < MapSize() + bias) return;

   451

				break;

   452

   453

			case 3:

   454

				if (xw < yw + bias) return;

   455

				break;

   456

		}

   457

	}

   458

   459

	if (x + w >= MapMaxX() - 1) return;

   460

	if (y + h >= MapMaxY() - 1) return;

   461

   462

	tile = &_m[TileXY(x, y)];

   463

   464

	switch (direction) {

   465

		case 0:

   466

			do {

   467

				Tile* tile_cur = tile;

   468

				uint w_cur;

   469

   470

				for (w_cur = w; w_cur != 0; --w_cur) {

   471

					if (*p >= tile_cur->type_height) tile_cur->type_height = *p;

   472

					p++;

   473

					tile_cur++;

   474

				}

   475

				tile += TileDiffXY(0, 1);

   476

			} while (--h != 0);

   477

			break;

   478

   479

		case 1:

   480

			do {

   481

				Tile* tile_cur = tile;

   482

				uint h_cur;

   483

   484

				for (h_cur = h; h_cur != 0; --h_cur) {

   485

					if (*p >= tile_cur->type_height) tile_cur->type_height = *p;

   486

					p++;

   487

					tile_cur += TileDiffXY(0, 1);

   488

				}

   489

				tile++;

   490

			} while (--w != 0);

   491

			break;

   492

   493

		case 2:

   494

			tile += TileDiffXY(w - 1, 0);

   495

			do {

   496

				Tile* tile_cur = tile;