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

    23

extern const TileTypeProcs

    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

const TileTypeProcs * const _tile_type_procs[16] = {

    37

	&_tile_type_clear_procs,

    38

	&_tile_type_rail_procs,

    39

	&_tile_type_road_procs,

    40

	&_tile_type_town_procs,

    41

	&_tile_type_trees_procs,

    42

	&_tile_type_station_procs,

    43

	&_tile_type_water_procs,

    44

	&_tile_type_dummy_procs,

    45

	&_tile_type_industry_procs,

    46

	&_tile_type_tunnelbridge_procs,

    47

	&_tile_type_unmovable_procs,

    48

};

    49

    50

/* landscape slope => sprite */

    51

const byte _tileh_to_sprite[32] = {

    52

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

    53

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

    54

};

    55

    56

const byte _inclined_tileh[] = {

    57

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

    58

	SLOPE_E,   SLOPE_N,   SLOPE_W,   SLOPE_S,

    59

	SLOPE_NWS, SLOPE_WSE, SLOPE_SEN, SLOPE_ENW

    60

};

    61

    62

    63

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

    64

{

    65

	int z = 0;

    66

    67

	switch (corners) {

    68

	case SLOPE_W:

    69

		if (x - y >= 0)

    70

			z = (x - y) >> 1;

    71

		break;

    72

    73

	case SLOPE_S:

    74

		y^=0xF;

    75

		if ( (x - y) >= 0)

    76

			z = (x - y) >> 1;

    77

		break;

    78

    79

	case SLOPE_SW:

    80

		z = (x>>1) + 1;

    81

		break;

    82

    83

	case SLOPE_E:

    84

		if (y - x >= 0)

    85

			z = (y - x) >> 1;

    86

		break;

    87

    88

	case SLOPE_EW:

    89

	case SLOPE_NS:

    90

	case SLOPE_ELEVATED:

    91

		z = 4;

    92

		break;

    93

    94

	case SLOPE_SE:

    95

		z = (y>>1) + 1;

    96

		break;

    97

    98

	case SLOPE_WSE:

    99

		z = 8;

   100

		y^=0xF;

   101

		if (x - y < 0)

   102

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

   103

		break;

   104

   105

	case SLOPE_N:

   106

		y ^= 0xF;

   107

		if (y - x >= 0)

   108

			z = (y - x) >> 1;

   109

		break;

   110

   111

	case SLOPE_NW:

   112

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

   113

		break;

   114

   115

	case SLOPE_NWS:

   116

		z = 8;

   117

		if (x - y < 0)

   118

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

   119

		break;

   120

   121

	case SLOPE_NE:

   122

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

   123

		break;

   124

   125

	case SLOPE_ENW:

   126

		z = 8;

   127

		y ^= 0xF;

   128

		if (y - x < 0)

   129

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

   130

		break;

   131

   132

	case SLOPE_SEN:

   133

		z = 8;

   134

		if (y - x < 0)

   135

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

   136

		break;

   137

   138

	case SLOPE_STEEP_S:

   139

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

   140

		break;

   141

   142

	case SLOPE_STEEP_W:

   143

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

   144

		break;

   145

   146

	case SLOPE_STEEP_N:

   147

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

   148

		break;

   149

   150

	case SLOPE_STEEP_E:

   151

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

   152

		break;

   153

   154

		default: break;

   155

	}

   156

   157

	return z;

   158

}

   159

   160

uint GetSlopeZ(int x, int y)

   161

{

   162

	TileIndex tile = TileVirtXY(x, y);

   163

   164

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

   165

}

   166

   167

   168

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   169

{

   170

	Slope tileh = GetTileSlope(tile, z);

   171

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

   172

   173

	// Flatter slope -> higher base height

   174

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

   175

	return slope;

   176

}

   177

   178

   179

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

   180

{

   181

	uint z;

   182

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

   183

   184

	return

   185

		(

   186

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

   187

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

   188

		) || (

   189

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

   190

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

   191

		);

   192

}

   193

   194

   195

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

   196

{

   197

	uint z;

   198

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

   199

   200

	return

   201

		(

   202

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

   203

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

   204

		) || (

   205

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

   206

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

   207

		);

   208

}

   209

   210

   211

void DrawFoundation(TileInfo *ti, uint f)

   212

{

   213

	uint32 sprite_base = SPR_SLOPES_BASE - 15;

   214

	Slope slope;

   215

	uint z;

   216

   217

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

   218

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

   219

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

   220

   221

	if (IsSteepSlope(ti->tileh)) {

   222

		uint32 lower_base;

   223

   224

		// Lower part of foundation

   225

		lower_base = sprite_base;

   226

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

   227

		AddSortableSpriteToDraw(

   228

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

   229

		);

   230

		ti->z += TILE_HEIGHT;

   231

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

   232

		if (f < 15 + 8) {

   233

			// inclined

   234

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

   235

			OffsetGroundSprite(31, 9);

   236

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

   237

			// three corners raised

   238

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

   239

   240

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

   241

			AddChildSpriteScreen(upper + 1, 31, 9);

   242

			OffsetGroundSprite(31, 9);

   243

		} else {

   244

			// one corner raised

   245

			OffsetGroundSprite(31, 1);

   246

		}

   247

	} else {

   248

		if (f < 15) {

   249

			// leveled foundation

   250

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

   251

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

   252

   253

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

   254

			ti->z += TILE_HEIGHT;

   255

			ti->tileh = SLOPE_FLAT;

   256

			OffsetGroundSprite(31, 1);

   257

		} else {

   258

			// inclined foundation

   259

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

   260

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

   261

			OffsetGroundSprite(31, 9);

   262

		}

   263

	}

   264

}

   265

   266

void DoClearSquare(TileIndex tile)

   267

{

   268

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

   269

	MarkTileDirtyByTile(tile);

   270

}

   271

   272

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode)

   273

{

   274

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

   275

}

   276

   277

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

   278

{

   279

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

   280

}

   281

   282

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   283

{

   284

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

   285

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

   286

}

   287

   288

void AnimateTile(TileIndex tile)

   289

{

   290

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

   291

}

   292

   293

void ClickTile(TileIndex tile)

   294

{

   295

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

   296

}

   297

   298

void GetTileDesc(TileIndex tile, TileDesc *td)

   299

{

   300

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

   301

}

   302

   303

/** Clear a piece of landscape

   304

 * @param tile tile to clear

   305

 * @param p1 unused

   306

 * @param p2 unused

   307

 */

   308

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

   309

{

   310

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   311

   312

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

   313

}

   314

   315

/** Clear a big piece of landscape

   316

 * @param tile end tile of area dragging

   317

 * @param p1 start tile of area dragging

   318

 * @param p2 unused

   319

 */

   320

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

   321

{

   322

	int32 cost, ret, money;

   323

	int ex;

   324

	int ey;

   325

	int sx,sy;

   326

	int x,y;

   327

	bool success = false;

   328

   329

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

   330

   331

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   332

   333

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

   334

	ex = TileX(tile);

   335

	ey = TileY(tile);

   336

	sx = TileX(p1);

   337

	sy = TileY(p1);

   338

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

   339

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

   340

   341

	money = GetAvailableMoneyForCommand();

   342

	cost = 0;

   343

   344

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

   345

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

   346

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

   347

			if (CmdFailed(ret)) continue;

   348

			cost += ret;

   349

			success = true;

   350

   351

			if (flags & DC_EXEC) {

   352

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

   353

					_additional_cash_required = ret;

   354

					return cost - ret;

   355

				}

   356

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

   357

   358

				// draw explosion animation...

   359

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

   360

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

   361

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

   362

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

   363

					);

   364

				}

   365

			}

   366

		}

   367

	}

   368

   369

	return (success) ? cost : CMD_ERROR;

   370

}

   371

   372

   373

#define TILELOOP_BITS 4

   374

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   375

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

   376

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

   377

   378

void RunTileLoop(void)

   379

{

   380

	TileIndex tile;

   381

	uint count;

   382

   383

	tile = _cur_tileloop_tile;

   384

   385

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

   386

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

   387

	do {

   388

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

   389

   390

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

   391

			tile += TILELOOP_SIZE; /* no overflow */

   392

		} else {

   393

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

   394

		}

   395

	} while (--count);

   396

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

   397

   398

	tile += 9;

   399

	if (tile & TILELOOP_CHKMASK)

   400

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

   401

	_cur_tileloop_tile = tile;

   402

}

   403

   404

void InitializeLandscape(void)

   405

{

   406

	uint maxx = MapMaxX();

   407

	uint maxy = MapMaxY();

   408

	uint sizex = MapSizeX();

   409

	uint x;

   410

	uint y;

   411

   412

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

   413

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

   414

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

   415

			SetTileHeight(sizex * y + x, 0);

   416

		}

   417

		MakeVoid(sizex * y + x);

   418

	}

   419

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

   420

}

   421

   422

void ConvertGroundTilesIntoWaterTiles(void)

   423

{

   424

	TileIndex tile;

   425

	uint z;

   426

	Slope slope;

   427

   428

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

   429

		slope = GetTileSlope(tile, &z);

   430

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

   431

			/* Make both water for tiles at level 0

   432

			 * and make shore, as that looks much better

   433

			 * during the generation. */

   434

			switch (slope) {

   435

				case SLOPE_FLAT:

   436

					MakeWater(tile);

   437

					break;

   438

   439

				case SLOPE_N:

   440

				case SLOPE_E:

   441

				case SLOPE_S:

   442

				case SLOPE_W:

   443

				case SLOPE_NW:

   444

				case SLOPE_SW:

   445

				case SLOPE_SE:

   446

				case SLOPE_NE:

   447

					MakeShore(tile);

   448

					break;

   449

   450

				default:

   451

					break;

   452

			}

   453

		}

   454

	}

   455

}

   456

   457

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

   458

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

   459

   460

static void GenerateTerrain(int type, int flag)

   461

{

   462

	uint32 r;

   463

	uint x;

   464

	uint y;

   465

	uint w;

   466

	uint h;

   467

	const Sprite* template;

   468

	const byte *p;

   469

	Tile* tile;

   470

	byte direction;

   471

   472

	r = Random();

   473

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

   474

   475

	x = r & MapMaxX();

   476

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

   477

   478

   479

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

   480

   481

	direction = GB(r, 22, 2);

   482

	if (direction & 1) {

   483

		w = template->height;

   484

		h = template->width;

   485

	} else {

   486

		w = template->width;

   487

		h = template->height;

   488

	}

   489

	p = template->data;

   490

   491

	if (flag & 4) {

   492

		uint xw = x * MapSizeY();

   493

		uint yw = y * MapSizeX();

   494

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

   495

   496

		switch (flag & 3) {