1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "functions.h"

     6

#include "map.h"

     7

#include "player.h"

     8

#include "spritecache.h"

     9

#include "table/sprites.h"

    10

#include "tile.h"

    11

#include <stdarg.h>

    12

#include "viewport.h"

    13

#include "command.h"

    14

#include "vehicle.h"

    15

#include "variables.h"

    16

    17

extern const TileTypeProcs

    18

	_tile_type_clear_procs,

    19

	_tile_type_rail_procs,

    20

	_tile_type_road_procs,

    21

	_tile_type_town_procs,

    22

	_tile_type_trees_procs,

    23

	_tile_type_station_procs,

    24

	_tile_type_water_procs,

    25

	_tile_type_dummy_procs,

    26

	_tile_type_industry_procs,

    27

	_tile_type_tunnelbridge_procs,

    28

	_tile_type_unmovable_procs;

    29

    30

const TileTypeProcs * const _tile_type_procs[16] = {

    31

	&_tile_type_clear_procs,

    32

	&_tile_type_rail_procs,

    33

	&_tile_type_road_procs,

    34

	&_tile_type_town_procs,

    35

	&_tile_type_trees_procs,

    36

	&_tile_type_station_procs,

    37

	&_tile_type_water_procs,

    38

	&_tile_type_dummy_procs,

    39

	&_tile_type_industry_procs,

    40

	&_tile_type_tunnelbridge_procs,

    41

	&_tile_type_unmovable_procs,

    42

};

    43

    44

/* landscape slope => sprite */

    45

const byte _tileh_to_sprite[32] = {

    46

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

    47

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

    48

};

    49

    50

const byte _inclined_tileh[] = {

    51

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

    52

};

    53

    54

    55

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    56

{

    57

	assert(tile < MapSize());

    58

    59

	ti->tile = tile;

    60

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

    61

	ti->type = GetTileType(tile);

    62

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

    63

}

    64

    65

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

    66

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

    67

{

    68

	ti->x = x;

    69

	ti->y = y;

    70

    71

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

    72

		ti->tileh = 0;

    73

		ti->type = MP_VOID;

    74

		ti->tile = 0;

    75

		ti->map5 = 0;

    76

		ti->z = 0;

    77

		return;

    78

	}

    79

    80

	FindLandscapeHeightByTile(ti, TileVirtXY(x, y));

    81

}

    82

    83

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

    84

{

    85

	int z = 0;

    86

    87

	switch(corners) {

    88

	case 1:

    89

		if (x - y >= 0)

    90

			z = (x - y) >> 1;

    91

		break;

    92

    93

	case 2:

    94

		y^=0xF;

    95

		if ( (x - y) >= 0)

    96

			z = (x - y) >> 1;

    97

		break;

    98

    99

	case 3:

   100

		z = (x>>1) + 1;

   101

		break;

   102

   103

	case 4:

   104

		if (y - x >= 0)

   105

			z = (y - x) >> 1;

   106

		break;

   107

   108

	case 5:

   109

	case 10:

   110

	case 15:

   111

		z = 4;

   112

		break;

   113

   114

	case 6:

   115

		z = (y>>1) + 1;

   116

		break;

   117

   118

	case 7:

   119

		z = 8;

   120

		y^=0xF;

   121

		if (x - y < 0)

   122

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

   123

		break;

   124

   125

	case 8:

   126

		y ^= 0xF;

   127

		if (y - x >= 0)

   128

			z = (y - x) >> 1;

   129

		break;

   130

   131

	case 9:

   132

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

   133

		break;

   134

   135

	case 11:

   136

		z = 8;

   137

		if (x - y < 0)

   138

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

   139

		break;

   140

   141

	case 12:

   142

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

   143

		break;

   144

   145

	case 13:

   146

		z = 8;

   147

		y ^= 0xF;

   148

		if (y - x < 0)

   149

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

   150

		break;

   151

   152

	case 14:

   153

		z = 8;

   154

		if (y - x < 0)

   155

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

   156

		break;

   157

   158

	case 23:

   159

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

   160

		break;

   161

   162

	case 27:

   163

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

   164

		break;

   165

   166

	case 29:

   167

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

   168

		break;

   169

   170

	case 30:

   171

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

   172

		break;

   173

	}

   174

   175

	return z;

   176

}

   177

   178

uint GetSlopeZ(int x,  int y)

   179

{

   180

	TileInfo ti;

   181

   182

	FindLandscapeHeight(&ti, x, y);

   183

   184

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

   185

}

   186

   187

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

   188

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

   189

static bool hasFoundation(const TileInfo* ti, bool direction)

   190

{

   191

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

   192

	uint slope = _tile_type_procs[ti->type]->get_slope_tileh_proc(ti);

   193

	uint tileh = ti->tileh;

   194

   195

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

   196

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

   197

   198

	if (direction) {

   199

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

   200

	} else {

   201

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

   202

	}

   203

	return south || other;

   204

}

   205

   206

void DrawFoundation(TileInfo *ti, uint f)

   207

{

   208

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   209

   210

	TileInfo ti2;

   211

	FindLandscapeHeight(&ti2, ti->x, ti->y - 1);

   212

	if (hasFoundation(&ti2, true)) sprite_base += 22;		// foundation in NW direction

   213

	FindLandscapeHeight(&ti2, ti->x - 1, ti->y);

   214

	if (hasFoundation(&ti2, false)) sprite_base += 22 * 2;	// foundation in NE direction

   215

   216

	if (f < 15) {

   217

		// leveled foundation

   218

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

   219

   220

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

   221

		ti->z += 8;

   222

		ti->tileh = 0;

   223

		OffsetGroundSprite(31, 1);

   224

	} else {

   225

		// inclined foundation

   226

		sprite_base += 14;

   227

   228

		AddSortableSpriteToDraw(

   229

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

   230

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

   231

		);

   232

   233

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

   234

		OffsetGroundSprite(31, 9);

   235

	}

   236

}

   237

   238

void DoClearSquare(TileIndex tile)

   239

{

   240

	ModifyTile(tile,

   241

		MP_SETTYPE(MP_CLEAR) |

   242

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   243

		OWNER_NONE, /* map_owner */

   244

		_generating_world ? 3 : 0 /* map5 */

   245

	);

   246

}

   247

   248

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   249

{

   250

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

   251

}

   252

   253

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

   254

{

   255

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

   256

}

   257

   258

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   259

{

   260

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

   261

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

   262

}

   263

   264

void AnimateTile(TileIndex tile)

   265

{

   266

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

   267

}

   268

   269

void ClickTile(TileIndex tile)

   270

{

   271

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

   272

}

   273

   274

void DrawTile(TileInfo *ti)

   275

{

   276

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

   277

}

   278

   279

void GetTileDesc(TileIndex tile, TileDesc *td)

   280

{

   281

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

   282

}

   283

   284

/** Clear a piece of landscape

   285

 * @param x,y coordinates of clearance

   286

 * @param p1 unused

   287

 * @param p2 unused

   288

 */

   289

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

   290

{

   291

	TileIndex tile = TileVirtXY(x, y);

   292

   293

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   294

   295

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

   296

}

   297

   298

/** Clear a big piece of landscape

   299

 * @param x,y end coordinates of area dragging

   300

 * @param p1 start tile of area dragging

   301

 * @param p2 unused

   302

 */

   303

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

   304

{

   305

	int32 cost, ret, money;

   306

	int sx,sy;

   307

	int x,y;

   308

	bool success = false;

   309

   310

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

   311

   312

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   313

   314

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

   315

	sx = TileX(p1) * 16;

   316

	sy = TileY(p1) * 16;

   317

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

   318

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

   319

   320

	money = GetAvailableMoneyForCommand();

   321

	cost = 0;

   322

   323

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

   324

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

   325

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

   326

			if (CmdFailed(ret)) continue;

   327

			cost += ret;

   328

			success = true;

   329

   330

			if (flags & DC_EXEC) {

   331

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

   332

					_additional_cash_required = ret;

   333

					return cost - ret;

   334

				}

   335

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

   336

   337

				// draw explosion animation...

   338

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

   339

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

   340

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

   341

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

   342

					);

   343

				}

   344

			}

   345

		}

   346

	}

   347

   348

	return (success) ? cost : CMD_ERROR;

   349

}

   350

   351

   352

/* utility function used to modify a tile */

   353

void CDECL ModifyTile(TileIndex tile, uint flags, ...)

   354

{

   355

	va_list va;

   356

	int i;

   357

   358

	va_start(va, flags);

   359

   360

	if ((i = GB(flags, 8, 4)) != 0) {

   361

		SetTileType(tile, i - 1);

   362

	}

   363

   364

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   365

		int x = 0;

   366

		if (flags & MP_MAP2) x = va_arg(va, int);

   367

		_m[tile].m2 = x;

   368

	}

   369

   370

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   371

		int x = 0;

   372

		if (flags & MP_MAP3LO) x = va_arg(va, int);

   373

		_m[tile].m3 = x;

   374

	}

   375

   376

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   377

		int x = 0;

   378

		if (flags & MP_MAP3HI) x = va_arg(va, int);

   379

		_m[tile].m4 = x;

   380

	}

   381

   382

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   383

		PlayerID x = _current_player;

   384

		if (flags & MP_MAPOWNER) x = va_arg(va, int);

   385

		_m[tile].m1 = x;

   386

	}

   387

   388

	if (flags & MP_MAP5) {

   389

		_m[tile].m5 = va_arg(va, int);

   390

	}

   391

   392

	va_end(va);

   393

   394

	if (!(flags & MP_NODIRTY))

   395

		MarkTileDirtyByTile(tile);

   396

}

   397

   398

   399

#define TILELOOP_BITS 4

   400

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   401

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

   402

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

   403

   404

void RunTileLoop(void)

   405

{

   406

	TileIndex tile;

   407

	uint count;

   408

   409

	tile = _cur_tileloop_tile;

   410

   411

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

   412

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

   413

	do {

   414

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

   415

   416

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

   417

			tile += TILELOOP_SIZE; /* no overflow */

   418

		} else {

   419

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

   420

		}

   421

	} while (--count);

   422

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

   423

   424

	tile += 9;

   425

	if (tile & TILELOOP_CHKMASK)

   426

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

   427

	_cur_tileloop_tile = tile;

   428

}

   429

   430

void InitializeLandscape(void)

   431

{

   432

	uint map_size;

   433

	uint i;

   434

   435

   436

	map_size = MapSize();

   437

	for (i = 0; i < map_size; i++) {

   438

		_m[i].type_height = MP_CLEAR << 4;

   439

		_m[i].m1          = OWNER_NONE;

   440

		_m[i].m2          = 0;

   441

		_m[i].m3          = 0;

   442

		_m[i].m4          = 0;

   443

		_m[i].m5          = 3;

   444

		_m[i].extra       = 0;

   445

	}

   446

   447

	// create void tiles at the border

   448

	for (i = 0; i < MapMaxY(); ++i)

   449

		SetTileType(i * MapSizeX() + MapMaxX(), MP_VOID);

   450

	for (i = 0; i < MapSizeX(); ++i)

   451

		SetTileType(MapSizeX() * MapMaxY() + i, MP_VOID);

   452

}

   453

   454

void ConvertGroundTilesIntoWaterTiles(void)

   455

{

   456

	TileIndex tile = 0;

   457

	uint h;

   458

   459

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

   460

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

   461

			SetTileType(tile, MP_WATER);

   462

			_m[tile].m5 = 0;

   463

			SetTileOwner(tile, OWNER_WATER);

   464

		}

   465

	}

   466

}

   467

   468

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

   469

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

   470

   471

static void GenerateTerrain(int type, int flag)

   472

{

   473

	uint32 r;

   474

	uint x;

   475

	uint y;

   476

	uint w;

   477

	uint h;

   478

	const Sprite* template;

   479

	const byte *p;

   480

	Tile* tile;

   481

	byte direction;

   482

   483

	r = Random();

   484

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

   485

   486

	x = r & MapMaxX();

   487

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

   488

   489

   490

	if (x < 2 || y < 2)

   491

		return;

   492

   493

	direction = GB(r, 22, 2);

   494

	if (direction & 1) {

   495

		w = template->height;

   496

		h = template->width;

   497

	} else {

   498

		w = template->width;

   499

		h = template->height;

   500

	}

   501

	p = template->data;

   502

   503

	if (flag & 4) {

   504

		uint xw = x * MapSizeY();

   505

		uint yw = y * MapSizeX();