1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "heightmap.h"

     6

#include "clear_map.h"

     7

#include "functions.h"

     8

#include "map.h"

     9

#include "player.h"

    10

#include "spritecache.h"

    11

#include "table/sprites.h"

    12

#include "tile.h"

    13

#include <stdarg.h>

    14

#include "viewport.h"

    15

#include "command.h"

    16

#include "vehicle.h"

    17

#include "variables.h"

    18

#include "void_map.h"

    19

#include "water_map.h"

    20

#include "tgp.h"

    21

#include "genworld.h"

    22

#include "heightmap.h"

    23

    24

extern const TileTypeProcs

    25

	_tile_type_clear_procs,

    26

	_tile_type_rail_procs,

    27

	_tile_type_road_procs,

    28

	_tile_type_town_procs,

    29

	_tile_type_trees_procs,

    30

	_tile_type_station_procs,

    31

	_tile_type_water_procs,

    32

	_tile_type_dummy_procs,

    33

	_tile_type_industry_procs,

    34

	_tile_type_tunnelbridge_procs,

    35

	_tile_type_unmovable_procs;

    36

    37

const TileTypeProcs * const _tile_type_procs[16] = {

    38

	&_tile_type_clear_procs,

    39

	&_tile_type_rail_procs,

    40

	&_tile_type_road_procs,

    41

	&_tile_type_town_procs,

    42

	&_tile_type_trees_procs,

    43

	&_tile_type_station_procs,

    44

	&_tile_type_water_procs,

    45

	&_tile_type_dummy_procs,

    46

	&_tile_type_industry_procs,

    47

	&_tile_type_tunnelbridge_procs,

    48

	&_tile_type_unmovable_procs,

    49

};

    50

    51

/* landscape slope => sprite */

    52

const byte _tileh_to_sprite[32] = {

    53

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

    54

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

    55

};

    56

    57

const byte _inclined_tileh[] = {

    58

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

    59

	SLOPE_E,   SLOPE_N,   SLOPE_W,   SLOPE_S,

    60

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    61

};

    62

    63

    64

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

    65

{

    66

	int z = 0;

    67

    68

	switch (corners) {

    69

	case SLOPE_W:

    70

		if (x - y >= 0)

    71

			z = (x - y) >> 1;

    72

		break;

    73

    74

	case SLOPE_S:

    75

		y^=0xF;

    76

		if ( (x - y) >= 0)

    77

			z = (x - y) >> 1;

    78

		break;

    79

    80

	case SLOPE_SW:

    81

		z = (x>>1) + 1;

    82

		break;

    83

    84

	case SLOPE_E:

    85

		if (y - x >= 0)

    86

			z = (y - x) >> 1;

    87

		break;

    88

    89

	case SLOPE_EW:

    90

	case SLOPE_NS:

    91

	case SLOPE_ELEVATED:

    92

		z = 4;

    93

		break;

    94

    95

	case SLOPE_SE:

    96

		z = (y>>1) + 1;

    97

		break;

    98

    99

	case SLOPE_WSE:

   100

		z = 8;

   101

		y^=0xF;

   102

		if (x - y < 0)

   103

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

   104

		break;

   105

   106

	case SLOPE_N:

   107

		y ^= 0xF;

   108

		if (y - x >= 0)

   109

			z = (y - x) >> 1;

   110

		break;

   111

   112

	case SLOPE_NW:

   113

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

   114

		break;

   115

   116

	case SLOPE_NWS:

   117

		z = 8;

   118

		if (x - y < 0)

   119

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

   120

		break;

   121

   122

	case SLOPE_NE:

   123

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

   124

		break;

   125

   126

	case SLOPE_ENW:

   127

		z = 8;

   128

		y ^= 0xF;

   129

		if (y - x < 0)

   130

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

   131

		break;

   132

   133

	case SLOPE_SEN:

   134

		z = 8;

   135

		if (y - x < 0)

   136

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

   137

		break;

   138

   139

	case SLOPE_STEEP_S:

   140

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

   141

		break;

   142

   143

	case SLOPE_STEEP_W:

   144

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

   145

		break;

   146

   147

	case SLOPE_STEEP_N:

   148

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

   149

		break;

   150

   151

	case SLOPE_STEEP_E:

   152

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

   153

		break;

   154

   155

		default: break;

   156

	}

   157

   158

	return z;

   159

}

   160

   161

uint GetSlopeZ(int x, int y)

   162

{

   163

	TileIndex tile = TileVirtXY(x, y);

   164

   165

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

   166

}

   167

   168

   169

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   170

{

   171

	Slope tileh = GetTileSlope(tile, z);

   172

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

   173

   174

	// Flatter slope -> higher base height

   175

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

   176

	return slope;

   177

}

   178

   179

   180

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

   181

{

   182

	uint z;

   183

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

   184

   185

	return

   186

		(z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) > z + (slope & SLOPE_E ? TILE_HEIGHT : 0)) ||

   187

		(z_here + (slope_here & SLOPE_W ? TILE_HEIGHT : 0) > z + (slope & SLOPE_S ? TILE_HEIGHT : 0));

   188

}

   189

   190

   191

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

   192

{

   193

	uint z;

   194

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

   195

   196

	return

   197

		(z_here + (slope_here & SLOPE_N ? TILE_HEIGHT : 0) > z + (slope & SLOPE_W ? TILE_HEIGHT : 0)) ||

   198

		(z_here + (slope_here & SLOPE_E ? TILE_HEIGHT : 0) > z + (slope & SLOPE_S ? TILE_HEIGHT : 0));

   199

}

   200

   201

   202

void DrawFoundation(TileInfo *ti, uint f)

   203

{

   204

	uint32 sprite_base = SPR_SLOPES_BASE - 15;

   205

	Slope slope;

   206

	uint z;

   207

   208

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

   209

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

   210

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

   211

   212

	if (IsSteepSlope(ti->tileh)) {

   213

		uint32 lower_base;

   214

   215

		// Lower part of foundation

   216

		lower_base = sprite_base;

   217

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

   218

		AddSortableSpriteToDraw(

   219

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

   220

		);

   221

		ti->z += TILE_HEIGHT;

   222

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

   223

		if (f < 15 + 8) {

   224

			// inclined

   225

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

   226

			OffsetGroundSprite(31, 9);

   227

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

   228

			// three corners raised

   229

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

   230

   231

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

   232

			AddChildSpriteScreen(upper + 1, 31, 9);

   233

			OffsetGroundSprite(31, 9);

   234

		} else {

   235

			// one corner raised

   236

			OffsetGroundSprite(31, 1);

   237

		}

   238

	} else {

   239

		if (f < 15) {

   240

			// leveled foundation

   241

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

   242

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

   243

   244

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

   245

			ti->z += TILE_HEIGHT;

   246

			ti->tileh = SLOPE_FLAT;

   247

			OffsetGroundSprite(31, 1);

   248

		} else {

   249

			// inclined foundation

   250

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

   251

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

   252

			OffsetGroundSprite(31, 9);

   253

		}

   254

	}

   255

}

   256

   257

void DoClearSquare(TileIndex tile)

   258

{

   259

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

   260

	MarkTileDirtyByTile(tile);

   261

}

   262

   263

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   264

{

   265

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

   266

}

   267

   268

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

   269

{

   270

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

   271

}

   272

   273

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   274

{

   275

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

   276

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

   277

}

   278

   279

void AnimateTile(TileIndex tile)

   280

{

   281

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

   282

}

   283

   284

void ClickTile(TileIndex tile)

   285

{

   286

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

   287

}

   288

   289

void GetTileDesc(TileIndex tile, TileDesc *td)

   290

{

   291

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

   292

}

   293

   294

/** Clear a piece of landscape

   295

 * @param tile tile to clear

   296

 * @param p1 unused

   297

 * @param p2 unused

   298

 */

   299

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

   300

{

   301

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   302

   303

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

   304

}

   305

   306

/** Clear a big piece of landscape

   307

 * @param tile end tile of area dragging

   308

 * @param p1 start tile of area dragging

   309

 * @param p2 unused

   310

 */

   311

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

   312

{

   313

	int32 cost, ret, money;

   314

	int ex;

   315

	int ey;

   316

	int sx,sy;

   317

	int x,y;

   318

	bool success = false;

   319

   320

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

   321

   322

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   323

   324

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

   325

	ex = TileX(tile);

   326

	ey = TileY(tile);

   327

	sx = TileX(p1);

   328

	sy = TileY(p1);

   329

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

   330

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

   331

   332

	money = GetAvailableMoneyForCommand();

   333

	cost = 0;

   334

   335

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

   336

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

   337

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

   338

			if (CmdFailed(ret)) continue;

   339

			cost += ret;

   340

			success = true;

   341

   342

			if (flags & DC_EXEC) {

   343

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

   344

					_additional_cash_required = ret;

   345

					return cost - ret;

   346

				}

   347

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

   348

   349

				// draw explosion animation...

   350

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

   351

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

   352

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

   353

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

   354

					);

   355

				}

   356

			}

   357

		}

   358

	}

   359

   360

	return (success) ? cost : CMD_ERROR;

   361

}

   362

   363

   364

#define TILELOOP_BITS 4

   365

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   366

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

   367

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

   368

   369

void RunTileLoop(void)

   370

{

   371

	TileIndex tile;

   372

	uint count;

   373

   374

	tile = _cur_tileloop_tile;

   375

   376

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

   377

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

   378

	do {

   379

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

   380

   381

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

   382

			tile += TILELOOP_SIZE; /* no overflow */

   383

		} else {

   384

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

   385

		}

   386

	} while (--count);

   387

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

   388

   389

	tile += 9;

   390

	if (tile & TILELOOP_CHKMASK)

   391

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

   392

	_cur_tileloop_tile = tile;

   393

}

   394

   395

void InitializeLandscape(void)

   396

{

   397

	uint maxx = MapMaxX();

   398

	uint maxy = MapMaxY();

   399

	uint sizex = MapSizeX();

   400

	uint x;

   401

	uint y;

   402

   403

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

   404

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

   405

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

   406

			SetTileHeight(sizex * y + x, 0);

   407

		}

   408

		MakeVoid(sizex * y + x);

   409

	}

   410

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

   411

}

   412

   413

void ConvertGroundTilesIntoWaterTiles(void)

   414

{

   415

	TileIndex tile;

   416

	uint z;

   417

	Slope slope;

   418

   419

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

   420

		slope = GetTileSlope(tile, &z);

   421

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

   422

			/* Make both water for tiles at level 0

   423

			 * and make shore, as that looks much better

   424

			 * during the generation. */

   425

			switch (slope) {

   426

				case SLOPE_FLAT:

   427

					MakeWater(tile);

   428

					break;

   429

   430

				case SLOPE_N:

   431

				case SLOPE_E:

   432

				case SLOPE_S:

   433

				case SLOPE_W:

   434

				case SLOPE_NW:

   435

				case SLOPE_SW:

   436

				case SLOPE_SE:

   437

				case SLOPE_NE:

   438

					MakeShore(tile);

   439

					break;

   440

   441

				default:

   442

					break;

   443

			}

   444

		}

   445

	}

   446

}

   447

   448

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

   449

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

   450

   451

static void GenerateTerrain(int type, int flag)

   452

{

   453

	uint32 r;

   454

	uint x;

   455

	uint y;

   456

	uint w;

   457

	uint h;

   458

	const Sprite* template;

   459

	const byte *p;

   460

	Tile* tile;

   461

	byte direction;

   462

   463

	r = Random();

   464

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

   465

   466

	x = r & MapMaxX();

   467

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

   468

   469

   470

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

   471

   472

	direction = GB(r, 22, 2);

   473

	if (direction & 1) {

   474

		w = template->height;

   475

		h = template->width;

   476

	} else {

   477

		w = template->width;

   478

		h = template->height;

   479

	}

   480

	p = template->data;

   481

   482

	if (flag & 4) {

   483

		uint xw = x * MapSizeY();

   484

		uint yw = y * MapSizeX();

   485

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

   486

   487

		switch (flag & 3) {

   488

			case 0:

   489

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

   490

				break;

   491

   492

			case 1:

   493

				if (yw < xw + bias) return;

   494

				break;

   495

   496

			case 2: