1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.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"

    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

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    59

{

    60

	assert(tile < MapSize());

    61

    62

	ti->tile = tile;

    63

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

    64

	ti->type = GetTileType(tile);

    65

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

    66

}

    67

    68

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

    69

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

    70

{

    71

	ti->x = x;

    72

	ti->y = y;

    73

    74

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

    75

		ti->tileh = 0;

    76

		ti->type = MP_VOID;

    77

		ti->tile = 0;

    78

		ti->map5 = 0;

    79

		ti->z = 0;

    80

		return;

    81

	}

    82

    83

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

    84

}

    85

    86

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

    87

{

    88

	int z = 0;

    89

    90

	switch (corners) {

    91

	case 1:

    92

		if (x - y >= 0)

    93

			z = (x - y) >> 1;

    94

		break;

    95

    96

	case 2:

    97

		y^=0xF;

    98

		if ( (x - y) >= 0)

    99

			z = (x - y) >> 1;

   100

		break;

   101

   102

	case 3:

   103

		z = (x>>1) + 1;

   104

		break;

   105

   106

	case 4:

   107

		if (y - x >= 0)

   108

			z = (y - x) >> 1;

   109

		break;

   110

   111

	case 5:

   112

	case 10:

   113

	case 15:

   114

		z = 4;

   115

		break;

   116

   117

	case 6:

   118

		z = (y>>1) + 1;

   119

		break;

   120

   121

	case 7:

   122

		z = 8;

   123

		y^=0xF;

   124

		if (x - y < 0)

   125

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

   126

		break;

   127

   128

	case 8:

   129

		y ^= 0xF;

   130

		if (y - x >= 0)

   131

			z = (y - x) >> 1;

   132

		break;

   133

   134

	case 9:

   135

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

   136

		break;

   137

   138

	case 11:

   139

		z = 8;

   140

		if (x - y < 0)

   141

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

   142

		break;

   143

   144

	case 12:

   145

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

   146

		break;

   147

   148

	case 13:

   149

		z = 8;

   150

		y ^= 0xF;

   151

		if (y - x < 0)

   152

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

   153

		break;

   154

   155

	case 14:

   156

		z = 8;

   157

		if (y - x < 0)

   158

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

   159

		break;

   160

   161

	case 23:

   162

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

   163

		break;

   164

   165

	case 27:

   166

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

   167

		break;

   168

   169

	case 29:

   170

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

   171

		break;

   172

   173

	case 30:

   174

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

   175

		break;

   176

	}

   177

   178

	return z;

   179

}

   180

   181

uint GetSlopeZ(int x, int y)

   182

{

   183

	TileInfo ti;

   184

   185

	FindLandscapeHeight(&ti, x, y);

   186

   187

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

   188

}

   189

   190

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

   191

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

   192

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

   193

{

   194

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

   195

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

   196

	uint tileh = ti->tileh;

   197

   198

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

   199

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

   200

   201

	if (direction) {

   202

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

   203

	} else {

   204

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

   205

	}

   206

	return south || other;

   207

}

   208

   209

void DrawFoundation(TileInfo *ti, uint f)

   210

{

   211

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   212

   213

	TileInfo ti2;

   214

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

   215

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

   216

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

   217

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

   218

   219

	if (f < 15) {

   220

		// leveled foundation

   221

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

   222

   223

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

   224

		ti->z += 8;

   225

		ti->tileh = 0;

   226

		OffsetGroundSprite(31, 1);

   227

	} else {

   228

		// inclined foundation

   229

		sprite_base += 14;

   230

   231

		AddSortableSpriteToDraw(

   232

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

   233

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

   234

		);

   235

   236

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

   237

		OffsetGroundSprite(31, 9);

   238

	}

   239

}

   240

   241

void DoClearSquare(TileIndex tile)

   242

{

   243

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

   244

	MarkTileDirtyByTile(tile);

   245

}

   246

   247

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   248

{

   249

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

   250

}

   251

   252

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

   253

{

   254

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

   255

}

   256

   257

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   258

{

   259

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

   260

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

   261

}

   262

   263

void AnimateTile(TileIndex tile)

   264

{

   265

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

   266

}

   267

   268

void ClickTile(TileIndex tile)

   269

{

   270

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

   271

}

   272

   273

void DrawTile(TileInfo *ti)

   274

{

   275

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

   276

}

   277

   278

void GetTileDesc(TileIndex tile, TileDesc *td)

   279

{

   280

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

   281

}

   282

   283

/** Clear a piece of landscape

   284

 * @param x,y coordinates of clearance

   285

 * @param p1 unused

   286

 * @param p2 unused

   287

 */

   288

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

   289

{

   290

	TileIndex tile = TileVirtXY(x, y);

   291

   292

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   293

   294

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

   295

}

   296

   297

/** Clear a big piece of landscape

   298

 * @param x,y end coordinates of area dragging

   299

 * @param p1 start tile of area dragging

   300

 * @param p2 unused

   301

 */

   302

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

   303

{

   304

	int32 cost, ret, money;

   305

	int sx,sy;

   306

	int x,y;

   307

	bool success = false;

   308

   309

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

   310

   311

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   312

   313

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

   314

	sx = TileX(p1) * 16;

   315

	sy = TileY(p1) * 16;

   316

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

   317

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

   318

   319

	money = GetAvailableMoneyForCommand();

   320

	cost = 0;

   321

   322

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

   323

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

   324

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

   325

			if (CmdFailed(ret)) continue;

   326

			cost += ret;

   327

			success = true;

   328

   329

			if (flags & DC_EXEC) {

   330

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

   331

					_additional_cash_required = ret;

   332

					return cost - ret;

   333

				}

   334

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

   335

   336

				// draw explosion animation...

   337

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

   338

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

   339

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

   340

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

   341

					);

   342

				}

   343

			}

   344

		}

   345

	}

   346

   347

	return (success) ? cost : CMD_ERROR;

   348

}

   349

   350

   351

/* utility function used to modify a tile */

   352

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

   353

{

   354

	va_list va;

   355

	int i;

   356

   357

	va_start(va, flags);

   358

   359

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

   360

		SetTileType(tile, i - 1);

   361

	}

   362

   363

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   364

		int x = 0;

   365

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

   366

		_m[tile].m2 = x;

   367

	}

   368

   369

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   370

		int x = 0;

   371

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

   372

		_m[tile].m3 = x;

   373

	}

   374

   375

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   376

		int x = 0;

   377

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

   378

		_m[tile].m4 = x;

   379

	}

   380

   381

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   382

		PlayerID x = _current_player;

   383

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

   384

		_m[tile].m1 = x;

   385

	}

   386

   387

	if (flags & MP_MAP5) {

   388

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

   389

	}

   390

   391

	va_end(va);

   392

   393

	if (!(flags & MP_NODIRTY))

   394

		MarkTileDirtyByTile(tile);

   395

}

   396

   397

   398

#define TILELOOP_BITS 4

   399

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   400

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

   401

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

   402

   403

void RunTileLoop(void)

   404

{

   405

	TileIndex tile;

   406

	uint count;

   407

   408

	tile = _cur_tileloop_tile;

   409

   410

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

   411

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

   412

	do {

   413

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

   414

   415

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

   416

			tile += TILELOOP_SIZE; /* no overflow */

   417

		} else {

   418

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

   419

		}

   420

	} while (--count);

   421

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

   422

   423

	tile += 9;

   424

	if (tile & TILELOOP_CHKMASK)

   425

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

   426

	_cur_tileloop_tile = tile;

   427

}

   428

   429

void InitializeLandscape(void)

   430

{

   431

	uint maxx = MapMaxX();

   432

	uint maxy = MapMaxY();

   433

	uint sizex = MapSizeX();

   434

	uint x;

   435

	uint y;

   436

   437

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

   438

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

   439

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

   440

			SetTileHeight(sizex * y + x, 0);

   441

		}

   442

		MakeVoid(sizex * y + x);

   443

	}

   444

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

   445

}

   446

   447

void ConvertGroundTilesIntoWaterTiles(void)

   448

{

   449

	TileIndex tile = 0;

   450

	uint h;

   451

   452

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

   453

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

   454

			MakeWater(tile);

   455

		}

   456

	}

   457

}

   458

   459

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

   460

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

   461

   462

static void GenerateTerrain(int type, int flag)

   463

{

   464

	uint32 r;

   465

	uint x;

   466

	uint y;

   467

	uint w;

   468

	uint h;

   469

	const Sprite* template;

   470

	const byte *p;

   471

	Tile* tile;

   472

	byte direction;

   473

   474

	r = Random();

   475

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

   476

   477

	x = r & MapMaxX();

   478

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

   479

   480

   481

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

   482

   483

	direction = GB(r, 22, 2);

   484

	if (direction & 1) {

   485

		w = template->height;

   486

		h = template->width;

   487

	} else {

   488

		w = template->width;

   489

		h = template->height;

   490

	}

   491

	p = template->data;

   492

   493

	if (flag & 4) {

   494

		uint xw = x * MapSizeY();

   495

		uint yw = y * MapSizeX();

   496

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

   497

   498

		switch (flag & 3) {

   499

			case 0:

   500

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

   501

				break;

   502

   503

			case 1:

   504

				if (yw < xw + bias) return;