1

/* $Id$ */

     2

     3

/** @file tree_cmd.cpp Handling of tree tiles. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "clear_map.h"

     9

#include "tile_cmd.h"

    10

#include "landscape.h"

    11

#include "tree_map.h"

    12

#include "viewport_func.h"

    13

#include "command_func.h"

    14

#include "economy_func.h"

    15

#include "town.h"

    16

#include "variables.h"

    17

#include "genworld.h"

    18

#include "transparency.h"

    19

#include "functions.h"

    20

#include "player_func.h"

    21

#include "sound_func.h"

    22

#include "settings_type.h"

    23

#include "water_map.h"

    24

#include "water.h"

    25

#include "landscape_type.h"

    26

#include "player_base.h"

    27

    28

#include "table/strings.h"

    29

#include "table/sprites.h"

    30

#include "table/tree_land.h"

    31

    32

/**

    33

 * List of tree placer algorithm.

    34

 *

    35

 * This enumeration defines all possible tree placer algorithm in the game.

    36

 */

    37

enum TreePlacer {

    38

	TP_NONE,     ///< No tree placer algorithm

    39

	TP_ORIGINAL, ///< The original algorithm

    40

	TP_IMPROVED, ///< A 'improved' algorithm

    41

};

    42

    43

/**

    44

 * Tests if a tile can be converted to MP_TREES

    45

 * This is true for clear ground without farms or rocks.

    46

 *

    47

 * @param tile the tile of interest

    48

 * @param allow_desert Allow planting trees on CLEAR_DESERT?

    49

 * @return true if trees can be built.

    50

 */

    51

static bool CanPlantTreesOnTile(TileIndex tile, bool allow_desert)

    52

{

    53

	switch (GetTileType(tile)) {

    54

		case MP_WATER:

    55

			return !IsBridgeAbove(tile) && IsCoast(tile) && !IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL));

    56

    57

		case MP_CLEAR:

    58

			return !IsBridgeAbove(tile) && !IsClearGround(tile, CLEAR_FIELDS) && !IsClearGround(tile, CLEAR_ROCKS) &&

    59

			       (allow_desert || !IsClearGround(tile, CLEAR_DESERT));

    60

    61

		default: return false;

    62

	}

    63

}

    64

    65

/**

    66

 * Creates a tree tile

    67

 * Ground type and density is preserved.

    68

 *

    69

 * @pre the tile must be suitable for trees.

    70

 *

    71

 * @param tile where to plant the trees.

    72

 * @param type The type of the tree

    73

 * @param count the number of trees (minus 1)

    74

 * @param growth the growth status

    75

 */

    76

static void PlantTreesOnTile(TileIndex tile, TreeType treetype, uint count, uint growth)

    77

{

    78

	assert(treetype != TREE_INVALID);

    79

	assert(CanPlantTreesOnTile(tile, true));

    80

    81

	TreeGround ground;

    82

	uint density = 3;

    83

    84

	switch (GetTileType(tile)) {

    85

		case MP_WATER:

    86

			ground = TREE_GROUND_SHORE;

    87

			break;

    88

    89

		case MP_CLEAR:

    90

			switch (GetClearGround(tile)) {

    91

				case CLEAR_GRASS:  ground = TREE_GROUND_GRASS;       density = GetClearDensity(tile); break;

    92

				case CLEAR_ROUGH:  ground = TREE_GROUND_ROUGH;                                        break;

    93

				default:           ground = TREE_GROUND_SNOW_DESERT; density = GetClearDensity(tile); break;

    94

			}

    95

			break;

    96

    97

		default: NOT_REACHED();

    98

	}

    99

   100

	MakeTree(tile, treetype, count, growth, ground, density);

   101

}

   102

   103

/**

   104

 * Get a random TreeType for the given tile based on a given seed

   105

 *

   106

 * This function returns a random TreeType which can be placed on the given tile.

   107

 * The seed for randomness must be less or equal 256, use #GB on the value of Random()

   108

 * to get such a value.

   109

 *

   110

 * @param tile The tile to get a random TreeType from

   111

 * @param seed The seed for randomness, must be less or equal 256

   112

 * @return The random tree type

   113

 */

   114

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

   115

{

   116

	switch (_settings_game.game_creation.landscape) {

   117

		case LT_TEMPERATE:

   118

			return (TreeType)(seed * TREE_COUNT_TEMPERATE / 256 + TREE_TEMPERATE);

   119

   120

		case LT_ARCTIC:

   121

			return (TreeType)(seed * TREE_COUNT_SUB_ARCTIC / 256 + TREE_SUB_ARCTIC);

   122

   123

		case LT_TROPIC:

   124

			switch (GetTropicZone(tile)) {

   125

				case TROPICZONE_NORMAL:  return (TreeType)(seed * TREE_COUNT_SUB_TROPICAL / 256 + TREE_SUB_TROPICAL);

   126

				case TROPICZONE_DESERT:  return (TreeType)((seed > 12) ? TREE_INVALID : TREE_CACTUS);

   127

				default:                 return (TreeType)(seed * TREE_COUNT_RAINFOREST / 256 + TREE_RAINFOREST);

   128

			}

   129

   130

		default:

   131

			return (TreeType)(seed * TREE_COUNT_TOYLAND / 256 + TREE_TOYLAND);

   132

	}

   133

}

   134

   135

/**

   136

 * Make a random tree tile of the given tile

   137

 *

   138

 * Create a new tree-tile for the given tile. The second parameter is used for

   139

 * randomness like type and number of trees.

   140

 *

   141

 * @param tile The tile to make a tree-tile from

   142

 * @param r The randomness value from a Random() value

   143

 */

   144

static void PlaceTree(TileIndex tile, uint32 r)

   145

{

   146

	TreeType tree = GetRandomTreeType(tile, GB(r, 24, 8));

   147

   148

	if (tree != TREE_INVALID) {

   149

		PlantTreesOnTile(tile, tree, GB(r, 22, 2), min(GB(r, 16, 3), 6));

   150

   151

		/* Rerandomize ground, if neither snow nor shore */

   152

		TreeGround ground = GetTreeGround(tile);

   153

		if (ground != TREE_GROUND_SNOW_DESERT && ground != TREE_GROUND_SHORE) {

   154

			SetTreeGroundDensity(tile, (TreeGround)GB(r, 28, 1), 3);

   155

		}

   156

   157

		/* Set the counter to a random start value */

   158

		SetTreeCounter(tile, (TreeGround)GB(r, 24, 4));

   159

	}

   160

}

   161

   162

/**

   163

 * Place some amount of trees around a given tile.

   164

 *

   165

 * This function adds some trees around a given tile. As this function use

   166

 * the Random() call it depends on the random how many trees are actually placed

   167

 * around the given tile.

   168

 *

   169

 * @param tile The center of the trees to add

   170

 */

   171

static void DoPlaceMoreTrees(TileIndex tile)

   172

{

   173

	uint i;

   174

   175

	for (i = 0; i < 1000; i++) {

   176

		uint32 r = Random();

   177

		int x = GB(r, 0, 5) - 16;

   178

		int y = GB(r, 8, 5) - 16;

   179

		uint dist = abs(x) + abs(y);

   180

		TileIndex cur_tile = TILE_MASK(tile + TileDiffXY(x, y));

   181

   182

		if (dist <= 13 && CanPlantTreesOnTile(cur_tile, true)) {

   183

			PlaceTree(cur_tile, r);

   184

		}

   185

	}

   186

}

   187

   188

/**

   189

 * Place more trees on the map.

   190

 *

   191

 * This function add more trees to the map.

   192

 */

   193

static void PlaceMoreTrees()

   194

{

   195

	uint i = ScaleByMapSize(GB(Random(), 0, 5) + 25);

   196

	do {

   197

		DoPlaceMoreTrees(RandomTile());

   198

	} while (--i);

   199

}

   200

   201

/**

   202

 * Place a tree at the same height as an existing tree.

   203

 *

   204

 * Add a new tree around the given tile which is at the same

   205

 * height or at some offset (2 units) of it.

   206

 *

   207

 * @param tile The base tile to add a new tree somewhere around

   208

 * @param height The height (like the one from the tile)

   209

 */

   210

static void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   211

{

   212

	uint i;

   213

   214

	for (i = 0; i < 1000; i++) {

   215

		uint32 r = Random();

   216

		int x = GB(r, 0, 5) - 16;

   217

		int y = GB(r, 8, 5) - 16;

   218

		TileIndex cur_tile = TILE_MASK(tile + TileDiffXY(x, y));

   219

   220

		/* Keep in range of the existing tree */

   221

		if (abs(x) + abs(y) > 16) continue;

   222

   223

		/* Clear tile, no farm-tiles or rocks */

   224

		if (!CanPlantTreesOnTile(cur_tile, true)) continue;

   225

   226

		/* Not too much height difference */

   227

		if (Delta(GetTileZ(cur_tile), height) > 2) continue;

   228

   229

		/* Place one tree and quit */

   230

		PlaceTree(cur_tile, r);

   231

		break;

   232

	}

   233

}

   234

   235

/**

   236

 * Place some trees randomly

   237

 *

   238

 * This function just place some trees randomly on the map.

   239

 */

   240

void PlaceTreesRandomly()

   241

{

   242

	uint i, j, ht;

   243

   244

	i = ScaleByMapSize(1000);

   245

	do {

   246

		uint32 r = Random();

   247

		TileIndex tile = RandomTileSeed(r);

   248

   249

		IncreaseGeneratingWorldProgress(GWP_TREE);

   250

   251

		if (CanPlantTreesOnTile(tile, true)) {

   252

			PlaceTree(tile, r);

   253

			if (_settings_game.game_creation.tree_placer != TP_IMPROVED) continue;

   254

   255

			/* Place a number of trees based on the tile height.

   256

			 *  This gives a cool effect of multiple trees close together.

   257

			 *  It is almost real life ;) */

   258

			ht = GetTileZ(tile);

   259

			/* The higher we get, the more trees we plant */

   260

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   261

			while (j--) {

   262

				/* Above snowline more trees! */

   263

				if (_settings_game.game_creation.landscape == LT_ARCTIC && ht > GetSnowLine()) {

   264

					PlaceTreeAtSameHeight(tile, ht);

   265

					PlaceTreeAtSameHeight(tile, ht);

   266

				};

   267

   268

				PlaceTreeAtSameHeight(tile, ht);

   269

			}

   270

		}

   271

	} while (--i);

   272

   273

	/* place extra trees at rainforest area */

   274

	if (_settings_game.game_creation.landscape == LT_TROPIC) {

   275

		i = ScaleByMapSize(15000);

   276

   277

		do {

   278

			uint32 r = Random();

   279

			TileIndex tile = RandomTileSeed(r);

   280

   281

			IncreaseGeneratingWorldProgress(GWP_TREE);

   282

   283

			if (GetTropicZone(tile) == TROPICZONE_RAINFOREST && CanPlantTreesOnTile(tile, false)) {

   284

				PlaceTree(tile, r);

   285

			}

   286

		} while (--i);

   287

	}

   288

}

   289

   290

/**

   291

 * Place new trees.

   292

 *

   293

 * This function takes care of the selected tree placer algorithm and

   294

 * place randomly the trees for a new game.

   295

 */

   296

void GenerateTrees()

   297

{

   298

	uint i, total;

   299

   300

	if (_settings_game.game_creation.tree_placer == TP_NONE) return;

   301

   302

	if (_settings_game.game_creation.landscape != LT_TOYLAND) PlaceMoreTrees();

   303

   304

	switch (_settings_game.game_creation.tree_placer) {

   305

		case TP_ORIGINAL: i = _settings_game.game_creation.landscape == LT_ARCTIC ? 15 : 6; break;

   306

		case TP_IMPROVED: i = _settings_game.game_creation.landscape == LT_ARCTIC ?  4 : 2; break;

   307

		default: NOT_REACHED(); return;

   308

	}

   309

   310

	total = ScaleByMapSize(1000);

   311

	if (_settings_game.game_creation.landscape == LT_TROPIC) total += ScaleByMapSize(15000);

   312

	total *= i;

   313

	SetGeneratingWorldProgress(GWP_TREE, total);

   314

   315

	for (; i != 0; i--) {

   316

		PlaceTreesRandomly();

   317

	}

   318

}

   319

   320

/** Plant a tree.

   321

 * @param tile start tile of area-drag of tree plantation

   322

 * @param flags type of operation

   323

 * @param p1 tree type, -1 means random.

   324

 * @param p2 end tile of area-drag

   325

 */

   326

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

   327

{

   328

	StringID msg = INVALID_STRING_ID;

   329

	CommandCost cost(EXPENSES_OTHER);

   330

	int ex;

   331

	int ey;

   332

	int sx, sy, x, y;

   333

   334

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

   335

	/* Check the tree type. It can be random or some valid value within the current climate */

   336

	if (p1 != (uint)-1 && p1 - _tree_base_by_landscape[_settings_game.game_creation.landscape] >= _tree_count_by_landscape[_settings_game.game_creation.landscape]) return CMD_ERROR;

   337

   338

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

   339

	ex = TileX(tile);

   340

	ey = TileY(tile);

   341

	sx = TileX(p2);

   342

	sy = TileY(p2);

   343

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

   344

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

   345

   346

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

   347

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

   348

			TileIndex tile = TileXY(x, y);

   349

   350

			switch (GetTileType(tile)) {

   351

				case MP_TREES:

   352

					/* no more space for trees? */

   353

					if (_game_mode != GM_EDITOR && GetTreeCount(tile) == 3) {

   354

						msg = STR_2803_TREE_ALREADY_HERE;

   355

						continue;

   356

					}

   357

   358

					if (flags & DC_EXEC) {

   359

						AddTreeCount(tile, 1);

   360

						MarkTileDirtyByTile(tile);

   361

					}

   362

					/* 2x as expensive to add more trees to an existing tile */

   363

					cost.AddCost(_price.build_trees * 2);

   364

					break;

   365

   366

				case MP_WATER:

   367

					if (!IsCoast(tile) || IsSlopeWithOneCornerRaised(GetTileSlope(tile, NULL))) {

   368

						msg = STR_3807_CAN_T_BUILD_ON_WATER;

   369

						continue;

   370

					}

   371

				/* FALL THROUGH */

   372

				case MP_CLEAR:

   373

					if (IsBridgeAbove(tile)) {

   374

						msg = STR_2804_SITE_UNSUITABLE;

   375

						continue;

   376

					}

   377

   378

					if (IsTileType(tile, MP_CLEAR)) {

   379

						/* Remove fields or rocks. Note that the ground will get barrened */

   380

						switch (GetClearGround(tile)) {

   381

							case CLEAR_FIELDS:

   382

							case CLEAR_ROCKS: {

   383

								CommandCost ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

   384

								if (CmdFailed(ret)) return ret;

   385

								cost.AddCost(ret);

   386

								break;

   387

							}

   388

   389

							default: break;

   390

						}

   391

					}

   392

   393

					if (_game_mode != GM_EDITOR && IsValidPlayerID(_current_player)) {

   394

						Town *t = ClosestTownFromTile(tile, _settings_game.economy.dist_local_authority);

   395

						if (t != NULL) ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   396

					}

   397

   398

					if (flags & DC_EXEC) {

   399

						TreeType treetype;

   400

   401

						treetype = (TreeType)p1;

   402

						if (treetype == TREE_INVALID) {

   403

							treetype = GetRandomTreeType(tile, GB(Random(), 24, 8));

   404

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   405

						}

   406

   407

						/* Plant full grown trees in scenario editor */

   408

						PlantTreesOnTile(tile, treetype, 0, _game_mode == GM_EDITOR ? 3 : 0);

   409

						MarkTileDirtyByTile(tile);

   410

   411

						/* When planting rainforest-trees, set tropiczone to rainforest in editor. */

   412

						if (_game_mode == GM_EDITOR && IsInsideMM(treetype, TREE_RAINFOREST, TREE_CACTUS))

   413

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   414

					}

   415

					cost.AddCost(_price.build_trees);

   416

					break;

   417

   418

				default:

   419

					msg = STR_2804_SITE_UNSUITABLE;

   420

					break;

   421

			}

   422

		}

   423

	}

   424

   425

	if (cost.GetCost() == 0) {

   426

		return_cmd_error(msg);

   427

	} else {

   428

		return cost;

   429

	}

   430

}

   431

   432

struct TreeListEnt {

   433

	SpriteID image;

   434

	SpriteID pal;

   435

	byte x, y;

   436

};

   437

   438

static void DrawTile_Trees(TileInfo *ti)

   439

{

   440

	switch (GetTreeGround(ti->tile)) {

   441

		case TREE_GROUND_SHORE: DrawShoreTile(ti->tileh); break;

   442

		case TREE_GROUND_GRASS: DrawClearLandTile(ti, GetTreeDensity(ti->tile)); break;

   443

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   444

		default: DrawGroundSprite(_tree_sprites_1[GetTreeDensity(ti->tile)] + _tileh_to_sprite[ti->tileh], PAL_NONE); break;

   445

	}

   446

   447

	DrawClearLandFence(ti);

   448

   449

	/* Do not draw trees when the invisible trees patch and transparency tree are set */

   450

	if (IsInvisibilitySet(TO_TREES)) return;

   451

   452

	uint16 tmp = ti->x;

   453

   454

	tmp = ROR(tmp, 2);

   455

	tmp -= ti->y;

   456

	tmp = ROR(tmp, 3);

   457

	tmp -= ti->x;

   458

	tmp = ROR(tmp, 1);

   459

	tmp += ti->y;

   460

   461

	uint index = GB(tmp, 6, 2) + (GetTreeType(ti->tile) << 2);

   462

   463

	/* different tree styles above one of the grounds */

   464

	if (GetTreeGround(ti->tile) == TREE_GROUND_SNOW_DESERT &&

   465

			GetTreeDensity(ti->tile) >= 2 &&

   466

			IsInsideMM(index, TREE_SUB_ARCTIC << 2, TREE_RAINFOREST << 2)) {

   467

		index += 164 - (TREE_SUB_ARCTIC << 2);

   468

	}

   469

   470

	assert(index < lengthof(_tree_layout_sprite));

   471

   472

	const PalSpriteID *s = _tree_layout_sprite[index];

   473

	const TreePos *d = _tree_layout_xy[GB(tmp, 4, 2)];

   474

   475

	/* combine trees into one sprite object */

   476

	StartSpriteCombine();

   477

   478

	TreeListEnt te[4];

   479

   480

	/* put the trees to draw in a list */

   481

	uint trees = GetTreeCount(ti->tile) + 1;

   482

   483

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

   484

		SpriteID image = s[0].sprite + (i == trees - 1 ? GetTreeGrowth(ti->tile) : 3);

   485

		SpriteID pal = s[0].pal;