1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "map.h"

     4

#include "spritecache.h"

     5

#include "table/sprites.h"

     6

#include "tile.h"

     7

#include <stdarg.h>

     8

#include "gfx.h"

     9

#include "viewport.h"

    10

#include "command.h"

    11

#include "vehicle.h"

    12

    13

extern const TileTypeProcs

    14

	_tile_type_clear_procs,

    15

	_tile_type_rail_procs,

    16

	_tile_type_road_procs,

    17

	_tile_type_town_procs,

    18

	_tile_type_trees_procs,

    19

	_tile_type_station_procs,

    20

	_tile_type_water_procs,

    21

	_tile_type_dummy_procs,

    22

	_tile_type_industry_procs,

    23

	_tile_type_tunnelbridge_procs,

    24

	_tile_type_unmovable_procs;

    25

    26

const TileTypeProcs * const _tile_type_procs[16] = {

    27

	&_tile_type_clear_procs,

    28

	&_tile_type_rail_procs,

    29

	&_tile_type_road_procs,

    30

	&_tile_type_town_procs,

    31

	&_tile_type_trees_procs,

    32

	&_tile_type_station_procs,

    33

	&_tile_type_water_procs,

    34

	&_tile_type_dummy_procs,

    35

	&_tile_type_industry_procs,

    36

	&_tile_type_tunnelbridge_procs,

    37

	&_tile_type_unmovable_procs,

    38

};

    39

    40

/* landscape slope => sprite */

    41

const byte _tileh_to_sprite[32] = {

    42

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

    43

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

    44

};

    45

    50

    51

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    52

{

    53

	assert(tile < MapSize());

    54

    55

	ti->tile = tile;

    56

	ti->map5 = _map5[tile];

    57

	ti->type = GetTileType(tile);

    58

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

    59

}

    60

    61

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

    62

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

    63

{

    64

	ti->x = x;

    65

	ti->y = y;

    66

    67

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

    68

		ti->tileh = 0;

    69

		ti->type = MP_VOID;

    70

		ti->tile = 0;

    71

		ti->map5 = 0;

    72

		ti->z = 0;

    73

		return;

    74

	}

    75

    76

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

    77

}

    78

    79

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

    80

{

    81

	int z = 0;

    82

    83

	switch(corners) {

    84

	case 1:

    85

		if (x - y >= 0)

    86

			z = (x - y) >> 1;

    87

		break;

    88

    89

	case 2:

    90

		y^=0xF;

    91

		if ( (x - y) >= 0)

    92

			z = (x - y) >> 1;

    93

		break;

    94

    95

	case 3:

    96

		z = (x>>1) + 1;

    97

		break;

    98

    99

	case 4:

   100

		if (y - x >= 0)

   101

			z = (y - x) >> 1;

   102

		break;

   103

   104

	case 5:

   105

	case 10:

   106

	case 15:

   107

		z = 4;

   108

		break;

   109

   110

	case 6:

   111

		z = (y>>1) + 1;

   112

		break;

   113

   114

	case 7:

   115

		z = 8;

   116

		y^=0xF;

   117

		if (x - y < 0)

   118

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

   119

		break;

   120

   121

	case 8:

   122

		y ^= 0xF;

   123

		if (y - x >= 0)

   124

			z = (y - x) >> 1;

   125

		break;

   126

   127

	case 9:

   128

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

   129

		break;

   130

   131

	case 11:

   132

		z = 8;

   133

		if (x - y < 0)

   134

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

   135

		break;

   136

   137

	case 12:

   138

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

   139

		break;

   140

   141

	case 13:

   142

		z = 8;

   143

		y ^= 0xF;

   144

		if (y - x < 0)

   145

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

   146

		break;

   147

   148

	case 14:

   149

		z = 8;

   150

		if (y - x < 0)

   151

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

   152

		break;

   153

   154

	case 23:

   155

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

   156

		break;

   157

   158

	case 27:

   159

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

   160

		break;

   161

   162

	case 29:

   163

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

   164

		break;

   165

   166

	case 30:

   167

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

   168

		break;

   169

	}

   170

   171

	return z;

   172

}

   173

   174

uint GetSlopeZ(int x,  int y)

   175

{

   176

	TileInfo ti;

   177

   178

	FindLandscapeHeight(&ti, x, y);

   179

   180

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

   181

}

   182

   183

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

   184

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

   185

static bool hasFoundation(TileInfo *ti, bool direction)

   186

{

   187

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

   188

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

   189

	uint tileh = ti->tileh;

   190

   191

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

   192

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

   193

   194

	if(direction)

   195

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

   196

	else

   197

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

   198

	return south || other;

   199

   200

}

   201

   202

void DrawFoundation(TileInfo *ti, uint f)

   203

{

   204

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   205

   206

	TileInfo ti2;

   207

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

   208

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

   209

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

   210

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

   211

   212

	if (f < 15) {

   213

		// leveled foundation

   214

		if( sprite_base < SPR_SLOPES_BASE ) sprite_base = 990; // use original slope sprites

   215

   216

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

   217

		ti->z += 8;

   218

		ti->tileh = 0;

   219

		OffsetGroundSprite(31, 1);

   220

	} else {

   221

		// inclined foundation

   222

		sprite_base += 14;

   223

   224

		AddSortableSpriteToDraw(

   225

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

   226

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

   227

		);

   228

   229

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

   230

		OffsetGroundSprite(31, 9);

   231

	}

   232

}

   233

   234

void DoClearSquare(TileIndex tile)

   235

{

   236

	ModifyTile(tile,

   237

		MP_SETTYPE(MP_CLEAR) |

   238

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   239

		OWNER_NONE, /* map_owner */

   240

		_generating_world ? 3 : 0 /* map5 */

   241

	);

   242

}

   243

   244

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   245

{

   246

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

   247

}

   248

   249

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

   250

{

   251

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

   252

}

   253

   254

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   255

{

   256

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

   257

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

   258

}

   259

   260

void AnimateTile(TileIndex tile)

   261

{

   262

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

   263

}

   264

   265

void ClickTile(TileIndex tile)

   266

{

   267

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

   268

}

   269

   270

void DrawTile(TileInfo *ti)

   271

{

   272

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

   273

}

   274

   275

void GetTileDesc(TileIndex tile, TileDesc *td)

   276

{

   277

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

   278

}

   279

   280

/** Clear a piece of landscape

   281

 * @param x,y coordinates of clearance

   282

 * @param p1 unused

   283

 * @param p2 unused

   284

 */

   285

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

   286

{

   287

	TileIndex tile = TILE_FROM_XY(x, y);

   288

   289

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   290

   291

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

   292

}

   293

   294

/** Clear a big piece of landscape

   295

 * @param x,y end coordinates of area dragging

   296

 * @param p1 start tile of area dragging

   297

 * @param p2 unused

   298

 */

   299

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

   300

{

   301

	int32 cost, ret, money;

   302

	int sx,sy;

   303

	int x,y;

   304

	bool success = false;

   305

   306

	if (p1 > MapSize()) return CMD_ERROR;

   307

   308

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   309

   310

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

   311

	sx = TileX(p1) * 16;

   312

	sy = TileY(p1) * 16;

   313

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

   314

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

   315

   316

	money = GetAvailableMoneyForCommand();

   317

	cost = 0;

   318

   319

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

   320

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

   321

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

   322

			if (CmdFailed(ret)) continue;

   323

			cost += ret;

   324

			success = true;

   325

   326

			if (flags & DC_EXEC) {

   327

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

   328

					_additional_cash_required = ret;

   329

					return cost - ret;

   330

				}

   331

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

   332

   333

				// draw explosion animation...

   334

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

   335

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

   336

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

   337

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

   338

					);

   339

				}

   340

			}

   341

		}

   342

	}

   343

   344

	return (success) ? cost : CMD_ERROR;

   345

}

   346

   347

   348

/* utility function used to modify a tile */

   349

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

   350

{

   351

	va_list va;

   352

	int i;

   353

   354

	va_start(va, flags);

   355

   356

	if ((i = (flags >> 8) & 0xF) != 0) {

   357

		SetTileType(tile, i - 1);

   358

	}

   359

   360

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   361

		int x = 0;

   362

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

   363

		_map2[tile] = x;

   364

	}

   365

   366

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   367

		int x = 0;

   368

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

   369

		_map3_lo[tile] = x;

   370

	}

   371

   372

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   373

		int x = 0;

   374

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

   375

		_map3_hi[tile] = x;

   376

	}

   377

   378

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   379

		byte x = _current_player;

   380

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

   381

		_map_owner[tile] = x;

   382

	}

   383

   384

	if (flags & MP_MAP5) {

   385

		_map5[tile] = va_arg(va, int);

   386

	}

   387

   388

	va_end(va);

   389

   390

	if (!(flags & MP_NODIRTY))

   391

		MarkTileDirtyByTile(tile);

   392

}

   393

   394

   395

#define TILELOOP_BITS 4

   396

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   397

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

   398

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

   399

   400

void RunTileLoop(void)

   401

{

   402

	TileIndex tile;

   403

	uint count;

   404

   405

	tile = _cur_tileloop_tile;

   406

   407

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

   408

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

   409

	do {

   410

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

   411

   412

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

   413

			tile += TILELOOP_SIZE; /* no overflow */

   414

		} else {

   415

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

   416

		}

   417

	} while (--count);

   418

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

   419

   420

	tile += 9;

   421

	if (tile & TILELOOP_CHKMASK)

   422

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

   423

	_cur_tileloop_tile = tile;

   424

}

   425

   426

void InitializeLandscape(uint log_x, uint log_y)

   427

{

   428

	uint map_size;

   429

	uint i;

   430

   431

	InitMap(log_x, log_y);

   432

	map_size = MapSize();

   433

   434

	memset(_map_type_and_height, MP_CLEAR << 4, map_size);

   435

	memset(_map_owner,              OWNER_NONE, map_size);

   436

	memset(_map2,                            0, map_size * sizeof(_map2[0]));

   437

	memset(_map3_lo,                         0, map_size);

   438

	memset(_map3_hi,                         0, map_size);

   439

	memset(_map5,                            3, map_size);

   440

	memset(_map_extra_bits,                  0, map_size / 4);

   441

   442

	// create void tiles at the border

   443

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

   444

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

   445

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

   446

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

   447

}

   448

   449

void ConvertGroundTilesIntoWaterTiles(void)

   450

{

   451

	TileIndex tile = 0;

   452

	uint h;

   453

   454

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

   455

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

   456

			SetTileType(tile, MP_WATER);

   457

			_map5[tile] = 0;

   458

			SetTileOwner(tile, OWNER_WATER);

   459

		}

   460

	}

   461

}

   462

   463

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

   464

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

   465

   466

static void GenerateTerrain(int type, int flag)

   467

{

   468

	uint32 r;

   469

	uint x;

   470

	uint y;

   471

	uint w;

   472

	uint h;

   473

	const Sprite* template;

   474

	const byte *p;

   475

	byte *tile;

   476

	byte direction;

   477

   478

	r = Random();

   479

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

   480

   481

	x = r & MapMaxX();

   482

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

   483

   484

   485

	if (x < 2 || y < 2)

   486

		return;

   487

   488

	direction = (r >> 22) & 3;

   489

	if (direction & 1) {

   490

		w = template->height;

   491

		h = template->width;

   492

	} else {

   493

		w = template->width;

   494

		h = template->height;

   495

	}

   496

	p = template->data;

   497

   498

	if (flag & 4) {

   499

		uint xw = x * MapSizeY();

   500

		uint yw = y * MapSizeX();

   501

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

   502

   503

		switch (flag & 3) {

   504

			case 0:

   505

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

   506

				break;

   507

   508

			case 1: