1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include <stdarg.h>

     5

#include "gfx.h"

     6

#include "viewport.h"

     7

#include "command.h"

     8

#include "vehicle.h"

     9

    10

extern const TileTypeProcs

    11

	_tile_type_clear_procs,

    12

	_tile_type_rail_procs,

    13

	_tile_type_road_procs,

    14

	_tile_type_town_procs,

    15

	_tile_type_trees_procs,

    16

	_tile_type_station_procs,

    17

	_tile_type_water_procs,

    18

	_tile_type_dummy_procs,

    19

	_tile_type_industry_procs,

    20

	_tile_type_tunnelbridge_procs,

    21

	_tile_type_unmovable_procs;

    22

    23

const TileTypeProcs * const _tile_type_procs[16] = {

    24

	&_tile_type_clear_procs,

    25

	&_tile_type_rail_procs,

    26

	&_tile_type_road_procs,

    27

	&_tile_type_town_procs,

    28

	&_tile_type_trees_procs,

    29

	&_tile_type_station_procs,

    30

	&_tile_type_water_procs,

    31

	&_tile_type_dummy_procs,

    32

	&_tile_type_industry_procs,

    33

	&_tile_type_tunnelbridge_procs,

    34

	&_tile_type_unmovable_procs,

    35

};

    36

    37

/* landscape slope => sprite */

    38

const byte _tileh_to_sprite[32] = {

    39

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

    40

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

    41

};

    42

    43

uint GetTileSlope(uint tile, int *h)

    44

{

    45

	uint a,b,c,d,min;

    46

	int r;

    47

    48

	if (GET_TILE_X(tile) == MapMaxX() || GET_TILE_Y(tile) == MapMaxY()) {

    49

		if (h)

    50

			*h = 0;

    51

		return 0;

    52

	}

    53

    54

	assert(tile < TILES_X * TILES_Y && GET_TILE_X(tile) != MapMaxX() && GET_TILE_Y(tile) != MapMaxY());

    55

    56

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

    57

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

    58

	if (min >= b) min = b;

    59

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

    60

	if (min >= c) min = c;

    61

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

    62

	if (min >= d) min = d;

    63

    64

	r = 0;

    65

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

    66

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

    67

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

    68

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

    69

    70

	if (h != 0)

    71

		*h = min * 8;

    72

    73

	return r;

    74

}

    75

    76

int GetTileZ(uint tile)

    77

{

    78

	int h;

    79

	GetTileSlope(tile, &h);

    80

	return h;

    81

}

    82

    83

void FindLandscapeHeightByTile(TileInfo *ti, uint tile)

    84

{

    85

	if (GET_TILE_X(tile) == MapMaxX() || GET_TILE_Y(tile) == MapMaxY()) {

    86

		ti->tileh = 0;

    87

		ti->type = MP_STRANGE;

    88

		ti->tile = 0;

    89

		ti->map5 = 0;

    90

		ti->z = 0;

    91

		return;

    92

	}

    93

    94

	ti->tile = tile;

    95

	ti->map5 = _map5[tile];

    96

	ti->type = GET_TILETYPE(tile);

    97

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

    98

//	ti->z = min * 8;

    99

}

   100

   101

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

   102

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

   103

{

   104

	int tile;

   105

   106

	ti->x = x;

   107

	ti->y = y;

   108

   109

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

   110

		ti->tileh = 0;

   111

		ti->type = MP_STRANGE;

   112

		ti->tile = 0;

   113

		ti->map5 = 0;

   114

		ti->z = 0;

   115

		return;

   116

	}

   117

   118

	tile = TILE_FROM_XY(x,y);

   119

	FindLandscapeHeightByTile(ti, tile);

   120

}

   121

   122

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

   123

{

   124

	int z = 0;

   125

   126

	switch(corners) {

   127

	case 1:

   128

		if (x - y >= 0)

   129

			z = (x - y) >> 1;

   130

		break;

   131

   132

	case 2:

   133

		y^=0xF;

   134

		if ( (x - y) >= 0)

   135

			z = (x - y) >> 1;

   136

		break;

   137

   138

	case 3:

   139

		z = (x>>1) + 1;

   140

		break;

   141

   142

	case 4:

   143

		if (y - x >= 0)

   144

			z = (y - x) >> 1;

   145

		break;

   146

   147

	case 5:

   148

	case 10:

   149

	case 15:

   150

		z = 4;

   151

		break;

   152

   153

	case 6:

   154

		z = (y>>1) + 1;

   155

		break;

   156

   157

	case 7:

   158

		z = 8;

   159

		y^=0xF;

   160

		if (x - y < 0)

   161

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

   162

		break;

   163

   164

	case 8:

   165

		y ^= 0xF;

   166

		if (y - x >= 0)

   167

			z = (y - x) >> 1;

   168

		break;

   169

   170

	case 9:

   171

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

   172

		break;

   173

   174

	case 11:

   175

		z = 8;

   176

		if (x - y < 0)

   177

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

   178

		break;

   179

   180

	case 12:

   181

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

   182

		break;

   183

   184

	case 13:

   185

		z = 8;

   186

		y ^= 0xF;

   187

		if (y - x < 0)

   188

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

   189

		break;

   190

   191

	case 14:

   192

		z = 8;

   193

		if (y - x < 0)

   194

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

   195

		break;

   196

   197

	case 23:

   198

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

   199

		break;

   200

   201

	case 27:

   202

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

   203

		break;

   204

   205

	case 29:

   206

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

   207

		break;

   208

   209

	case 30:

   210

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

   211

		break;

   212

	}

   213

   214

	return z;

   215

}

   216

   217

uint GetSlopeZ(int x,  int y)

   218

{

   219

	TileInfo ti;

   220

//	int z;

   221

   222

	FindLandscapeHeight(&ti, x, y);

   223

   224

/*

   225

	z = ti.z;

   226

	x &= 0xF;

   227

	y &= 0xF;

   228

   229

   230

	assert(z < 256);

   231

*/

   232

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

   233

}

   234

   235

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

   236

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

   237

bool hasFoundation(TileInfo *ti, bool direction)

   238

{

   239

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

   240

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

   241

	uint tileh = ti->tileh;

   242

   243

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

   244

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

   245

   246

	if(direction)

   247

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

   248

	else

   249

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

   250

	return south || other;

   251

   252

}

   253

   254

void DrawFoundation(TileInfo *ti, uint f)

   255

{

   256

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   257

   258

	TileInfo ti2;

   259

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

   260

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

   261

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

   262

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

   263

   264

	if (f < 15) {

   265

		// leveled foundation

   266

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

   267

   268

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

   269

		ti->z += 8;

   270

		ti->tileh = 0;

   271

		OffsetGroundSprite(31, 1);

   272

	} else {

   273

		// inclined foundation

   274

		sprite_base += 14;

   275

   276

		AddSortableSpriteToDraw(

   277

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

   278

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

   279

		);

   280

   281

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

   282

		OffsetGroundSprite(31, 9);

   283

	}

   284

}

   285

   286

void DoClearSquare(uint tile)

   287

{

   288

	ModifyTile(tile,

   289

		MP_SETTYPE(MP_CLEAR) |

   290

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   291

		OWNER_NONE, /* map_owner */

   292

		_generating_world ? 3 : 0 /* map5 */

   293

	);

   294

}

   295

   296

uint32 GetTileTrackStatus(uint tile, TransportType mode)

   297

{

   298

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

   299

}

   300

   301

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

   302

{

   303

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

   304

}

   305

   306

void GetAcceptedCargo(uint tile, AcceptedCargo ac)

   307

{

   308

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

   309

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

   310

}

   311

   312

void AnimateTile(uint tile)

   313

{

   314

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

   315

}

   316

   317

void ClickTile(uint tile)

   318

{

   319

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

   320

}

   321

   322

void DrawTile(TileInfo *ti)

   323

{

   324

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

   325

}

   326

   327

void GetTileDesc(uint tile, TileDesc *td)

   328

{

   329

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

   330

}

   331

   332

/* Clear a piece of landscape

   333

 * p1 = 0,

   334

 * p2 = 0

   335

 */

   336

   337

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

   338

{

   339

	uint tile;

   340

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   341

   342

	tile = TILE_FROM_XY(x,y);

   343

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

   344

}

   345

   346

// p1 = end tile

   347

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

   348

{

   349

	int32 cost,ret, money;

   350

	int sx,sy;

   351

	int x,y;

   352

	bool success = false;

   353

   354

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

   355

	sx = GET_TILE_X(p1)*16;

   356

	sy = GET_TILE_Y(p1)*16;

   357

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

   358

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

   359

   360

	money = GetAvailableMoneyForCommand();

   361

	cost = 0;

   362

   363

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

   364

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

   365

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

   366

			if (ret == CMD_ERROR) continue;

   367

			cost += ret;

   368

			success = true;

   369

   370

			if (flags & DC_EXEC) {

   371

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

   372

					_additional_cash_required = ret;

   373

					return cost - ret;

   374

				}

   375

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

   376

   377

				// draw explosion animation...

   378

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

   379

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

   380

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

   381

				}

   382

			}

   383

		}

   384

	}

   385

   386

	if (!success)

   387

		cost = CMD_ERROR;

   388

	return cost;

   389

}

   390

   391

   392

/* utility function used to modify a tile */

   393

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

   394

{

   395

	va_list va;

   396

	int i;

   397

   398

	va_start(va, flags);

   399

   400

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

   401

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

   402

	}

   403

   404

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   405

		int x = 0;

   406

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

   407

		_map2[tile] = x;

   408

	}

   409

   410

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   411

		int x = 0;

   412

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

   413

		_map3_lo[tile] = x;

   414

	}

   415

   416

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   417

		int x = 0;

   418

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

   419

		_map3_hi[tile] = x;

   420

	}

   421

   422

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   423

		byte x = _current_player;

   424

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

   425

		_map_owner[tile] = x;

   426

	}

   427

   428

	if (flags & MP_MAP5) {

   429

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

   430

	}

   431

   432

	va_end(va);

   433

   434

	if (!(flags & MP_NODIRTY))

   435

		MarkTileDirtyByTile(tile);

   436

}

   437

   438

void SetMapExtraBits(uint tile, byte bits)

   439

{

   440

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

   441

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

   442

}

   443

   444

uint GetMapExtraBits(uint tile)

   445

{

   446

	if (GET_TILE_X(tile) < MapSizeX() && GET_TILE_Y(tile) < MapSizeY() &&

   447

			GET_TILE_X(tile) > 0 && GET_TILE_Y(tile) > 0)

   448

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

   449

	else

   450

		return 0;

   451

}

   452

   453

#define TILELOOP_BITS 4

   454

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   455

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

   456

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

   457

   458

void RunTileLoop()

   459

{

   460

	uint tile;

   461

	uint count;

   462

   463

	tile = _cur_tileloop_tile;

   464

   465

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

   466

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

   467

	do {

   468

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

   469

   470

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

   471

			tile += TILELOOP_SIZE; /* no overflow */

   472

		} else {

   473

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

   474

		}

   475

	} while (--count);

   476

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

   477

   478

	tile += 9;

   479

	if (tile & TILELOOP_CHKMASK)

   480

		tile = (tile + TILES_X) & TILELOOP_ASSERTMASK;

   481

	_cur_tileloop_tile = tile;

   482

}

   483

   484

void InitializeLandscape()

   485

{

   486

	uint map_size = MapSize();

   487

	int i;

   488

   489

	memset(_map_owner, OWNER_NONE, map_size);

   490

	memset(_map2, 0, map_size * sizeof(uint16));

   491

	memset(_map3_lo, 0, map_size);

   492

	memset(_map3_hi, 0, map_size);

   493

	memset(_map_extra_bits, 0, map_size / 4);

   494

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

   495

   496

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

   497

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

   498

   499

	memset(_map5, 3, map_size);

   500

}

   501

   502

void ConvertGroundTilesIntoWaterTiles()

   503

{

   504

	uint tile = 0;

   505

	int h;

   506

   507

	while(true) {

   508

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

   509

			_map_type_and_height[tile] = MP_WATER << 4;

   510

			_map5[tile] = 0;

   511

			_map_owner[tile] = OWNER_WATER;

   512

		}

   513

		tile++;

   514

		if (GET_TILE_X(tile) == MapMaxX()) {

   516

			if (GET_TILE_Y(tile) == MapMaxY())

   517

				break;

   518

		}

   519

	}

   520

}

   521