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

	SLOPE_E, SLOPE_N, SLOPE_W, SLOPE_S,

    56

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    57

};

    58

    59

    60

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

    61

{

    62

	int z = 0;

    63

    64

	switch (corners) {

    65

	case SLOPE_W:

    66

		if (x - y >= 0)

    67

			z = (x - y) >> 1;

    68

		break;

    69

    70

	case SLOPE_S:

    71

		y^=0xF;

    72

		if ( (x - y) >= 0)

    73

			z = (x - y) >> 1;

    74

		break;

    75

    76

	case SLOPE_SW:

    77

		z = (x>>1) + 1;

    78

		break;

    79

    80

	case SLOPE_E:

    81

		if (y - x >= 0)

    82

			z = (y - x) >> 1;

    83

		break;

    84

    85

	case SLOPE_EW:

    86

	case SLOPE_NS:

    87

	case SLOPE_ELEVATED:

    88

		z = 4;

    89

		break;

    90

    91

	case SLOPE_SE:

    92

		z = (y>>1) + 1;

    93

		break;

    94

    95

	case SLOPE_WSE:

    96

		z = 8;

    97

		y^=0xF;

    98

		if (x - y < 0)

    99

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

   100

		break;

   101

   102

	case SLOPE_N:

   103

		y ^= 0xF;

   104

		if (y - x >= 0)

   105

			z = (y - x) >> 1;

   106

		break;

   107

   108

	case SLOPE_NW:

   109

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

   110

		break;

   111

   112

	case SLOPE_NWS:

   113

		z = 8;

   114

		if (x - y < 0)

   115

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

   116

		break;

   117

   118

	case SLOPE_NE:

   119

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

   120

		break;

   121

   122

	case SLOPE_ENW:

   123

		z = 8;

   124

		y ^= 0xF;

   125

		if (y - x < 0)

   126

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

   127

		break;

   128

   129

	case SLOPE_SEN:

   130

		z = 8;

   131

		if (y - x < 0)

   132

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

   133

		break;

   134

   135

	case SLOPE_STEEP_S:

   136

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

   137

		break;

   138

   139

	case SLOPE_STEEP_W:

   140

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

   141

		break;

   142

   143

	case SLOPE_STEEP_N:

   144

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

   145

		break;

   146

   147

	case SLOPE_STEEP_E:

   148

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

   149

		break;

   150

   151

		default: break;

   152

	}

   153

   154

	return z;

   155

}

   156

   157

uint GetSlopeZ(int x, int y)

   158

{

   159

	TileIndex tile = TileVirtXY(x, y);

   160

   161

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

   162

}

   163

   164

   165

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   166

{

   167

	Slope tileh = GetTileSlope(tile, z);

   168

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

   169

   170

	// Flatter slope -> higher base height

   171

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

   172

	return slope;

   173

}

   174

   175

   176

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

   177

{

   178

	uint z;

   179

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

   180

   181

	return

   182

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

   183

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

   184

}

   185

   186

   187

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

   188

{

   189

	uint z;

   190

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

   191

   192

	return

   193

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

   194

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

   195

}

   196

   197

   198

void DrawFoundation(TileInfo *ti, uint f)

   199

{

   200

	uint32 sprite_base = SPR_SLOPES_BASE - 15;

   201

	Slope slope;

   202

	uint z;

   203

   204

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

   205

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

   206

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

   207

   208

	if (IsSteepSlope(ti->tileh)) {

   209

		uint32 lower_base;

   210

   211

		// Lower part of foundation

   212

		lower_base = sprite_base;

   213

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

   214

		AddSortableSpriteToDraw(

   215

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

   216

		);

   217

		ti->z += TILE_HEIGHT;

   218

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

   219

		if (f < 15 + 8) {

   220

			// inclined

   221

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

   222

			OffsetGroundSprite(31, 9);

   223

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

   224

			// three corners raised

   225

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

   226

   227

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

   228

			AddChildSpriteScreen(upper + 1, 31, 9);

   229

			OffsetGroundSprite(31, 9);

   230

		} else {

   231

			// one corner raised

   232

			OffsetGroundSprite(31, 1);

   233

		}

   234

	} else {

   235

		if (f < 15) {

   236

			// leveled foundation

   237

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

   238

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

   239

   240

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

   241

			ti->z += TILE_HEIGHT;

   242

			ti->tileh = SLOPE_FLAT;

   243

			OffsetGroundSprite(31, 1);

   244

		} else {

   245

			// inclined foundation

   246

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

   247

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

   248

			OffsetGroundSprite(31, 9);

   249

		}

   250

	}

   251

}

   252

   253

void DoClearSquare(TileIndex tile)

   254

{

   255

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

   256

	MarkTileDirtyByTile(tile);

   257

}

   258

   259

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   260

{

   261

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

   262

}

   263

   264

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

   265

{

   266

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

   267

}

   268

   269

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   270

{

   271

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

   272

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

   273

}

   274

   275

void AnimateTile(TileIndex tile)

   276

{

   277

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

   278

}

   279

   280

void ClickTile(TileIndex tile)

   281

{

   282

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

   283

}

   284

   285

void GetTileDesc(TileIndex tile, TileDesc *td)

   286

{

   287

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

   288

}

   289

   290

/** Clear a piece of landscape

   291

 * @param tile tile to clear

   292

 * @param p1 unused

   293

 * @param p2 unused

   294

 */

   295

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

   296

{

   297

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   298

   299

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

   300

}

   301

   302

/** Clear a big piece of landscape

   303

 * @param tile end tile of area dragging

   304

 * @param p1 start tile of area dragging

   305

 * @param p2 unused

   306

 */

   307

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

   308

{

   309

	int32 cost, ret, money;

   310

	int ex;

   311

	int ey;

   312

	int sx,sy;

   313

	int x,y;

   314

	bool success = false;

   315

   316

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

   317

   318

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   319

   320

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

   321

	ex = TileX(tile);

   322

	ey = TileY(tile);

   323

	sx = TileX(p1);

   324

	sy = TileY(p1);

   325

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

   326

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

   327

   328

	money = GetAvailableMoneyForCommand();

   329

	cost = 0;

   330

   331

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

   332

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

   333

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

   334

			if (CmdFailed(ret)) continue;

   335

			cost += ret;

   336

			success = true;

   337

   338

			if (flags & DC_EXEC) {

   339

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

   340

					_additional_cash_required = ret;

   341

					return cost - ret;

   342

				}

   343

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

   344

   345

				// draw explosion animation...

   346

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

   347

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

   348

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

   349

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

   350

					);

   351

				}

   352

			}

   353

		}

   354

	}

   355

   356

	return (success) ? cost : CMD_ERROR;

   357

}

   358

   359

   360

#define TILELOOP_BITS 4

   361

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   362

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

   363

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

   364

   365

void RunTileLoop(void)

   366

{

   367

	TileIndex tile;

   368

	uint count;

   369

   370

	tile = _cur_tileloop_tile;

   371

   372

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

   373

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

   374

	do {

   375

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

   376

   377

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

   378

			tile += TILELOOP_SIZE; /* no overflow */

   379

		} else {

   380

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

   381

		}

   382

	} while (--count);

   383

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

   384

   385

	tile += 9;

   386

	if (tile & TILELOOP_CHKMASK)

   387

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

   388

	_cur_tileloop_tile = tile;

   389

}

   390

   391

void InitializeLandscape(void)

   392

{

   393

	uint maxx = MapMaxX();

   394

	uint maxy = MapMaxY();

   395

	uint sizex = MapSizeX();

   396

	uint x;

   397

	uint y;

   398

   399

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

   400

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

   401

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

   402

			SetTileHeight(sizex * y + x, 0);

   403

		}

   404

		MakeVoid(sizex * y + x);

   405

	}

   406

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

   407

}

   408

   409

void ConvertGroundTilesIntoWaterTiles(void)

   410

{

   411

	TileIndex tile;

   412

   413

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

   414

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

   415

			MakeWater(tile);

   416

		}

   417

	}

   418

}

   419

   420

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

   421

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

   422

   423

static void GenerateTerrain(int type, int flag)

   424

{

   425

	uint32 r;

   426

	uint x;

   427

	uint y;

   428

	uint w;

   429

	uint h;

   430

	const Sprite* template;

   431

	const byte *p;

   432

	Tile* tile;

   433

	byte direction;

   434

   435

	r = Random();

   436

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

   437

   438

	x = r & MapMaxX();

   439

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

   440

   441

   442

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

   443

   444

	direction = GB(r, 22, 2);

   445

	if (direction & 1) {

   446

		w = template->height;

   447

		h = template->width;

   448

	} else {

   449

		w = template->width;

   450

		h = template->height;

   451

	}

   452

	p = template->data;

   453

   454

	if (flag & 4) {

   455

		uint xw = x * MapSizeY();

   456

		uint yw = y * MapSizeX();

   457

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

   458

   459

		switch (flag & 3) {

   460

			case 0:

   461

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

   462

				break;

   463

   464

			case 1:

   465

				if (yw < xw + bias) return;

   466

				break;

   467

   468

			case 2:

   469

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

   470

				break;

   471

   472

			case 3:

   473

				if (xw < yw + bias) return;

   474

				break;

   475

		}

   476

	}

   477

   478

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

   479

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

   480

   481

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

   482

   483

	switch (direction) {

   484

		case 0:

   485

			do {

   486

				Tile* tile_cur = tile;

   487

				uint w_cur;

   488

   489

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

   490

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

   491

					p++;

   492

					tile_cur++;

   493

				}

   494

				tile += TileDiffXY(0, 1);

   495

			} while (--h != 0);

   496

			break;

   497