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 "date.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "player.h"

    12

#include "spritecache.h"

    13

#include "table/sprites.h"

    14

#include "tile.h"

    15

#include <stdarg.h>

    16

#include "viewport.h"

    17

#include "command.h"

    18

#include "landscape.h"

    19

#include "vehicle.h"

    20

#include "variables.h"

    21

#include "void_map.h"

    22

#include "water_map.h"

    23

#include "tgp.h"

    24

#include "genworld.h"

    25

    26

extern const TileTypeProcs

    27

	_tile_type_clear_procs,

    28

	_tile_type_rail_procs,

    29

	_tile_type_road_procs,

    30

	_tile_type_town_procs,

    31

	_tile_type_trees_procs,

    32

	_tile_type_station_procs,

    33

	_tile_type_water_procs,

    34

	_tile_type_dummy_procs,

    35

	_tile_type_industry_procs,

    36

	_tile_type_tunnelbridge_procs,

    37

	_tile_type_unmovable_procs;

    38

    39

const TileTypeProcs * const _tile_type_procs[16] = {

    40

	&_tile_type_clear_procs,

    41

	&_tile_type_rail_procs,

    42

	&_tile_type_road_procs,

    43

	&_tile_type_town_procs,

    44

	&_tile_type_trees_procs,

    45

	&_tile_type_station_procs,

    46

	&_tile_type_water_procs,

    47

	&_tile_type_dummy_procs,

    48

	&_tile_type_industry_procs,

    49

	&_tile_type_tunnelbridge_procs,

    50

	&_tile_type_unmovable_procs,

    51

};

    52

    53

/* landscape slope => sprite */

    54

const byte _tileh_to_sprite[32] = {

    55

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

    56

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

    57

};

    58

    59

SnowLine *_snow_line = NULL;

    60

    61

/**

    62

 * Applys a foundation to a slope.

    63

 *

    64

 * @pre      Foundation and slope must be valid combined.

    65

 * @param f  The #Foundation.

    66

 * @param s  The #Slope to modify.

    67

 * @return   Increment to the tile Z coordinate.

    68

 */

    69

uint ApplyFoundationToSlope(Foundation f, Slope *s)

    70

{

    71

    72

	if (!IsFoundation(f)) return 0;

    73

    74

	if (IsLeveledFoundation(f)) {

    75

		*s = SLOPE_FLAT;

    76

		return TILE_HEIGHT;

    77

	}

    78

    79

	uint dz = IsSteepSlope(*s) ? TILE_HEIGHT : 0;

    80

	byte highest_corner = GetHighestSlopeCorner(*s);

    81

    82

	switch (f) {

    83

		case FOUNDATION_INCLINED_X:

    84

			*s = (highest_corner <= 1 ? SLOPE_SW : SLOPE_NE);

    85

			break;

    86

    87

		case FOUNDATION_INCLINED_Y:

    88

			*s = (((highest_corner == 1) || (highest_corner == 2)) ? SLOPE_SE : SLOPE_NW);

    89

			break;

    90

    91

		case FOUNDATION_STEEP_LOWER:

    92

			*s = (Slope) (1 << highest_corner);

    93

			break;

    94

    95

		case FOUNDATION_STEEP_HIGHER:

    96

			*s = (Slope) (*s & ~SLOPE_STEEP);

    97

			break;

    98

    99

		default: NOT_REACHED();

   100

	}

   101

	return dz;

   102

}

   103

   104

   105

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

   106

{

   107

	int z = 0;

   108

   109

	switch (corners) {

   110

	case SLOPE_W:

   111

		if (x - y >= 0)

   112

			z = (x - y) >> 1;

   113

		break;

   114

   115

	case SLOPE_S:

   116

		y ^= 0xF;

   117

		if ( (x - y) >= 0)

   118

			z = (x - y) >> 1;

   119

		break;

   120

   121

	case SLOPE_SW:

   122

		z = (x >> 1) + 1;

   123

		break;

   124

   125

	case SLOPE_E:

   126

		if (y - x >= 0)

   127

			z = (y - x) >> 1;

   128

		break;

   129

   130

	case SLOPE_EW:

   131

	case SLOPE_NS:

   132

	case SLOPE_ELEVATED:

   133

		z = 4;

   134

		break;

   135

   136

	case SLOPE_SE:

   137

		z = (y >> 1) + 1;

   138

		break;

   139

   140

	case SLOPE_WSE:

   141

		z = 8;

   142

		y ^= 0xF;

   143

		if (x - y < 0)

   144

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

   145

		break;

   146

   147

	case SLOPE_N:

   148

		y ^= 0xF;

   149

		if (y - x >= 0)

   150

			z = (y - x) >> 1;

   151

		break;

   152

   153

	case SLOPE_NW:

   154

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

   155

		break;

   156

   157

	case SLOPE_NWS:

   158

		z = 8;

   159

		if (x - y < 0)

   160

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

   161

		break;

   162

   163

	case SLOPE_NE:

   164

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

   165

		break;

   166

   167

	case SLOPE_ENW:

   168

		z = 8;

   169

		y ^= 0xF;

   170

		if (y - x < 0)

   171

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

   172

		break;

   173

   174

	case SLOPE_SEN:

   175

		z = 8;

   176

		if (y - x < 0)

   177

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

   178

		break;

   179

   180

	case SLOPE_STEEP_S:

   181

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

   182

		break;

   183

   184

	case SLOPE_STEEP_W:

   185

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

   186

		break;

   187

   188

	case SLOPE_STEEP_N:

   189

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

   190

		break;

   191

   192

	case SLOPE_STEEP_E:

   193

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

   194

		break;

   195

   196

		default: break;

   197

	}

   198

   199

	return z;

   200

}

   201

   202

uint GetSlopeZ(int x, int y)

   203

{

   204

	TileIndex tile = TileVirtXY(x, y);

   205

   206

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

   207

}

   208

   209

   210

static Slope GetFoundationSlope(TileIndex tile, uint* z)

   211

{

   212

	Slope tileh = GetTileSlope(tile, z);

   213

	Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);

   214

	*z += ApplyFoundationToSlope(f, &tileh);

   215

	return tileh;

   216

}

   217

   218

   219

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

   220

{

   221

	uint z;

   222

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

   223

   224

	return

   225

		(

   226

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

   227

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

   228

		) || (

   229

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

   230

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

   231

		);

   232

}

   233

   234

   235

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

   236

{

   237

	uint z;

   238

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

   239

   240

	return

   241

		(

   242

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

   243

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

   244

		) || (

   245

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

   246

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

   247

		);

   248

}

   249

   250

   251

void DrawFoundation(TileInfo *ti, Foundation f)

   252

{

   253

	if (!IsFoundation(f)) return;

   254

   255

	SpriteID sprite_base = SPR_SLOPES_VIRTUAL_BASE;

   256

	uint z;

   257

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

   258

   259

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

   260

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

   261

   262

	if (IsSteepSlope(ti->tileh)) {

   263

		SpriteID lower_base;

   264

   265

		/* Lower part of foundation

   266

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

   267

		 */

   268

		lower_base = sprite_base;

   269

		if (lower_base == SPR_SLOPES_VIRTUAL_BASE) lower_base = SPR_FOUNDATION_BASE;

   270

		AddSortableSpriteToDraw(

   271

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

   272

		);

   273

   274

		byte highest_corner = GetHighestSlopeCorner(ti->tileh);

   275

		ti->z += ApplyFoundationToSlope(f, &ti->tileh);

   276

   277

		if (IsInclinedFoundation(f)) {

   278

			/* inclined foundation */

   279

			byte inclined = highest_corner * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);

   280

   281

			AddSortableSpriteToDraw(sprite_base + SPR_SLOPES_INCLINED_OFFSET + inclined, PAL_NONE, ti->x, ti->y, 16, 16, 1, ti->z);

   282

			OffsetGroundSprite(31, 9);

   283

		} else if (f >= FOUNDATION_STEEP_HIGHER) {

   284

			/* three corners raised:

   285

			 * Draw inclined foundations for both axes, that results in the needed image.

   286

			 */

   287

			SpriteID upper = sprite_base + SPR_SLOPES_INCLINED_OFFSET + highest_corner * 2;

   288

   289

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

   290

			AddChildSpriteScreen(upper + 1, PAL_NONE, 31, 9);

   291

			OffsetGroundSprite(31, 9);

   292

		} else {

   293

			/* one corner raised */

   294

			OffsetGroundSprite(31, 1);

   295

		}

   296

	} else {

   297

		if (IsLeveledFoundation(f)) {

   298

			/* leveled foundation

   299

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

   300

			 */

   301

			if (sprite_base == SPR_SLOPES_VIRTUAL_BASE) sprite_base = SPR_FOUNDATION_BASE;

   302

   303

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

   304

			OffsetGroundSprite(31, 1);

   305

		} else {

   306

			/* inclined foundation */

   307

			byte inclined = GetHighestSlopeCorner(ti->tileh) * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);

   308

   309

			AddSortableSpriteToDraw(sprite_base + SPR_SLOPES_INCLINED_OFFSET + inclined, PAL_NONE, ti->x, ti->y, 16, 16, 1, ti->z);

   310

			OffsetGroundSprite(31, 9);

   311

		}

   312

		ti->z += ApplyFoundationToSlope(f, &ti->tileh);

   313

	}

   314

}

   315

   316

void DoClearSquare(TileIndex tile)

   317

{

   318

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

   319

	MarkTileDirtyByTile(tile);

   320

}

   321

   322

uint32 GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode)

   323

{

   324

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

   325

}

   326

   327

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

   328

{

   329

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

   330

}

   331

   332

void GetAcceptedCargo(TileIndex tile, AcceptedCargo ac)

   333

{

   334

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

   335

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

   336

}

   337

   338

void AnimateTile(TileIndex tile)

   339

{

   340

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

   341

}

   342

   343

void ClickTile(TileIndex tile)

   344

{

   345

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

   346

}

   347

   348

void GetTileDesc(TileIndex tile, TileDesc *td)

   349

{

   350

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

   351

}

   352

   353

/**

   354

 * Has a snow line table already been loaded.

   355

 * @return true if the table has been loaded already.

   356

 */

   357

bool IsSnowLineSet(void)

   358

{

   359

	return _snow_line != NULL;

   360

}

   361

   362

/**

   363

 * Set a variable snow line, as loaded from a newgrf file.

   364

 * @param table the 12 * 32 byte table containing the snowline for each day

   365

 */

   366

void SetSnowLine(byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS])

   367

{

   368

	_snow_line = CallocT<SnowLine>(1);

   369

	memcpy(_snow_line->table, table, sizeof(_snow_line->table));

   370

   371

	for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {

   372

		for (uint j = 0; j < SNOW_LINE_DAYS; j++) {

   373

			_snow_line->highest_value = max(_snow_line->highest_value, table[i][j]);

   374

		}

   375

	}

   376

}

   377

   378

/**

   379

 * Get the current snow line, either variable or static.

   380

 * @return the snow line height.

   381

 */

   382

byte GetSnowLine(void)

   383

{

   384

	if (_snow_line == NULL) return _opt.snow_line;

   385

   386

	YearMonthDay ymd;

   387

	ConvertDateToYMD(_date, &ymd);

   388

	return _snow_line->table[ymd.month][ymd.day];

   389

}

   390

   391

/**

   392

 * Get the highest possible snow line height, either variable or static.

   393

 * @return the highest snow line height.

   394

 */

   395

byte HighestSnowLine(void)

   396

{

   397

	return _snow_line == NULL ? _opt.snow_line : _snow_line->highest_value;

   398

}

   399

   400

/**

   401

 * Clear the variable snow line table and free the memory.

   402

 */

   403

void ClearSnowLine(void)

   404

{

   405

	free(_snow_line);

   406

	_snow_line = NULL;

   407

}

   408

   409

/** Clear a piece of landscape

   410

 * @param tile tile to clear

   411

 * @param flags of operation to conduct

   412

 * @param p1 unused

   413

 * @param p2 unused

   414

 */

   415

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

   416

{

   417

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   418

   419

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

   420

}

   421

   422

/** Clear a big piece of landscape

   423

 * @param tile end tile of area dragging

   424

 * @param p1 start tile of area dragging

   425

 * @param flags of operation to conduct

   426

 * @param p2 unused

   427

 */

   428

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

   429

{

   430

	CommandCost cost, ret, money;

   431

	int ex;

   432

	int ey;

   433

	int sx, sy;

   434

	int x, y;

   435

	bool success = false;

   436

   437

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

   438

   439

	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);

   440

   441

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

   442

	ex = TileX(tile);

   443

	ey = TileY(tile);

   444

	sx = TileX(p1);

   445

	sy = TileY(p1);

   446

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

   447

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

   448

   449

	money.AddCost(GetAvailableMoneyForCommand());

   450

   451

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

   452

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

   453

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

   454

			if (CmdFailed(ret)) continue;

   455

			success = true;

   456

   457

			if (flags & DC_EXEC) {

   458

				money.AddCost(-ret.GetCost());

   459

				if (ret.GetCost() > 0 && money.GetCost() < 0) {

   460

					_additional_cash_required = ret.GetCost();

   461

					return cost;

   462

				}

   463

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

   464

   465

				/* draw explosion animation... */

   466

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

   467

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

   468

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

   469

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

   470

					);

   471

				}

   472

			}

   473

			cost.AddCost(ret);

   474

		}

   475

	}

   476

   477

	return (success) ? cost : CMD_ERROR;

   478

}

   479

   480

   481

#define TILELOOP_BITS 4

   482

#define TILELOOP_SIZE (1 << TILELOOP_BITS)

   483

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

   484

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

   485

   486

void RunTileLoop()

   487

{

   488

	TileIndex tile;

   489

	uint count;

   490

   491

	tile = _cur_tileloop_tile;

   492

   493

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