1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "tile.h"

     5

#include <stdarg.h>

     6

#include "gfx.h"

     7

#include "viewport.h"

     8

#include "command.h"

     9

#include "vehicle.h"

    10

    11

extern const TileTypeProcs

    12

	_tile_type_clear_procs,

    13

	_tile_type_rail_procs,

    14

	_tile_type_road_procs,

    15

	_tile_type_town_procs,

    16

	_tile_type_trees_procs,

    17

	_tile_type_station_procs,

    18

	_tile_type_water_procs,

    19

	_tile_type_dummy_procs,

    20

	_tile_type_industry_procs,

    21

	_tile_type_tunnelbridge_procs,

    22

	_tile_type_unmovable_procs;

    23

    24

const TileTypeProcs * const _tile_type_procs[16] = {

    25

	&_tile_type_clear_procs,

    26

	&_tile_type_rail_procs,

    27

	&_tile_type_road_procs,

    28

	&_tile_type_town_procs,

    29

	&_tile_type_trees_procs,

    30

	&_tile_type_station_procs,

    31

	&_tile_type_water_procs,

    32

	&_tile_type_dummy_procs,

    33

	&_tile_type_industry_procs,

    34

	&_tile_type_tunnelbridge_procs,

    35

	&_tile_type_unmovable_procs,

    36

};

    37

    38

/* landscape slope => sprite */

    39

const byte _tileh_to_sprite[32] = {

    40

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

    41

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

    42

};

    43

    44

uint GetTileSlope(uint tile, int *h)

    45

{

    46

	uint a,b,c,d,min;

    47

	int r;

    48

    49

	assert(tile < MapSize());

    50

    51

	if (TileX(tile) == MapMaxX() || TileY(tile) == MapMaxY()) {

    52

		if (h)

    53

			*h = 0;

    54

		return 0;

    55

	}

    56

    57

	min = a = TileHeight(tile);

    58

	b = TileHeight(tile + TILE_XY(1,0));

    59

	if (min >= b) min = b;

    60

	c = TileHeight(tile + TILE_XY(0,1));

    61

	if (min >= c) min = c;

    62

	d = TileHeight(tile + TILE_XY(1,1));

    63

	if (min >= d) min = d;

    64

    65

	r = 0;

    66

	if ((a-=min)!=0) { r += (--a << 4) + 8; }

    67

	if ((c-=min)!=0) { r += (--c << 4) + 4; }

    68

	if ((d-=min)!=0) { r += (--d << 4) + 2; }

    69

	if ((b-=min)!=0) { r += (--b << 4) + 1; }

    70

    71

	if (h != 0)

    72

		*h = min * 8;

    73

    74

	return r;

    75

}

    76

    77

int GetTileZ(uint tile)

    78

{

    79

	int h;

    80

	GetTileSlope(tile, &h);

    81

	return h;

    82

}

    83

    84

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    85

{

    86

	assert(tile < MapSize());

    87

    88

	ti->tile = tile;

    89

	ti->map5 = _map5[tile];

    90

	ti->type = GetTileType(tile);

    91

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

    92

}

    93

    94

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

    95

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

    96

{

    97

	int tile;

    98

    99

	ti->x = x;

   100

	ti->y = y;

   101

   102

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

   103

		ti->tileh = 0;

   104

		ti->type = MP_VOID;

   105

		ti->tile = 0;

   106

		ti->map5 = 0;

   107

		ti->z = 0;

   108

		return;

   109

	}

   110

   111

	tile = TILE_FROM_XY(x,y);

   112

	FindLandscapeHeightByTile(ti, tile);

   113

}

   114

   115

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

   116

{

   117

	int z = 0;

   118

   119

	switch(corners) {

   120

	case 1:

   121

		if (x - y >= 0)

   122

			z = (x - y) >> 1;

   123

		break;

   124

   125

	case 2:

   126

		y^=0xF;

   127

		if ( (x - y) >= 0)

   128

			z = (x - y) >> 1;

   129

		break;

   130

   131

	case 3:

   132

		z = (x>>1) + 1;

   133

		break;

   134

   135

	case 4:

   136

		if (y - x >= 0)

   137

			z = (y - x) >> 1;

   138

		break;

   139

   140

	case 5:

   141

	case 10:

   142

	case 15:

   143

		z = 4;

   144

		break;

   145

   146

	case 6:

   147

		z = (y>>1) + 1;

   148

		break;

   149

   150

	case 7:

   151

		z = 8;

   152

		y^=0xF;

   153

		if (x - y < 0)

   154

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

   155

		break;

   156

   157

	case 8:

   158

		y ^= 0xF;

   159

		if (y - x >= 0)

   160

			z = (y - x) >> 1;

   161

		break;

   162

   163

	case 9:

   164

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

   165

		break;

   166

   167

	case 11:

   168

		z = 8;

   169

		if (x - y < 0)

   170

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

   171

		break;

   172

   173

	case 12:

   174

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

   175

		break;

   176

   177

	case 13:

   178

		z = 8;

   179

		y ^= 0xF;

   180

		if (y - x < 0)

   181

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

   182

		break;

   183

   184

	case 14:

   185

		z = 8;

   186

		if (y - x < 0)

   187

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

   188

		break;

   189

   190

	case 23:

   191

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

   192

		break;

   193

   194

	case 27:

   195

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

   196

		break;

   197

   198

	case 29:

   199

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

   200

		break;

   201

   202

	case 30:

   203

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

   204

		break;

   205

	}

   206

   207

	return z;

   208

}

   209

   210

uint GetSlopeZ(int x,  int y)

   211

{

   212

	TileInfo ti;

   213

//	int z;

   214

   215

	FindLandscapeHeight(&ti, x, y);

   216

   217

/*

   218

	z = ti.z;

   219

	x &= 0xF;

   220

	y &= 0xF;

   221

   222

   223

	assert(z < 256);

   224

*/

   225

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

   226

}

   227

   228

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

   229

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

   230

static bool hasFoundation(TileInfo *ti, bool direction)

   231

{

   232

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

   233

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

   234

	uint tileh = ti->tileh;

   235

   236

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

   237

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

   238

   239

	if(direction)

   240

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

   241

	else

   242

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

   243

	return south || other;

   244

   245

}

   246

   247

void DrawFoundation(TileInfo *ti, uint f)

   248

{

   249

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   250

   251

	TileInfo ti2;

   252

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

   253

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

   254

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

   255

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

   256

   257

	if (f < 15) {

   258

		// leveled foundation

   259

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

   260

   261

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

   262

		ti->z += 8;

   263

		ti->tileh = 0;

   264

		OffsetGroundSprite(31, 1);

   265

	} else {

   266

		// inclined foundation

   267

		sprite_base += 14;

   268

   269

		AddSortableSpriteToDraw(

   270

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

   271

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

   272

		);

   273

   274

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

   275

		OffsetGroundSprite(31, 9);

   276

	}

   277

}

   278

   279

void DoClearSquare(uint tile)

   280

{

   281

	ModifyTile(tile,

   282

		MP_SETTYPE(MP_CLEAR) |

   283

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   284

		OWNER_NONE, /* map_owner */

   285

		_generating_world ? 3 : 0 /* map5 */

   286

	);

   287

}

   288

   289

uint32 GetTileTrackStatus(uint tile, TransportType mode)

   290

{

   291

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

   292

}

   293

   294

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

   295

{

   296

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

   297

}

   298

   299

void GetAcceptedCargo(uint tile, AcceptedCargo ac)

   300

{

   301

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

   302

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

   303

}

   304

   305

void AnimateTile(uint tile)

   306

{

   307

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

   308

}

   309

   310

void ClickTile(uint tile)

   311

{

   312

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

   313

}

   314

   315

void DrawTile(TileInfo *ti)

   316

{

   317

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

   318

}

   319

   320

void GetTileDesc(uint tile, TileDesc *td)

   321

{

   322

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

   323

}

   324

   325

/* Clear a piece of landscape

   326

 * p1 = 0,

   327

 * p2 = 0

   328

 */

   329

   330

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

   331

{

   332

	uint tile;

   333

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   334

   335

	tile = TILE_FROM_XY(x,y);

   336

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

   337

}

   338

   339

// p1 = end tile

   340

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

   341

{

   342

	int32 cost,ret, money;

   343

	int sx,sy;

   344

	int x,y;

   345

	bool success = false;

   346

   347

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   348

   349

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

   350

	sx = TileX(p1) * 16;

   351

	sy = TileY(p1) * 16;

   352

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

   353

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

   354

   355

	money = GetAvailableMoneyForCommand();

   356

	cost = 0;

   357

   358

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

   359

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

   360

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

   361

			if (ret == CMD_ERROR) continue;

   362

			cost += ret;

   363

			success = true;

   364

   365

			if (flags & DC_EXEC) {

   366

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

   367

					_additional_cash_required = ret;

   368

					return cost - ret;

   369

				}

   370

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

   371

   372

				// draw explosion animation...

   373

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

   374

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

   375

					CreateEffectVehicleAbove(x + 8,y + 8, 2, sy==ey && sx==ex ? EV_DEMOLISH : EV_CRASHED_SMOKE);

   376

				}

   377

			}

   378

		}

   379

	}

   380

   381

	if (!success)

   382

		cost = CMD_ERROR;

   383

	return cost;

   384

}

   385

   386

   387

/* utility function used to modify a tile */

   388

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

   389

{

   390

	va_list va;

   391

	int i;

   392

   393

	va_start(va, flags);

   394

   395

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

   396

		SetTileType(tile, i - 1);

   397

	}

   398

   399

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   400

		int x = 0;

   401

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

   402

		_map2[tile] = x;

   403

	}

   404

   405

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   406

		int x = 0;

   407

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

   408

		_map3_lo[tile] = x;

   409

	}

   410

   411

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   412

		int x = 0;

   413

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

   414

		_map3_hi[tile] = x;

   415

	}

   416

   417

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   418

		byte x = _current_player;

   419

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

   420

		_map_owner[tile] = x;

   421

	}

   422

   423

	if (flags & MP_MAP5) {

   424

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

   425

	}

   426

   427

	va_end(va);

   428

   429

	if (!(flags & MP_NODIRTY))

   430

		MarkTileDirtyByTile(tile);

   431

}

   432

   433

   434

#define TILELOOP_BITS 4

   435

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   436

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

   437

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

   438

   439

void RunTileLoop(void)

   440

{

   441

	uint tile;

   442

	uint count;

   443

   444

	tile = _cur_tileloop_tile;

   445

   446

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

   447

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

   448

	do {

   449

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

   450

   451

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

   452

			tile += TILELOOP_SIZE; /* no overflow */

   453

		} else {

   454

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

   455

		}

   456

	} while (--count);

   457

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

   458

   459

	tile += 9;

   460

	if (tile & TILELOOP_CHKMASK)

   461

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

   462

	_cur_tileloop_tile = tile;

   463

}

   464

   465

void InitializeLandscape(uint log_x, uint log_y)

   466

{

   467

	uint map_size;

   468

	uint i;

   469

   470

	InitMap(log_x, log_y);

   471

	map_size = MapSize();

   472

   473

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

   474

	memset(_map_owner,              OWNER_NONE, map_size);

   475

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

   476

	memset(_map3_lo,                         0, map_size);

   477

	memset(_map3_hi,                         0, map_size);

   478

	memset(_map5,                            3, map_size);

   479

	memset(_map_extra_bits,                  0, map_size / 4);

   480

   481

	// create void tiles at the border

   482

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

   483

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

   484

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

   485

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

   486

}

   487

   488

void ConvertGroundTilesIntoWaterTiles(void)

   489

{

   490

	uint tile = 0;

   491

	int h;

   492

   493

	while(true) {

   494

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

   495

			SetTileType(tile, MP_WATER);

   496

			_map5[tile] = 0;

   497

			_map_owner[tile] = OWNER_WATER;

   498

		}

   499

		tile++;

   500

		if (TileX(tile) == MapMaxX()) {

   501

			tile += TILE_XY(-(int)MapMaxX(), 1);

   502

			if (TileY(tile) == MapMaxY())

   503

				break;

   504

		}

   505

	}

   506

}

   507

   508

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

   509

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

   510

   511

static void GenerateTerrain(int type, int flag)

   512

{

   513

	uint32 r;

   514

	uint x,y;