1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "spritecache.h"

     5

#include "tile.h"

     6

#include <stdarg.h>

     7

#include "gfx.h"

     8

#include "viewport.h"

     9

#include "command.h"

    10

#include "vehicle.h"

    11

    12

extern const TileTypeProcs

    13

	_tile_type_clear_procs,

    14

	_tile_type_rail_procs,

    15

	_tile_type_road_procs,

    16

	_tile_type_town_procs,

    17

	_tile_type_trees_procs,

    18

	_tile_type_station_procs,

    19

	_tile_type_water_procs,

    20

	_tile_type_dummy_procs,

    21

	_tile_type_industry_procs,

    22

	_tile_type_tunnelbridge_procs,

    23

	_tile_type_unmovable_procs;

    24

    25

const TileTypeProcs * const _tile_type_procs[16] = {

    26

	&_tile_type_clear_procs,

    27

	&_tile_type_rail_procs,

    28

	&_tile_type_road_procs,

    29

	&_tile_type_town_procs,

    30

	&_tile_type_trees_procs,

    31

	&_tile_type_station_procs,

    32

	&_tile_type_water_procs,

    33

	&_tile_type_dummy_procs,

    34

	&_tile_type_industry_procs,

    35

	&_tile_type_tunnelbridge_procs,

    36

	&_tile_type_unmovable_procs,

    37

};

    38

    39

/* landscape slope => sprite */

    40

const byte _tileh_to_sprite[32] = {

    41

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

    42

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

    43

};

    44

    45

    46

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    47

{

    48

	assert(tile < MapSize());

    49

    50

	ti->tile = tile;

    51

	ti->map5 = _map5[tile];

    52

	ti->type = GetTileType(tile);

    53

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

    54

}

    55

    56

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

    57

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

    58

{

    59

	int tile;

    60

    61

	ti->x = x;

    62

	ti->y = y;

    63

    64

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

    65

		ti->tileh = 0;

    66

		ti->type = MP_VOID;

    67

		ti->tile = 0;

    68

		ti->map5 = 0;

    69

		ti->z = 0;

    70

		return;

    71

	}

    72

    73

	tile = TILE_FROM_XY(x,y);

    74

	FindLandscapeHeightByTile(ti, tile);

    75

}

    76

    77

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

    78

{

    79

	int z = 0;

    80

    81

	switch(corners) {

    82

	case 1:

    83

		if (x - y >= 0)

    84

			z = (x - y) >> 1;

    85

		break;

    86

    87

	case 2:

    88

		y^=0xF;

    89

		if ( (x - y) >= 0)

    90

			z = (x - y) >> 1;

    91

		break;

    92

    93

	case 3:

    94

		z = (x>>1) + 1;

    95

		break;

    96

    97

	case 4:

    98

		if (y - x >= 0)

    99

			z = (y - x) >> 1;

   100

		break;

   101

   102

	case 5:

   103

	case 10:

   104

	case 15:

   105

		z = 4;

   106

		break;

   107

   108

	case 6:

   109

		z = (y>>1) + 1;

   110

		break;

   111

   112

	case 7:

   113

		z = 8;

   114

		y^=0xF;

   115

		if (x - y < 0)

   116

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

   117

		break;

   118

   119

	case 8:

   120

		y ^= 0xF;

   121

		if (y - x >= 0)

   122

			z = (y - x) >> 1;

   123

		break;

   124

   125

	case 9:

   126

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

   127

		break;

   128

   129

	case 11:

   130

		z = 8;

   131

		if (x - y < 0)

   132

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

   133

		break;

   134

   135

	case 12:

   136

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

   137

		break;

   138

   139

	case 13:

   140

		z = 8;

   141

		y ^= 0xF;

   142

		if (y - x < 0)

   143

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

   144

		break;

   145

   146

	case 14:

   147

		z = 8;

   148

		if (y - x < 0)

   149

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

   150

		break;

   151

   152

	case 23:

   153

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

   154

		break;

   155

   156

	case 27:

   157

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

   158

		break;

   159

   160

	case 29:

   161

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

   162

		break;

   163

   164

	case 30:

   165

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

   166

		break;

   167

	}

   168

   169

	return z;

   170

}

   171

   172

uint GetSlopeZ(int x,  int y)

   173

{

   174

	TileInfo ti;

   175

//	int z;

   176

   177

	FindLandscapeHeight(&ti, x, y);

   178

   179

/*

   180

	z = ti.z;

   181

	x &= 0xF;

   182

	y &= 0xF;

   183

   184

   185

	assert(z < 256);

   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(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

	return south || other;

   206

   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 = 990; // 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) : 	ti->tileh + 0x3DE - 1,

   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(uint tile)

   242

{

   243

	ModifyTile(tile,

   244

		MP_SETTYPE(MP_CLEAR) |

   245

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   246

		OWNER_NONE, /* map_owner */

   247

		_generating_world ? 3 : 0 /* map5 */

   248

	);

   249

}

   250

   251

uint32 GetTileTrackStatus(uint tile, TransportType mode)

   252

{

   253

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

   254

}

   255

   256

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

   257

{

   258

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

   259

}

   260

   261

void GetAcceptedCargo(uint tile, AcceptedCargo ac)

   262

{

   263

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

   264

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

   265

}

   266

   267

void AnimateTile(uint tile)

   268

{

   269

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

   270

}

   271

   272

void ClickTile(uint tile)

   273

{

   274

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

   275

}

   276

   277

void DrawTile(TileInfo *ti)

   278

{

   279

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

   280

}

   281

   282

void GetTileDesc(uint tile, TileDesc *td)

   283

{

   284

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

   285

}

   286

   287

/* Clear a piece of landscape

   288

 * p1 = 0,

   289

 * p2 = 0

   290

 */

   291

   292

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

   293

{

   294

	uint tile;

   295

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   296

   297

	tile = TILE_FROM_XY(x,y);

   298

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

   299

}

   300

   301

// p1 = end tile

   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

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   310

   311

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

   312

	sx = TileX(p1) * 16;

   313

	sy = TileY(p1) * 16;

   314

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

   315

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

   316

   317

	money = GetAvailableMoneyForCommand();

   318

	cost = 0;

   319

   320

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

   321

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

   322

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

   323

			if (ret == CMD_ERROR) continue;

   324

			cost += ret;

   325

			success = true;

   326

   327

			if (flags & DC_EXEC) {

   328

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

   329

					_additional_cash_required = ret;

   330

					return cost - ret;

   331

				}

   332

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

   333

   334

				// draw explosion animation...

   335

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

   336

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

   337

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

   338

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

   339

					);

   340

				}

   341

			}

   342

		}

   343

	}

   344

   345

	if (!success)

   346

		cost = CMD_ERROR;

   347

	return cost;

   348

}

   349

   350

   351

/* utility function used to modify a tile */

   352

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

   353

{

   354

	va_list va;

   355

	int i;

   356

   357

	va_start(va, flags);

   358

   359

	if ((i = (flags >> 8) & 0xF) != 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

		_map2[tile] = 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

		_map3_lo[tile] = 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

		_map3_hi[tile] = x;

   379

	}

   380

   381

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   382

		byte x = _current_player;

   383

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

   384

		_map_owner[tile] = x;

   385

	}

   386

   387

	if (flags & MP_MAP5) {

   388

		_map5[tile] = 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

	uint 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) + TILE_XY(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(uint log_x, uint log_y)

   430

{

   431

	uint map_size;

   432

	uint i;

   433

   434

	InitMap(log_x, log_y);

   435

	map_size = MapSize();

   436

   437

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

   438

	memset(_map_owner,              OWNER_NONE, map_size);

   439

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

   440

	memset(_map3_lo,                         0, map_size);

   441

	memset(_map3_hi,                         0, map_size);

   442

	memset(_map5,                            3, map_size);

   443

	memset(_map_extra_bits,                  0, map_size / 4);

   444

   445

	// create void tiles at the border

   446

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

   447

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

   448

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

   449

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

   450

}

   451

   452

void ConvertGroundTilesIntoWaterTiles(void)

   453

{

   454

	TileIndex tile = 0;

   455

	uint h;

   456

   457

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

   458

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

   459

			SetTileType(tile, MP_WATER);

   460

			_map5[tile] = 0;

   461

			_map_owner[tile] = OWNER_WATER;

   462

		}

   463

	}

   464

}

   465

   466

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

   467

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

   468

   469

static void GenerateTerrain(int type, int flag)

   470

{

   471

	uint32 r;

   472

	uint x;

   473

	uint y;

   474

	uint w;

   475

	uint h;

   476

	const byte *p;

   477

	byte *tile;

   478

	byte direction;

   479

   480

	r = Random();

   481

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

   482

   483

	x = r & MapMaxX();

   484

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

   485

   486

   487

	if (x < 2 || y < 2)

   488

		return;

   489

   490

	direction = (r >> 22) & 3;

   491

	if (direction & 1) {

   492

		w = p[1];

   493

		h = p[2];

   494

	} else {

   495

		w = p[2];

   496

		h = p[1];

   497

	}

   498

	p += 8;

   499

   500

	if (flag & 4) {

   501

		uint xw = x * MapSizeY();

   502

		uint yw = y * MapSizeX();

   503

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

   504

   505

		switch (flag & 3) {

   506

			case 0:

   507

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

   508

				break;

   509

   510

			case 1:

   511

				if (yw < xw + bias) return;

   512

				break;

   513