1

/* $Id$ */

     2

     3

/** @file clear_cmd.cpp Commands related to clear tiles. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "clear_map.h"

     8

#include "command_func.h"

     9

#include "bridge.h"

    10

#include "landscape.h"

    11

#include "variables.h"

    12

#include "unmovable_map.h"

    13

#include "genworld.h"

    14

#include "industry.h"

    15

#include "water_map.h"

    16

#include "tile_cmd.h"

    17

#include "functions.h"

    18

#include "economy_func.h"

    19

#include "viewport_func.h"

    20

#include "settings_type.h"

    21

    22

#include "table/strings.h"

    23

#include "table/sprites.h"

    24

#include "table/clear_land.h"

    25

    26

static CommandCost ClearTile_Clear(TileIndex tile, byte flags)

    27

{

    28

	static const Money* clear_price_table[] = {

    29

		&_price.clear_grass,

    30

		&_price.clear_roughland,

    31

		&_price.clear_rocks,

    32

		&_price.clear_fields,

    33

		&_price.clear_roughland,

    34

		&_price.clear_roughland,

    35

	};

    36

	CommandCost price(EXPENSES_CONSTRUCTION);

    37

    38

	if (!IsClearGround(tile, CLEAR_GRASS) || GetClearDensity(tile) != 0) {

    39

		price.AddCost(*clear_price_table[GetClearGround(tile)]);

    40

	}

    41

    42

	if (flags & DC_EXEC) DoClearSquare(tile);

    43

    44

	return price;

    45

}

    46

    47

void DrawClearLandTile(const TileInfo *ti, byte set)

    48

{

    49

	DrawGroundSprite(SPR_FLAT_BARE_LAND + _tileh_to_sprite[ti->tileh] + set * 19, PAL_NONE);

    50

}

    51

    52

void DrawHillyLandTile(const TileInfo *ti)

    53

{

    54

	if (ti->tileh != SLOPE_FLAT) {

    55

		DrawGroundSprite(SPR_FLAT_ROUGH_LAND + _tileh_to_sprite[ti->tileh], PAL_NONE);

    56

	} else {

    57

		DrawGroundSprite(_landscape_clear_sprites[GB(ti->x ^ ti->y, 4, 3)], PAL_NONE);

    58

	}

    59

}

    60

    61

void DrawClearLandFence(const TileInfo *ti)

    62

{

    63

	byte z = ti->z;

    64

    65

	if (ti->tileh & SLOPE_S) {

    66

		z += TILE_HEIGHT;

    67

		if (ti->tileh == SLOPE_STEEP_S) z += TILE_HEIGHT;

    68

	}

    69

    70

	if (GetFenceSW(ti->tile) != 0) {

    71

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[GetFenceSW(ti->tile) - 1] + _fence_mod_by_tileh[ti->tileh], PAL_NONE, ti->x, ti->y, z);

    72

	}

    73

    74

	if (GetFenceSE(ti->tile) != 0) {

    75

		DrawGroundSpriteAt(_clear_land_fence_sprites_1[GetFenceSE(ti->tile) - 1] + _fence_mod_by_tileh_2[ti->tileh], PAL_NONE, ti->x, ti->y, z);

    76

	}

    77

}

    78

    79

static void DrawTile_Clear(TileInfo *ti)

    80

{

    81

	switch (GetClearGround(ti->tile)) {

    82

		case CLEAR_GRASS:

    83

			DrawClearLandTile(ti, GetClearDensity(ti->tile));

    84

			break;

    85

    86

		case CLEAR_ROUGH:

    87

			DrawHillyLandTile(ti);

    88

			break;

    89

    90

		case CLEAR_ROCKS:

    91

			DrawGroundSprite(SPR_FLAT_ROCKY_LAND_1 + _tileh_to_sprite[ti->tileh], PAL_NONE);

    92

			break;

    93

    94

		case CLEAR_FIELDS:

    95

			DrawGroundSprite(_clear_land_sprites_1[GetFieldType(ti->tile)] + _tileh_to_sprite[ti->tileh], PAL_NONE);

    96

			break;

    97

    98

		case CLEAR_SNOW:

    99

			DrawGroundSprite(_clear_land_sprites_2[GetClearDensity(ti->tile)] + _tileh_to_sprite[ti->tileh], PAL_NONE);

   100

			break;

   101

   102

		case CLEAR_DESERT:

   103

			DrawGroundSprite(_clear_land_sprites_3[GetClearDensity(ti->tile)] + _tileh_to_sprite[ti->tileh], PAL_NONE);

   104

			break;

   105

	}

   106

   107

	DrawClearLandFence(ti);

   108

	DrawBridgeMiddle(ti);

   109

}

   110

   111

static uint GetSlopeZ_Clear(TileIndex tile, uint x, uint y)

   112

{

   113

	uint z;

   114

	Slope tileh = GetTileSlope(tile, &z);

   115

   116

	return z + GetPartialZ(x & 0xF, y & 0xF, tileh);

   117

}

   118

   119

static Foundation GetFoundation_Clear(TileIndex tile, Slope tileh)

   120

{

   121

	return FOUNDATION_NONE;

   122

}

   123

   124

static void GetAcceptedCargo_Clear(TileIndex tile, AcceptedCargo ac)

   125

{

   126

	/* unused */

   127

}

   128

   129

static void AnimateTile_Clear(TileIndex tile)

   130

{

   131

	/* unused */

   132

}

   133

   134

void TileLoopClearHelper(TileIndex tile)

   135

{

   136

	byte self;

   137

	byte neighbour;

   138

	TileIndex dirty = INVALID_TILE;

   139

   140

	self = (IsTileType(tile, MP_CLEAR) && IsClearGround(tile, CLEAR_FIELDS));

   141

   142

	neighbour = (IsTileType(TILE_ADDXY(tile, 1, 0), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 1, 0), CLEAR_FIELDS));

   143

	if (GetFenceSW(tile) == 0) {

   144

		if (self != neighbour) {

   145

			SetFenceSW(tile, 3);

   146

			dirty = tile;

   147

		}

   148

	} else {

   149

		if (self == 0 && neighbour == 0) {

   150

			SetFenceSW(tile, 0);

   151

			dirty = tile;

   152

		}

   153

	}

   154

   155

	neighbour = (IsTileType(TILE_ADDXY(tile, 0, 1), MP_CLEAR) && IsClearGround(TILE_ADDXY(tile, 0, 1), CLEAR_FIELDS));

   156

	if (GetFenceSE(tile) == 0) {

   157

		if (self != neighbour) {

   158

			SetFenceSE(tile, 3);

   159

			dirty = tile;

   160

		}

   161

	} else {

   162

		if (self == 0 && neighbour == 0) {

   163

			SetFenceSE(tile, 0);

   164

			dirty = tile;

   165

		}

   166

	}

   167

   168

	if (dirty != INVALID_TILE) MarkTileDirtyByTile(dirty);

   169

}

   170

   171

   172

/* convert into snowy tiles */

   173

static void TileLoopClearAlps(TileIndex tile)

   174

{

   175

	int k = GetTileZ(tile) - GetSnowLine() + TILE_HEIGHT;

   176

   177

	if (k < 0) { // well below the snow line

   178

		if (!IsClearGround(tile, CLEAR_SNOW)) return;

   179

		if (GetClearDensity(tile) == 0) SetClearGroundDensity(tile, CLEAR_GRASS, 3);

   180

	} else {

   181

		if (!IsClearGround(tile, CLEAR_SNOW)) {

   182

			SetClearGroundDensity(tile, CLEAR_SNOW, 0);

   183

		} else {

   184

			uint density = min((uint)k / TILE_HEIGHT, 3);

   185

   186

			if (GetClearDensity(tile) < density) {

   187

				AddClearDensity(tile, 1);

   188

			} else if (GetClearDensity(tile) > density) {

   189

				AddClearDensity(tile, -1);

   190

			} else {

   191

				return;

   192

			}

   193

		}

   194

	}

   195

   196

	MarkTileDirtyByTile(tile);

   197

}

   198

   199

static void TileLoopClearDesert(TileIndex tile)

   200

{

   201

	if (IsClearGround(tile, CLEAR_DESERT)) return;

   202

   203

	if (GetTropicZone(tile) == TROPICZONE_DESERT) {

   204

		SetClearGroundDensity(tile, CLEAR_DESERT, 3);

   205

	} else {

   206

		if (GetTropicZone(tile + TileDiffXY( 1,  0)) != TROPICZONE_DESERT &&

   207

				GetTropicZone(tile + TileDiffXY(-1,  0)) != TROPICZONE_DESERT &&

   208

				GetTropicZone(tile + TileDiffXY( 0,  1)) != TROPICZONE_DESERT &&

   209

				GetTropicZone(tile + TileDiffXY( 0, -1)) != TROPICZONE_DESERT)

   210

			return;

   211

		SetClearGroundDensity(tile, CLEAR_DESERT, 1);

   212

	}

   213

   214

	MarkTileDirtyByTile(tile);

   215

}

   216

   217

static void TileLoop_Clear(TileIndex tile)

   218

{

   219

	TileLoopClearHelper(tile);

   220

   221

	switch (_settings_game.game_creation.landscape) {

   222

		case LT_TROPIC: TileLoopClearDesert(tile); break;

   223

		case LT_ARCTIC: TileLoopClearAlps(tile);   break;

   224

	}

   225

   226

	switch (GetClearGround(tile)) {

   227

		case CLEAR_GRASS:

   228

			if (GetClearDensity(tile) == 3) return;

   229

   230

			if (_game_mode != GM_EDITOR) {

   231

				if (GetClearCounter(tile) < 7) {

   232

					AddClearCounter(tile, 1);

   233

					return;

   234

				} else {

   235

					SetClearCounter(tile, 0);

   236

					AddClearDensity(tile, 1);

   237

				}

   238

			} else {

   239

				SetClearGroundDensity(tile, GB(Random(), 0, 8) > 21 ? CLEAR_GRASS : CLEAR_ROUGH, 3);

   240

			}

   241

			break;

   242

   243

		case CLEAR_FIELDS: {

   244

			uint field_type;

   245

   246

			if (_game_mode == GM_EDITOR) return;

   247

   248

			if (GetClearCounter(tile) < 7) {

   249

				AddClearCounter(tile, 1);

   250

				return;

   251

			} else {

   252

				SetClearCounter(tile, 0);

   253

			}

   254

   255

			if (GetIndustryIndexOfField(tile) == INVALID_INDUSTRY && GetFieldType(tile) >= 7) {

   256

				/* This farmfield is no longer farmfield, so make it grass again */

   257

				MakeClear(tile, CLEAR_GRASS, 2);

   258

			} else {

   259

				field_type = GetFieldType(tile);

   260

				field_type = (field_type < 8) ? field_type + 1 : 0;

   261

				SetFieldType(tile, field_type);

   262

			}

   263

			break;

   264

		}

   265

   266

		default:

   267

			return;

   268

	}

   269

   270

	MarkTileDirtyByTile(tile);

   271

}

   272

   273

void GenerateClearTile()

   274

{

   275

	uint i, gi;

   276

	TileIndex tile;

   277

   278

	/* add rough tiles */

   279

	i = ScaleByMapSize(GB(Random(), 0, 10) + 0x400);

   280

	gi = ScaleByMapSize(GB(Random(), 0, 7) + 0x80);

   281

   282

	SetGeneratingWorldProgress(GWP_ROUGH_ROCKY, gi + i);

   283

	do {

   284

		IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);

   285

		tile = RandomTile();

   286

		if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) SetClearGroundDensity(tile, CLEAR_ROUGH, 3);

   287

	} while (i && --i);

   288

   289

	/* add rocky tiles */

   290

	i = gi;

   291

	do {

   292

		uint32 r = Random();

   293

		tile = RandomTileSeed(r);

   294

   295

		IncreaseGeneratingWorldProgress(GWP_ROUGH_ROCKY);

   296

		if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_DESERT)) {

   297

			uint j = GB(r, 16, 4) + 5;

   298

			for (;;) {

   299

				TileIndex tile_new;

   300

   301

				SetClearGroundDensity(tile, CLEAR_ROCKS, 3);

   303

				do {

   304

					if (--j == 0) goto get_out;

   311

				} while (!IsTileType(tile_new, MP_CLEAR) || IsClearGround(tile_new, CLEAR_DESERT));

   313

				tile = tile_new;

   314

			}

   315

get_out:;

   316

		}

   317

	} while (i && --i);

   318

}

   319

   320

static void ClickTile_Clear(TileIndex tile)

   321

{

   322

	/* not used */

   323

}

   324

   325

static TrackStatus GetTileTrackStatus_Clear(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)

   326

{

   327

	return 0;

   328

}

   329

   330

static const StringID _clear_land_str[] = {

   331

	STR_080D_GRASS,

   332

	STR_080B_ROUGH_LAND,

   333

	STR_080A_ROCKS,

   334

	STR_080E_FIELDS,

   335

	STR_080F_SNOW_COVERED_LAND,

   336

	STR_0810_DESERT

   337

};

   338

   339

static void GetTileDesc_Clear(TileIndex tile, TileDesc *td)

   340

{

   341

	if (IsClearGround(tile, CLEAR_GRASS) && GetClearDensity(tile) == 0) {

   342

		td->str = STR_080C_BARE_LAND;

   343

	} else {

   344

		td->str = _clear_land_str[GetClearGround(tile)];

   345

	}

   346

	td->owner[0] = GetTileOwner(tile);

   347

}

   348

   349

static void ChangeTileOwner_Clear(TileIndex tile, Owner old_owner, Owner new_owner)

   350

{

   351

	return;

   352

}

   353

   354

void InitializeClearLand()

   355

{

   356

	_settings_game.game_creation.snow_line = _settings_game.game_creation.snow_line_height * TILE_HEIGHT;

   357

}

   358

   359

static CommandCost TerraformTile_Clear(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)

   360

{

   361

	return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   362

}

   363

   364

extern const TileTypeProcs _tile_type_clear_procs = {

   365

	DrawTile_Clear,           ///< draw_tile_proc

   366

	GetSlopeZ_Clear,          ///< get_slope_z_proc

   367

	ClearTile_Clear,          ///< clear_tile_proc

   368

	GetAcceptedCargo_Clear,   ///< get_accepted_cargo_proc

   369

	GetTileDesc_Clear,        ///< get_tile_desc_proc

   370

	GetTileTrackStatus_Clear, ///< get_tile_track_status_proc

   371

	ClickTile_Clear,          ///< click_tile_proc

   372

	AnimateTile_Clear,        ///< animate_tile_proc

   373

	TileLoop_Clear,           ///< tile_loop_clear

   374

	ChangeTileOwner_Clear,    ///< change_tile_owner_clear

   375

	NULL,                     ///< get_produced_cargo_proc

   376

	NULL,                     ///< vehicle_enter_tile_proc

   377

	GetFoundation_Clear,      ///< get_foundation_proc

   378

	TerraformTile_Clear,      ///< terraform_tile_proc

   379

};