1

#include "stdafx.h"

     2

#include "openttd.h"

     4

#include "map.h"

     5

#include "player.h"

     6

#include "spritecache.h"

     7

#include "table/sprites.h"

     8

#include "tile.h"

     9

#include <stdarg.h>

    10

#include "viewport.h"

    11

#include "command.h"

    12

#include "vehicle.h"

    13

#include "variables.h"

    14

    15

extern const TileTypeProcs

    16

	_tile_type_clear_procs,

    17

	_tile_type_rail_procs,

    18

	_tile_type_road_procs,

    19

	_tile_type_town_procs,

    20

	_tile_type_trees_procs,

    21

	_tile_type_station_procs,

    22

	_tile_type_water_procs,

    23

	_tile_type_dummy_procs,

    24

	_tile_type_industry_procs,

    25

	_tile_type_tunnelbridge_procs,

    26

	_tile_type_unmovable_procs;

    27

    28

const TileTypeProcs * const _tile_type_procs[16] = {

    29

	&_tile_type_clear_procs,

    30

	&_tile_type_rail_procs,

    31

	&_tile_type_road_procs,

    32

	&_tile_type_town_procs,

    33

	&_tile_type_trees_procs,

    34

	&_tile_type_station_procs,

    35

	&_tile_type_water_procs,

    36

	&_tile_type_dummy_procs,

    37

	&_tile_type_industry_procs,

    38

	&_tile_type_tunnelbridge_procs,

    39

	&_tile_type_unmovable_procs,

    40

};

    41

    42

/* landscape slope => sprite */

    43

const byte _tileh_to_sprite[32] = {

    44

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

    45

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

    46

};

    47

    48

const byte _inclined_tileh[] = {

    49

	3, 9, 3, 6, 12, 6, 12, 9

    50

};

    51

    52

    53

void FindLandscapeHeightByTile(TileInfo *ti, TileIndex tile)

    54

{

    55

	assert(tile < MapSize());

    56

    57

	ti->tile = tile;

    58

	ti->map5 = _m[tile].m5;

    59

	ti->type = GetTileType(tile);

    60

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

    61

}

    62

    63

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

    64

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

    65

{

    66

	ti->x = x;

    67

	ti->y = y;

    68

    69

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

    70

		ti->tileh = 0;

    71

		ti->type = MP_VOID;

    72

		ti->tile = 0;

    73

		ti->map5 = 0;

    74

		ti->z = 0;

    75

		return;

    76

	}

    77

    78

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

    79

}

    80

    81

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

    82

{

    83

	int z = 0;

    84

    85

	switch(corners) {

    86

	case 1:

    87

		if (x - y >= 0)

    88

			z = (x - y) >> 1;

    89

		break;

    90

    91

	case 2:

    92

		y^=0xF;

    93

		if ( (x - y) >= 0)

    94

			z = (x - y) >> 1;

    95

		break;

    96

    97

	case 3:

    98

		z = (x>>1) + 1;

    99

		break;

   100

   101

	case 4:

   102

		if (y - x >= 0)

   103

			z = (y - x) >> 1;

   104

		break;

   105

   106

	case 5:

   107

	case 10:

   108

	case 15:

   109

		z = 4;

   110

		break;

   111

   112

	case 6:

   113

		z = (y>>1) + 1;

   114

		break;

   115

   116

	case 7:

   117

		z = 8;

   118

		y^=0xF;

   119

		if (x - y < 0)

   120

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

   121

		break;

   122

   123

	case 8:

   124

		y ^= 0xF;

   125

		if (y - x >= 0)

   126

			z = (y - x) >> 1;

   127

		break;

   128

   129

	case 9:

   130

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

   131

		break;

   132

   133

	case 11:

   134

		z = 8;

   135

		if (x - y < 0)

   136

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

   137

		break;

   138

   139

	case 12:

   140

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

   141

		break;

   142

   143

	case 13:

   144

		z = 8;

   145

		y ^= 0xF;

   146

		if (y - x < 0)

   147

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

   148

		break;

   149

   150

	case 14:

   151

		z = 8;

   152

		if (y - x < 0)

   153

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

   154

		break;

   155

   156

	case 23:

   157

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

   158

		break;

   159

   160

	case 27:

   161

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

   162

		break;

   163

   164

	case 29:

   165

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

   166

		break;

   167

   168

	case 30:

   169

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

   170

		break;

   171

	}

   172

   173

	return z;

   174

}

   175

   176

uint GetSlopeZ(int x,  int y)

   177

{

   178

	TileInfo ti;

   179

   180

	FindLandscapeHeight(&ti, x, y);

   181

   182

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

   183

}

   184

   185

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

   186

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

   187

static bool hasFoundation(TileInfo *ti, bool direction)

   188

{

   189

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

   190

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

   191

	uint tileh = ti->tileh;

   192

   193

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

   194

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

   195

   196

	if(direction)

   197

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

   198

	else

   199

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

   200

	return south || other;

   201

   202

}

   203

   204

void DrawFoundation(TileInfo *ti, uint f)

   205

{

   206

	uint32 sprite_base = SPR_SLOPES_BASE-14;

   207

   208

	TileInfo ti2;

   209

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

   210

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

   211

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

   212

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

   213

   214

	if (f < 15) {

   215

		// leveled foundation

   216

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

   217

   218

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

   219

		ti->z += 8;

   220

		ti->tileh = 0;

   221

		OffsetGroundSprite(31, 1);

   222

	} else {

   223

		// inclined foundation

   224

		sprite_base += 14;

   225

   226

		AddSortableSpriteToDraw(

   227

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

   228

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

   229

		);

   230

   231

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

   232

		OffsetGroundSprite(31, 9);

   233

	}

   234

}

   235

   236

void DoClearSquare(TileIndex tile)

   237

{

   238

	ModifyTile(tile,

   239

		MP_SETTYPE(MP_CLEAR) |

   240

		MP_MAP2_CLEAR | MP_MAP3LO_CLEAR | MP_MAP3HI_CLEAR | MP_MAPOWNER | MP_MAP5,

   241

		OWNER_NONE, /* map_owner */

   242

		_generating_world ? 3 : 0 /* map5 */

   243

	);

   244

}

   245

   246

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   247

{

   248

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

   249

}

   250

   251

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

   252

{

   253

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

   254

}

   255

   256

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   257

{

   258

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

   259

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

   260

}

   261

   262

void AnimateTile(TileIndex tile)

   263

{

   264

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

   265

}

   266

   267

void ClickTile(TileIndex tile)

   268

{

   269

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

   270

}

   271

   272

void DrawTile(TileInfo *ti)

   273

{

   274

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

   275

}

   276

   277

void GetTileDesc(TileIndex tile, TileDesc *td)

   278

{

   279

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

   280

}

   281

   282

/** Clear a piece of landscape

   283

 * @param x,y coordinates of clearance

   284

 * @param p1 unused

   285

 * @param p2 unused

   286

 */

   287

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

   288

{

   289

	TileIndex tile = TileVirtXY(x, y);

   290

   291

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   292

   293

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

   294

}

   295

   296

/** Clear a big piece of landscape

   297

 * @param x,y end coordinates of area dragging

   298

 * @param p1 start tile of area dragging

   299

 * @param p2 unused

   300

 */

   301

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

   302

{

   303

	int32 cost, ret, money;

   304

	int sx,sy;

   305

	int x,y;

   306

	bool success = false;

   307

   308

	if (p1 > MapSize()) return CMD_ERROR;

   309

   310

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   311

   312

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

   313

	sx = TileX(p1) * 16;

   314

	sy = TileY(p1) * 16;

   315

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

   316

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

   317

   318

	money = GetAvailableMoneyForCommand();

   319

	cost = 0;

   320

   321

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

   322

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

   323

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

   324

			if (CmdFailed(ret)) continue;

   325

			cost += ret;

   326

			success = true;

   327

   328

			if (flags & DC_EXEC) {

   329

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

   330

					_additional_cash_required = ret;

   331

					return cost - ret;

   332

				}

   333

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

   334

   335

				// draw explosion animation...

   336

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

   337

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

   338

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

   339

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

   340

					);

   341

				}

   342

			}

   343

		}

   344

	}

   345

   346

	return (success) ? cost : CMD_ERROR;

   347

}

   348

   349

   350

/* utility function used to modify a tile */

   351

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

   352

{

   353

	va_list va;

   354

	int i;

   355

   356

	va_start(va, flags);

   357

   358

	if ((i = GB(flags, 8, 4)) != 0) {

   359

		SetTileType(tile, i - 1);

   360

	}

   361

   362

	if (flags & (MP_MAP2_CLEAR | MP_MAP2)) {

   363

		int x = 0;

   364

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

   365

		_m[tile].m2 = x;

   366

	}

   367

   368

	if (flags & (MP_MAP3LO_CLEAR | MP_MAP3LO)) {

   369

		int x = 0;

   370

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

   371

		_m[tile].m3 = x;

   372

	}

   373

   374

	if (flags & (MP_MAP3HI_CLEAR | MP_MAP3HI)) {

   375

		int x = 0;

   376

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

   377

		_m[tile].m4 = x;

   378

	}

   379

   380

	if (flags & (MP_MAPOWNER|MP_MAPOWNER_CURRENT)) {

   381

		byte x = _current_player;

   382

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

   383

		_m[tile].owner = x;

   384

	}

   385

   386

	if (flags & MP_MAP5) {

   387

		_m[tile].m5 = va_arg(va, int);

   388

	}

   389

   390

	va_end(va);

   391

   392

	if (!(flags & MP_NODIRTY))

   393

		MarkTileDirtyByTile(tile);

   394

}

   395

   396

   397

#define TILELOOP_BITS 4

   398

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   399

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

   400

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

   401

   402

void RunTileLoop(void)

   403

{

   404

	TileIndex tile;

   405

	uint count;

   406

   407

	tile = _cur_tileloop_tile;

   408

   409

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

   410

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

   411

	do {

   412

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

   413

   414

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

   415

			tile += TILELOOP_SIZE; /* no overflow */

   416

		} else {

   417

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

   418

		}

   419

	} while (--count);

   420

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

   421

   422

	tile += 9;

   423

	if (tile & TILELOOP_CHKMASK)

   424

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

   425

	_cur_tileloop_tile = tile;

   426

}

   427

   428

void InitializeLandscape(void)

   429

{

   430

	uint map_size;

   431

	uint i;

   432

   433

   434

	map_size = MapSize();

   435

	for (i = 0; i < map_size; i++) {

   436

		_m[i].type_height = MP_CLEAR << 4;

   437

		_m[i].owner       = OWNER_NONE;

   438

		_m[i].m2          = 0;

   439

		_m[i].m3          = 0;

   440

		_m[i].m4          = 0;

   441

		_m[i].m5          = 3;

   442

		_m[i].extra       = 0;

   443

	}

   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

			_m[tile].m5 = 0;

   461

			SetTileOwner(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 Sprite* template;

   477

	const byte *p;

   478

	Tile* tile;

   479

	byte direction;

   480

   481

	r = Random();

   482

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

   483

   484

	x = r & MapMaxX();

   485

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

   486

   487

   488

	if (x < 2 || y < 2)

   489

		return;

   490

   491

	direction = GB(r, 22, 2);

   492

	if (direction & 1) {

   493

		w = template->height;

   494

		h = template->width;

   495

	} else {

   496

		w = template->width;

   497

		h = template->height;

   498

	}

   499

	p = template->data;

   500

   501

	if (flag & 4) {

   502

		uint xw = x * MapSizeY();

   503

		uint yw = y * MapSizeX();

   504

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

   505

   506

		switch (flag & 3) {