1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include <stdarg.h>

     4

#include "gfx.h"

     5

#include "viewport.h"

     6

#include "command.h"

     7

#include "vehicle.h"

     8

     9

byte _map_type_and_height[TILES_X * TILES_Y];

    10

byte _map5[TILES_X * TILES_Y];

    11

byte _map3_lo[TILES_X * TILES_Y];

    12

byte _map3_hi[TILES_X * TILES_Y];

    13

byte _map_owner[TILES_X * TILES_Y];

    14

byte _map2[TILES_X * TILES_Y];

    15

byte _map_extra_bits[TILES_X * TILES_Y/4];

    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

uint GetTileSlope(uint tile, int *h)

    51

{

    52

	uint a,b,c,d,min;

    53

	int r;

    54

    55

	if (GET_TILE_X(tile) == TILE_X_MAX || GET_TILE_Y(tile) == TILE_Y_MAX) {

    56

		if (h)

    57

			*h = 0;

    58

		return 0;

    59

	}

    60

    61

	assert(tile < TILES_X * TILES_Y && GET_TILE_X(tile) != TILE_X_MAX && GET_TILE_Y(tile) != TILE_Y_MAX);

    62

    63

	min = a = _map_type_and_height[tile] & 0xF;

    64

	b = _map_type_and_height[tile+TILE_XY(1,0)] & 0xF;

    65

	if (min >= b) min = b;

    66

	c = _map_type_and_height[tile+TILE_XY(0,1)] & 0xF;

    67

	if (min >= c) min = c;

    68

	d = _map_type_and_height[tile+TILE_XY(1,1)] & 0xF;

    69

	if (min >= d) min = d;

    70

    71

	r = 0;

    72

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

    73

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

    74

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

    75

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

    76

    77

	if (h != 0)

    78

		*h = min * 8;

    79

    80

	return r;

    81

}

    82

    83

int GetTileZ(uint tile)

    84

{

    85

	int h;

    86

	GetTileSlope(tile, &h);

    87

	return h;

    88

}

    89

    90

void FindLandscapeHeightByTile(TileInfo *ti, uint tile)

    91

{

    92

	if (GET_TILE_X(tile) == TILE_X_MAX ||

    93

			GET_TILE_Y(tile) == TILE_Y_MAX) {

    94

		ti->tileh = 0;

    95

		ti->type = MP_STRANGE;

    96

		ti->tile = 0;

    97

		ti->map5 = 0;

    98

		ti->z = 0;

    99

		return;

   100

	}

   101

   102

	ti->tile = tile;

   103

	ti->map5 = _map5[tile];

   104

	ti->type = GET_TILETYPE(tile);

   105

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

   106

//	ti->z = min * 8;

   107

}

   108

   109

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

   110

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

   111

{

   112

	int tile;

   113

   114

	ti->x = x;

   115

	ti->y = y;

   116

   117

	if (x >= TILE_X_MAX*16-1 || y >= TILE_Y_MAX*16-1) {

   118

		ti->tileh = 0;

   119

		ti->type = MP_STRANGE;

   120

		ti->tile = 0;

   121

		ti->map5 = 0;

   122

		ti->z = 0;

   123

		return;

   124

	}

   125

   126

	tile = TILE_FROM_XY(x,y);

   127

	FindLandscapeHeightByTile(ti, tile);

   128

}

   129

   130

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

   131

{

   132

	int z = 0;

   133

   134

	switch(corners) {

   135

	case 1:

   136

		if (x - y >= 0)

   137

			z = (x - y) >> 1;

   138

		break;

   139

   140

	case 2:

   141

		y^=0xF;

   142

		if ( (x - y) >= 0)

   143

			z = (x - y) >> 1;

   144

		break;

   145

   146

	case 3:

   147

		z = (x>>1) + 1;

   148

		break;

   149

   150

	case 4:

   151

		if (y - x >= 0)

   152

			z = (y - x) >> 1;

   153

		break;

   154

   155

	case 5:

   156

	case 10:

   157

	case 15:

   158

		z = 4;

   159

		break;

   160

   161

	case 6:

   162

		z = (y>>1) + 1;

   163

		break;

   164

   165

	case 7:

   166

		z = 8;

   167

		y^=0xF;

   168

		if (x - y < 0)

   169

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

   170

		break;

   171

   172

	case 8:

   173

		y ^= 0xF;

   174

		if (y - x >= 0)

   175

			z = (y - x) >> 1;

   176

		break;

   177

   178

	case 9:

   179

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

   180

		break;

   181

   182

	case 11:

   183

		z = 8;

   184

		if (x - y < 0)

   185

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

   186

		break;

   187

   188

	case 12:

   189

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

   190

		break;

   191

   192

	case 13:

   193

		z = 8;

   194

		y ^= 0xF;

   195

		if (y - x < 0)

   196

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

   197

		break;

   198

   199

	case 14:

   200

		z = 8;

   201

		if (y - x < 0)

   202

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

   203

		break;

   204

   205

	case 23:

   206

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

   207

		break;

   208

   209

	case 27:

   210

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

   211

		break;

   212

   213

	case 29:

   214

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

   215

		break;

   216

   217

	case 30:

   218

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

   219

		break;

   220

	}

   221

   222

	return z;

   223

}

   224

   225

uint GetSlopeZ(int x,  int y)

   226

{

   227

	TileInfo ti;

   228

//	int z;

   229

   230

	FindLandscapeHeight(&ti, x, y);

   231

   232

/*

   233

	z = ti.z;

   234

	x &= 0xF;

   235

	y &= 0xF;

   236

   237

   238

	assert(z < 256);

   239

*/

   240

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

   241

}

   242

   243

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

   244

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

   245

bool hasFoundation(TileInfo *ti, bool direction)

   246

{

   247

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

   248

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

   249

	uint tileh = ti->tileh;

   250

   251

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

   252

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

   253

   254

	if(direction)

   255

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

   256

	else

   257

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

   258

	return south || other;

   259

   260

}

   261

   262

void DrawFoundation(TileInfo *ti, uint f)

   263

{

   264

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   265

   266

	TileInfo ti2;

   267

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

   268

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

   269

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

   270

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

   271

   272

	if (f < 15) {

   273

		// leveled foundation

   274

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

   275

   276

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

   277

		ti->z += 8;

   278

		ti->tileh = 0;

   279

		OffsetGroundSprite(31, 1);

   280

	} else {

   281

		// inclined foundation

   282

		sprite_base += 14;

   283

   284

		AddSortableSpriteToDraw(

   285

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

   286

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

   287

		);

   288

   289

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

   290

		OffsetGroundSprite(31, 9);

   291

	}

   292

}

   293

   294

void DoClearSquare(uint tile)

   295

{

   296

	ModifyTile(tile,

   297

		MP_SETTYPE(MP_CLEAR) |

   298

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   299

		OWNER_NONE, /* map_owner */

   300

		_generating_world ? 3 : 0 /* map5 */

   301

	);

   302

}

   303

   304

uint32 GetTileTrackStatus(uint tile, TransportType mode)

   305

{

   306

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

   307

}

   308

   309

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

   310

{

   311

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

   312

}

   313

   315

{

   316

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

   317

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

   318

}

   319

   320

void AnimateTile(uint tile)

   321

{

   322

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

   323

}

   324

   325

void ClickTile(uint tile)

   326

{

   327

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

   328

}

   329

   330

void DrawTile(TileInfo *ti)

   331

{

   332

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

   333

}

   334

   335

void GetTileDesc(uint tile, TileDesc *td)

   336

{

   337

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

   338

}

   339

   340

/* Clear a piece of landscape

   341

 * p1 = 0,

   342

 * p2 = 0

   343

 */

   344

   345

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

   346

{

   347

	uint tile;

   348

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   349

   350

	tile = TILE_FROM_XY(x,y);

   351

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

   352

}

   353

   354

// p1 = end tile

   355

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

   356

{

   357

	int32 cost,ret, money;

   358

	int sx,sy;

   359

	int x,y;

   360

	bool success = false;

   361

   362

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

   363

	sx = GET_TILE_X(p1)*16;

   364

	sy = GET_TILE_Y(p1)*16;

   365

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

   366

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

   367

   368

	money = GetAvailableMoneyForCommand();

   369

	cost = 0;

   370

   371

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

   372

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

   373

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

   374

			if (ret == CMD_ERROR) continue;

   375

			cost += ret;

   376

			success = true;

   377

   378

			if (flags & DC_EXEC) {

   379

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

   380

					_additional_cash_required = ret;

   381

					return cost - ret;

   382

				}

   383

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

   384

   385

				// draw explosion animation...

   386

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

   387

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

   388

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

   389

				}

   390

			}

   391

		}

   392

	}

   393

   394

	if (!success)

   395

		cost = CMD_ERROR;

   396

	return cost;

   397

}

   398

   399

   400

/* utility function used to modify a tile */

   401

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

   402

{

   403

	va_list va;

   404

	int i;

   405

   406

	va_start(va, flags);

   407

   408

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

   409

		_map_type_and_height[tile] = (_map_type_and_height[tile]&~0xF0)|((i-1) << 4);

   410

	}

   411

   412

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   413

		int x = 0;

   414

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

   415

		_map2[tile] = x;

   416

	}

   417

   418

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   419

		int x = 0;

   420

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

   421

		_map3_lo[tile] = x;

   422

	}

   423

   424

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   425

		int x = 0;

   426

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

   427

		_map3_hi[tile] = x;

   428

	}

   429

   430

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   431

		byte x = _current_player;

   432

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

   433

		_map_owner[tile] = x;

   434

	}

   435

   436

	if (flags & MP_MAP5) {

   437

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

   438

	}

   439

   440

	va_end(va);

   441

   442

	if (!(flags & MP_NODIRTY))

   443

		MarkTileDirtyByTile(tile);

   444

}

   445

   446

void SetMapExtraBits(uint tile, byte bits)

   447

{

   448

	_map_extra_bits[tile >> 2] &= ~(3 << ((tile&3)*2));

   449

	_map_extra_bits[tile >> 2] |= (bits&3) << ((tile&3)*2);

   450

}

   451

   452

uint GetMapExtraBits(uint tile)

   453

{

   454

	return (_map_extra_bits[tile >> 2] >> (tile&3)*2)&3;

   455

}

   456

   457

#define TILELOOP_BITS 4

   458

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   459

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

   460

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

   461

   462

void RunTileLoop()

   463

{

   464

	uint tile;

   465

	uint count;

   466

   467

	tile = _cur_tileloop_tile;

   468

   469

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

   470

	count = (TILES_X/TILELOOP_SIZE) * (TILES_Y/TILELOOP_SIZE);

   471

	do {

   472

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

   473

   474

		if ( GET_TILE_X(tile) < TILES_X - TILELOOP_SIZE) {

   475

			tile += TILELOOP_SIZE; /* no overflow */

   476

		} else {

   477

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

   478

		}

   479

	} while (--count);

   480

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

   481

   482

	tile += 9;

   483

	if (tile & TILELOOP_CHKMASK)

   484

		tile = (tile + TILES_X) & TILELOOP_ASSERTMASK;

   485

	_cur_tileloop_tile = tile;

   486

}

   487

   488

void InitializeLandscape()

   489

{

   490

	int i;

   491

   492

	memset(_map_owner, OWNER_NONE, sizeof(_map_owner));

   493

	memset(_map2, 0, sizeof(_map2));

   494

	memset(_map3_lo, 0, sizeof(_map3_lo));

   495

	memset(_map3_hi, 0, sizeof(_map3_hi));

   496

	memset(_map_extra_bits, 0, sizeof(_map_extra_bits));

   497

	memset(_map_type_and_height, MP_WATER << 4, sizeof(_map_type_and_height));

   498

   499

	for(i=0; i!=TILES_Y-1; i++)

   500

		memset(_map_type_and_height + i*TILES_X, 0, TILES_X-1);

   501

   502

	memset(_map5, 3, sizeof(_map5));

   503

}

   504

   505

void ConvertGroundTilesIntoWaterTiles()

   506

{

   507

	uint tile = 0;

   508

	int h;

   509

   510

	while(true) {

   511

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

   512

			_map_type_and_height[tile] = MP_WATER << 4;

   513

			_map5[tile] = 0;

   514

			_map_owner[tile] = OWNER_WATER;

   515

		}

   516

		tile++;

   517

		if (GET_TILE_X(tile) == TILE_X_MAX) {

   518

			tile += TILE_XY(-TILE_X_MAX, 1);

   519

			if (GET_TILE_Y(tile) == TILE_Y_MAX)

   520

				break;

   521

		}

   522

	}

   523

}

   524