1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "bridge_map.h"

     6

#include "heightmap.h"

     7

#include "clear_map.h"

     8

#include "functions.h"

     9

#include "map.h"

    10

#include "player.h"

    11

#include "spritecache.h"

    12

#include "table/sprites.h"

    13

#include "tile.h"

    14

#include <stdarg.h>

    15

#include "viewport.h"

    16

#include "command.h"

    17

#include "vehicle.h"

    18

#include "variables.h"

    19

#include "void_map.h"

    20

#include "water_map.h"

    21

#include "tgp.h"

    22

#include "genworld.h"

    23

#include "heightmap.h"

    24

    25

extern const TileTypeProcs

    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_tunnel_procs,

    36

	_tile_type_unmovable_procs,

    37

	_tile_type_bridge_procs,

    38

	_tile_type_bridge_procs;

    39

    40

const TileTypeProcs * const _tile_type_procs[16] = {

    41

	&_tile_type_clear_procs,

    42

	&_tile_type_rail_procs,

    43

	&_tile_type_road_procs,

    44

	&_tile_type_town_procs,

    45

	&_tile_type_trees_procs,

    46

	&_tile_type_station_procs,

    47

	&_tile_type_water_procs,

    48

	&_tile_type_dummy_procs,

    49

	&_tile_type_industry_procs,

    50

	&_tile_type_tunnel_procs,

    51

	&_tile_type_unmovable_procs,

    52

	&_tile_type_bridge_procs,

    53

	&_tile_type_bridge_procs,

    54

	NULL,

    55

	NULL,

    56

	NULL

    57

};

    58

    59

/* landscape slope => sprite */

    60

const byte _tileh_to_sprite[32] = {

    61

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

    62

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

    63

};

    64

    65

const byte _inclined_tileh[] = {

    66

	SLOPE_SW,  SLOPE_NW,  SLOPE_SW,  SLOPE_SE, SLOPE_NE, SLOPE_SE, SLOPE_NE, SLOPE_NW,

    67

	SLOPE_E,   SLOPE_N,   SLOPE_W,   SLOPE_S,

    68

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    69

};

    70

    71

    72

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

    73

{

    74

	int z = 0;

    75

    76

	switch (corners) {

    77

	case SLOPE_W:

    78

		if (x - y >= 0)

    79

			z = (x - y) >> 1;

    80

		break;

    81

    82

	case SLOPE_S:

    83

		y^=0xF;

    84

		if ( (x - y) >= 0)

    85

			z = (x - y) >> 1;

    86

		break;

    87

    88

	case SLOPE_SW:

    89

		z = (x>>1) + 1;

    90

		break;

    91

    92

	case SLOPE_E:

    93

		if (y - x >= 0)

    94

			z = (y - x) >> 1;

    95

		break;

    96

    97

	case SLOPE_EW:

    98

	case SLOPE_NS:

    99

	case SLOPE_ELEVATED:

   100

		z = 4;

   101

		break;

   102

   103

	case SLOPE_SE:

   104

		z = (y>>1) + 1;

   105

		break;

   106

   107

	case SLOPE_WSE:

   108

		z = 8;

   109

		y^=0xF;

   110

		if (x - y < 0)

   111

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

   112

		break;

   113

   114

	case SLOPE_N:

   115

		y ^= 0xF;

   116

		if (y - x >= 0)

   117

			z = (y - x) >> 1;

   118

		break;

   119

   120

	case SLOPE_NW:

   121

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

   122

		break;

   123

   124

	case SLOPE_NWS:

   125

		z = 8;

   126

		if (x - y < 0)

   127

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

   128

		break;

   129

   130

	case SLOPE_NE:

   131

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

   132

		break;

   133

   134

	case SLOPE_ENW:

   135

		z = 8;

   136

		y ^= 0xF;

   137

		if (y - x < 0)

   138

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

   139

		break;

   140

   141

	case SLOPE_SEN:

   142

		z = 8;

   143

		if (y - x < 0)

   144

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

   145

		break;

   146

   147

	case SLOPE_STEEP_S:

   148

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

   149

		break;

   150

   151

	case SLOPE_STEEP_W:

   152

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

   153

		break;

   154

   155

	case SLOPE_STEEP_N:

   156

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

   157

		break;

   158

   159

	case SLOPE_STEEP_E:

   160

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

   161

		break;

   162

   163

		default: break;

   164

	}

   165

   166

	return z;

   167

}

   168

   169

uint GetSlopeZ(int x, int y)

   170

{

   171

	TileIndex tile = TileVirtXY(x, y);

   172

   173

	return _tile_type_procs[GetTileType(tile)]->get_slope_z_proc(tile, x, y);

   174

}

   175

   176

   177

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   178

{

   179

	Slope tileh = GetTileSlope(tile, z);

   180

	Slope slope = _tile_type_procs[GetTileType(tile)]->get_slope_tileh_proc(tile, tileh);

   181

   182

	// Flatter slope -> higher base height

   183

	if (slope < tileh) *z += TILE_HEIGHT;

   184

	return slope;

   185

}

   186

   187

   188

static bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)

   189

{

   190

	uint z;

   191

	Slope slope = GetFoundationSlope(TILE_ADDXY(tile, 0, -1), &z);

   192

   193

	return

   194

		(

   195

			z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_N ? TILE_HEIGHT : 0) >

   196

			z      + (slope      & SLOPE_E ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_E ? TILE_HEIGHT : 0)

   197

		) || (

   198

			z_here + (slope_here & SLOPE_W ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_W ? TILE_HEIGHT : 0) >

   199

			z      + (slope      & SLOPE_S ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_S ? TILE_HEIGHT : 0)

   200

		);

   201

}

   202

   203

   204

static bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)

   205

{

   206

	uint z;

   207

	Slope slope = GetFoundationSlope(TILE_ADDXY(tile, -1, 0), &z);

   208

   209

	return

   210

		(

   211

			z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_N ? TILE_HEIGHT : 0) >

   212

			z      + (slope      & SLOPE_W ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_W ? TILE_HEIGHT : 0)

   213

		) || (

   214

			z_here + (slope_here & SLOPE_E ? TILE_HEIGHT : 0) + (slope_here == SLOPE_STEEP_E ? TILE_HEIGHT : 0) >

   215

			z      + (slope      & SLOPE_S ? TILE_HEIGHT : 0) + (slope      == SLOPE_STEEP_S ? TILE_HEIGHT : 0)

   216

		);

   217

}

   218

   219

   220

void DrawFoundation(TileInfo *ti, uint f)

   221

{

   222

	uint32 sprite_base = SPR_SLOPES_BASE - 15;

   223

	Slope slope;

   224

	uint z;

   225

   226

	slope = GetFoundationSlope(ti->tile, &z);

   227

	if (!HasFoundationNW(ti->tile, slope, z)) sprite_base += 22;

   228

	if (!HasFoundationNE(ti->tile, slope, z)) sprite_base += 44;

   229

   230

	if (IsSteepSlope(ti->tileh)) {

   231

		uint32 lower_base;

   232

   233

		// Lower part of foundation

   234

		lower_base = sprite_base;

   235

		if (lower_base == SPR_SLOPES_BASE - 15) lower_base = SPR_FOUNDATION_BASE;

   236

		AddSortableSpriteToDraw(

   237

			lower_base + (ti->tileh & ~SLOPE_STEEP), ti->x, ti->y, 16, 16, 7, ti->z

   238

		);

   239

		ti->z += TILE_HEIGHT;

   240

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

   241

		if (f < 15 + 8) {

   242

			// inclined

   243

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

   244

			OffsetGroundSprite(31, 9);

   245

		} else if (f >= 15 + 8 + 4) {

   246

			// three corners raised

   247

			uint32 upper = sprite_base + 15 + (f - 15 - 8 - 4) * 2;

   248

   249

			AddSortableSpriteToDraw(upper, ti->x, ti->y, 16, 16, 1, ti->z);

   250

			AddChildSpriteScreen(upper + 1, 31, 9);

   251

			OffsetGroundSprite(31, 9);

   252

		} else {

   253

			// one corner raised

   254

			OffsetGroundSprite(31, 1);

   255

		}

   256

	} else {

   257

		if (f < 15) {

   258

			// leveled foundation

   259

			// Use the original slope sprites if NW and NE borders should be visible

   260

			if (sprite_base  == SPR_SLOPES_BASE - 15) sprite_base = SPR_FOUNDATION_BASE;

   261

   262

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

   263

			ti->z += TILE_HEIGHT;

   264

			ti->tileh = SLOPE_FLAT;

   265

			OffsetGroundSprite(31, 1);

   266

		} else {

   267

			// inclined foundation

   268

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

   269

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

   270

			OffsetGroundSprite(31, 9);

   271

		}

   272

	}

   273

}

   274

   275

void DoClearSquare(TileIndex tile)

   276

{

   277

	MakeClear(tile, CLEAR_GRASS, _generating_world ? 3 : 0);

   278

	MarkTileDirtyByTile(tile);

   279

}

   280

   281

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   282

{

   283

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

   284

}

   285

   286

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

   287

{

   288

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

   289

}

   290

   291

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   292

{

   293

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

   294

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

   295

}

   296

   297

void AnimateTile(TileIndex tile)

   298

{

   299

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

   300

}

   301

   302

void ClickTile(TileIndex tile)

   303

{

   304

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

   305

}

   306

   307

void GetTileDesc(TileIndex tile, TileDesc *td)

   308

{

   309

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

   310

}

   311

   312

/** Clear a piece of landscape

   313

 * @param tile tile to clear

   314

 * @param p1 unused

   315

 * @param p2 unused

   316

 */

   317

int32 CmdLandscapeClear(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   318

{

   319

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   320

   321

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

   322

}

   323

   324

/** Clear a big piece of landscape

   325

 * @param tile end tile of area dragging

   326

 * @param p1 start tile of area dragging

   327

 * @param p2 unused

   328

 */

   329

int32 CmdClearArea(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   330

{

   331

	int32 cost, ret, money;

   332

	int ex;

   333

	int ey;

   334

	int sx,sy;

   335

	int x,y;

   336

	bool success = false;

   337

   338

	if (p1 >= MapSize()) return CMD_ERROR;

   339

   340

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   341

   342

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

   343

	ex = TileX(tile);

   344

	ey = TileY(tile);

   345

	sx = TileX(p1);

   346

	sy = TileY(p1);

   347

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

   348

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

   349

   350

	money = GetAvailableMoneyForCommand();

   351

	cost = 0;

   352

   353

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

   354

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

   355

			ret = DoCommand(TileXY(x, y), 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);

   356

			if (CmdFailed(ret)) continue;

   357

			cost += ret;

   358

			success = true;

   359

   360

			if (flags & DC_EXEC) {

   361

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

   362

					_additional_cash_required = ret;

   363

					return cost - ret;

   364

				}

   365

				DoCommand(TileXY(x, y), 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   366

   367

				// draw explosion animation...

   368

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

   369

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

   370

					CreateEffectVehicleAbove(x * TILE_SIZE + TILE_SIZE / 2, y * TILE_SIZE + TILE_SIZE / 2, 2,

   371

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

   372

					);

   373

				}

   374

			}

   375

		}

   376

	}

   377

   378

	return (success) ? cost : CMD_ERROR;

   379

}

   380

   381

   382

#define TILELOOP_BITS 4

   383

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   384

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

   385

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

   386

   387

void RunTileLoop(void)

   388

{

   389

	TileIndex tile;

   390

	uint count;

   391

   392

	tile = _cur_tileloop_tile;

   393

   394

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

   395

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

   396

	do {

   397

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

   398

   399

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

   400

			tile += TILELOOP_SIZE; /* no overflow */

   401

		} else {

   402

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

   403

		}

   404

	} while (--count);

   405

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

   406

   407

	tile += 9;

   408

	if (tile & TILELOOP_CHKMASK)

   409

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

   410

	_cur_tileloop_tile = tile;

   411

}

   412

   413

void InitializeLandscape(void)

   414

{

   415

	uint maxx = MapMaxX();

   416

	uint maxy = MapMaxY();

   417

	uint sizex = MapSizeX();

   418

	uint x;

   419

	uint y;

   420

   421

	for (y = 0; y < maxy; y++) {

   422

		for (x = 0; x < maxx; x++) {

   423

			MakeClear(sizex * y + x, CLEAR_GRASS, 3);

   424

			SetTileHeight(sizex * y + x, 0);

   425

			_m[sizex * y + x].extra = 0;

   426

			ClearBridgeMiddle(sizex * y + x);

   427

		}

   428

		MakeVoid(sizex * y + x);

   429

	}

   430

	for (x = 0; x < sizex; x++) MakeVoid(sizex * y + x);

   431

}

   432

   433

void ConvertGroundTilesIntoWaterTiles(void)

   434

{

   435

	TileIndex tile;

   436

	uint z;

   437

	Slope slope;

   438

   439

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

   440

		slope = GetTileSlope(tile, &z);

   441

		if (IsTileType(tile, MP_CLEAR) && z == 0) {

   442

			/* Make both water for tiles at level 0

   443

			 * and make shore, as that looks much better

   444

			 * during the generation. */

   445

			switch (slope) {

   446

				case SLOPE_FLAT:

   447

					MakeWater(tile);

   448

					break;

   449

   450

				case SLOPE_N:

   451

				case SLOPE_E:

   452

				case SLOPE_S:

   453

				case SLOPE_W:

   454

				case SLOPE_NW:

   455

				case SLOPE_SW:

   456

				case SLOPE_SE:

   457

				case SLOPE_NE:

   458

					MakeShore(tile);

   459

					break;

   460

   461

				default:

   462

					break;

   463

			}

   464

		}

   465

	}

   466

}

   467

   468

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

   469

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

   470

   471

static void GenerateTerrain(int type, int flag)

   472

{

   473

	uint32 r;

   474

	uint x;

   475

	uint y;

   476

	uint w;

   477

	uint h;

   478

	const Sprite* template;

   479

	const byte *p;

   480

	Tile* tile;

   481

	byte direction;

   482

   483

	r = Random();

   484

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

   485

   486

	x = r & MapMaxX();

   487

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

   488

   489

   490

	if (x < 2 || y < 2) return;

   491

   492

	direction = GB(r, 22, 2);

   493

	if (direction & 1) {

   494

		w = template->height;

   495

		h = template->width;