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

	3, 9, 3, 6, 12, 6, 12, 9

    55

};

    56

    57

    58

/* find the landscape height for the coordinates x y */

    59

void FindLandscapeHeight(TileInfo *ti, uint x, uint y)

    60

{

    61

	ti->x = x;

    62

	ti->y = y;

    63

    64

	if (x >= MapMaxX() * TILE_SIZE - 1 || y >= MapMaxY() * TILE_SIZE - 1) {

    65

		ti->tileh = 0;

    66

		ti->type = MP_VOID;

    67

		ti->tile = 0;

    68

		ti->map5 = 0;

    69

		ti->z = 0;

    70

	} else {

    71

		TileIndex tile = TileVirtXY(x, y);

    72

    73

		ti->tile = tile;

    74

		ti->type = GetTileType(tile);

    75

		ti->map5 = _m[tile].m5;

    76

		ti->tileh = GetTileSlope(tile, &ti->z);

    77

	}

    78

}

    79

    80

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

    81

{

    82

	int z = 0;

    83

    84

	switch (corners) {

    85

	case 1:

    86

		if (x - y >= 0)

    87

			z = (x - y) >> 1;

    88

		break;

    89

    90

	case 2:

    91

		y^=0xF;

    92

		if ( (x - y) >= 0)

    93

			z = (x - y) >> 1;

    94

		break;

    95

    96

	case 3:

    97

		z = (x>>1) + 1;

    98

		break;

    99

   100

	case 4:

   101

		if (y - x >= 0)

   102

			z = (y - x) >> 1;

   103

		break;

   104

   105

	case 5:

   106

	case 10:

   107

	case 15:

   108

		z = 4;

   109

		break;

   110

   111

	case 6:

   112

		z = (y>>1) + 1;

   113

		break;

   114

   115

	case 7:

   116

		z = 8;

   117

		y^=0xF;

   118

		if (x - y < 0)

   119

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

   120

		break;

   121

   122

	case 8:

   123

		y ^= 0xF;

   124

		if (y - x >= 0)

   125

			z = (y - x) >> 1;

   126

		break;

   127

   128

	case 9:

   129

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

   130

		break;

   131

   132

	case 11:

   133

		z = 8;

   134

		if (x - y < 0)

   135

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

   136

		break;

   137

   138

	case 12:

   139

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

   140

		break;

   141

   142

	case 13:

   143

		z = 8;

   144

		y ^= 0xF;

   145

		if (y - x < 0)

   146

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

   147

		break;

   148

   149

	case 14:

   150

		z = 8;

   151

		if (y - x < 0)

   152

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

   153

		break;

   154

   155

	case 23:

   156

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

   157

		break;

   158

   159

	case 27:

   160

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

   161

		break;

   162

   163

	case 29:

   164

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

   165

		break;

   166

   167

	case 30:

   168

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

   169

		break;

   170

	}

   171

   172

	return z;

   173

}

   174

   175

uint GetSlopeZ(int x, int y)

   176

{

   177

	TileInfo ti;

   178

   179

	FindLandscapeHeight(&ti, x, y);

   180

   181

	return _tile_type_procs[ti.type]->get_slope_z_proc(&ti);

   182

}

   183

   184

// direction=true:  check for foundation in east and south corner

   185

// direction=false: check for foundation in west and south corner

   186

static bool HasFoundation(TileIndex tile, bool direction)

   187

{

   188

	bool south, other; // southern corner and east/west corner

   189

	uint tileh = GetTileSlope(tile, NULL);

   190

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

   191

   192

	if (slope == 0 && slope != tileh) tileh = 15;

   193

	south = (tileh & 2) != (slope & 2);

   194

   195

	if (direction) {

   196

		other = (tileh & 4) != (slope & 4);

   197

	} else {

   198

		other = (tileh & 1) != (slope & 1);

   199

	}

   200

	return south || other;

   201

}

   202

   203

void DrawFoundation(TileInfo *ti, uint f)

   204

{

   205

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   206

   207

	if (HasFoundation(TILE_ADDXY(ti->tile, 0, -1), true)) sprite_base += 22; // foundation in NW direction

   208

	if (HasFoundation(TILE_ADDXY(ti->tile, -1, 0), false)) sprite_base += 44; // foundation in NE direction

   209

   210

	if (f < 15) {

   211

		// leveled foundation

   212

		if (sprite_base < SPR_SLOPES_BASE) sprite_base = SPR_FOUNDATION_BASE + 1; // use original slope sprites

   213

   214

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

   215

		ti->z += 8;

   216

		ti->tileh = 0;

   217

		OffsetGroundSprite(31, 1);

   218

	} else {

   219

		// inclined foundation

   220

		sprite_base += 14;

   221

   222

		AddSortableSpriteToDraw(

   223

			HASBIT((1<<1) | (1<<2) | (1<<4) | (1<<8), ti->tileh) ? sprite_base + (f - 15) : SPR_FOUNDATION_BASE + ti->tileh,

   224

			ti->x, ti->y, 1, 1, 1, ti->z

   225

		);

   226

   227

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

   228

		OffsetGroundSprite(31, 9);

   229

	}

   230

}

   231

   232

void DoClearSquare(TileIndex tile)

   233

{

   234

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

   235

	MarkTileDirtyByTile(tile);

   236

}

   237

   238

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   239

{

   240

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

   241

}

   242

   243

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

   244

{

   245

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

   246

}

   247

   248

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   249

{

   250

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

   251

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

   252

}

   253

   254

void AnimateTile(TileIndex tile)

   255

{

   256

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

   257

}

   258

   259

void ClickTile(TileIndex tile)

   260

{

   261

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

   262

}

   263

   264

void DrawTile(TileInfo *ti)

   265

{

   266

	_tile_type_procs[ti->type]->draw_tile_proc(ti);

   267

}

   268

   269

void GetTileDesc(TileIndex tile, TileDesc *td)

   270

{

   271

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

   272

}

   273

   274

/** Clear a piece of landscape

   275

 * @param x,y coordinates of clearance

   276

 * @param p1 unused

   277

 * @param p2 unused

   278

 */

   279

int32 CmdLandscapeClear(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   280

{

   281

	TileIndex tile = TileVirtXY(x, y);

   282

   283

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   284

   285

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

   286

}

   287

   288

/** Clear a big piece of landscape

   289

 * @param x,y end coordinates of area dragging

   290

 * @param p1 start tile of area dragging

   291

 * @param p2 unused

   292

 */

   293

int32 CmdClearArea(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)

   294

{

   295

	int32 cost, ret, money;

   296

	int sx,sy;

   297

	int x,y;

   298

	bool success = false;

   299

   300

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

   301

   302

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   303

   304

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

   305

	sx = TileX(p1) * TILE_SIZE;

   306

	sy = TileY(p1) * TILE_SIZE;

   307

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

   308

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

   309

   310

	money = GetAvailableMoneyForCommand();

   311

	cost = 0;

   312

   313

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

   314

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

   315

			ret = DoCommandByTile(TileVirtXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);

   316

			if (CmdFailed(ret)) continue;

   317

			cost += ret;

   318

			success = true;

   319

   320

			if (flags & DC_EXEC) {

   321

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

   322

					_additional_cash_required = ret;

   323

					return cost - ret;

   324

				}

   325

				DoCommandByTile(TileVirtXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   326

   327

				// draw explosion animation...

   328

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

   329

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

   330

					CreateEffectVehicleAbove(x + 8, y + 8, 2,

   331

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

   332

					);

   333

				}

   334

			}

   335

		}

   336

	}

   337

   338

	return (success) ? cost : CMD_ERROR;

   339

}

   340

   341

   342

#define TILELOOP_BITS 4

   343

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   344

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

   345

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

   346

   347

void RunTileLoop(void)

   348

{

   349

	TileIndex tile;

   350

	uint count;

   351

   352

	tile = _cur_tileloop_tile;

   353

   354

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

   355

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

   356

	do {

   357

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

   358

   359

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

   360

			tile += TILELOOP_SIZE; /* no overflow */

   361

		} else {

   362

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

   363

		}

   364

	} while (--count);

   365

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

   366

   367

	tile += 9;

   368

	if (tile & TILELOOP_CHKMASK)

   369

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

   370

	_cur_tileloop_tile = tile;

   371

}

   372

   373

void InitializeLandscape(void)

   374

{

   375

	uint maxx = MapMaxX();

   376

	uint maxy = MapMaxY();

   377

	uint sizex = MapSizeX();

   378

	uint x;

   379

	uint y;

   380

   381

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

   382

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

   383

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

   384

			SetTileHeight(sizex * y + x, 0);

   385

		}

   386

		MakeVoid(sizex * y + x);

   387

	}

   388

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

   389

}

   390

   391

void ConvertGroundTilesIntoWaterTiles(void)

   392

{

   393

	TileIndex tile = 0;

   394

	uint h;

   395

   396

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

   397

		if (IsTileType(tile, MP_CLEAR) && GetTileSlope(tile, &h) == 0 && h == 0) {

   398

			MakeWater(tile);

   399

		}

   400

	}

   401

}

   402

   403

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

   404

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

   405

   406

static void GenerateTerrain(int type, int flag)

   407

{

   408

	uint32 r;

   409

	uint x;

   410

	uint y;

   411

	uint w;

   412

	uint h;

   413

	const Sprite* template;

   414

	const byte *p;

   415

	Tile* tile;

   416

	byte direction;

   417

   418

	r = Random();

   419

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

   420

   421

	x = r & MapMaxX();

   422

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

   423

   424

   425

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

   426

   427

	direction = GB(r, 22, 2);

   428

	if (direction & 1) {

   429

		w = template->height;

   430

		h = template->width;

   431

	} else {

   432

		w = template->width;

   433

		h = template->height;

   434

	}

   435

	p = template->data;

   436

   437

	if (flag & 4) {

   438

		uint xw = x * MapSizeY();

   439

		uint yw = y * MapSizeX();

   440

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

   441

   442

		switch (flag & 3) {

   443

			case 0:

   444

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

   445

				break;

   446

   447

			case 1:

   448

				if (yw < xw + bias) return;

   449

				break;

   450

   451

			case 2:

   452

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

   453

				break;

   454

   455

			case 3:

   456

				if (xw < yw + bias) return;

   457

				break;

   458

		}

   459

	}

   460

   461

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

   462

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

   463

   464

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

   465

   466

	switch (direction) {

   467

		case 0:

   468

			do {

   469

				Tile* tile_cur = tile;

   470

				uint w_cur;

   471

   472

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

   473

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

   474

					p++;

   475

					tile_cur++;

   476

				}

   477

				tile += TileDiffXY(0, 1);

   478

			} while (--h != 0);

   479

			break;

   480

   481

		case 1:

   482

			do {

   483

				Tile* tile_cur = tile;

   484

				uint h_cur;

   485

   486

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

   487

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

   488

					p++;

   489

					tile_cur += TileDiffXY(0, 1);

   490

				}

   491

				tile++;

   492

			} while (--w != 0);

   493

			break;

   494

   495

		case 2:

   496

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

   497

			do {

   498

				Tile* tile_cur = tile;

   499

				uint w_cur;

   500

   501

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