1

/* $Id$ */

     2

     3

/** @file tree_cmd.cpp */

     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

    26

#include "table/strings.h"

    27

#include "table/sprites.h"

    28

#include "table/tree_land.h"

    29

    30

/**

    31

 * List of tree placer algorithm.

    32

 *

    33

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

    34

 */

    35

enum TreePlacer {

    36

	TP_NONE,     ///< No tree placer algorithm

    37

	TP_ORIGINAL, ///< The original algorithm

    38

	TP_IMPROVED, ///< A 'improved' algorithm

    39

};

    40

    41

/**

    42

 * Tests if a tile can be converted to MP_TREES

    43

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

    44

 *

    45

 * @param tile the tile of interest

    46

 * @param allow_desert Allow planting trees on CLEAR_DESERT?

    47

 * @return true if trees can be built.

    48

 */

    49

static bool CanPlantTreesOnTile(TileIndex tile, bool allow_desert)

    50

{

    51

	switch (GetTileType(tile)) {

    52

		case MP_WATER:

    53

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

    54

    55

		case MP_CLEAR:

    56

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

    57

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

    58

    59

		default: return false;

    60

	}

    61

}

    62

    63

/**

    64

 * Creates a tree tile

    65

 * Ground type and density is preserved.

    66

 *

    67

 * @pre the tile must be suitable for trees.

    68

 *

    69

 * @param tile where to plant the trees.

    70

 * @param type The type of the tree

    71

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

    72

 * @param growth the growth status

    73

 */

    74

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

    75

{

    76

	assert(treetype != TREE_INVALID);

    77

	assert(CanPlantTreesOnTile(tile, true));

    78

    79

	TreeGround ground;

    80

	uint density = 3;

    81

    82

	switch (GetTileType(tile)) {

    83

		case MP_WATER:

    84

			ground = TREE_GROUND_SHORE;

    85

			break;

    86

    87

		case MP_CLEAR:

    88

			switch (GetClearGround(tile)) {

    89

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

    90

				case CLEAR_ROUGH:  ground = TREE_GROUND_ROUGH;                                        break;

    91

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

    92

			}

    93

			break;

    94

    95

		default: NOT_REACHED();

    96

	}

    97

    98

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

    99

}

   100

   101

/**

   102

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

   103

 *

   104

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

   105

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

   106

 * to get such a value.

   107

 *

   108

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

   109

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

   110

 * @return The random tree type

   111

 */

   112

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

   113

{

   114

	switch (_opt.landscape) {

   115

		case LT_TEMPERATE:

   116

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

   117

   118

		case LT_ARCTIC:

   119

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

   120

   121

		case LT_TROPIC:

   122

			switch (GetTropicZone(tile)) {

   123

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

   124

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

   125

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

   126

			}

   127

   128

		default:

   129

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

   130

	}

   131

}

   132

   133

/**

   134

 * Make a random tree tile of the given tile

   135

 *

   136

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

   137

 * randomness like type and number of trees.

   138

 *

   139

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

   140

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

   141

 */

   142

static void PlaceTree(TileIndex tile, uint32 r)

   143

{

   144

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

   145

   146

	if (tree != TREE_INVALID) {

   147

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

   148

   149

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

   150

		TreeGround ground = GetTreeGround(tile);

   151

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

   152

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

   153

		}

   154

   155

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

   156

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

   157

	}

   158

}

   159

   160

/**

   161

 * Place some amount of trees around a given tile.

   162

 *

   163

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

   164

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

   165

 * around the given tile.

   166

 *

   167

 * @param tile The center of the trees to add

   168

 */

   169

static void DoPlaceMoreTrees(TileIndex tile)

   170

{

   171

	uint i;

   172

   173

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

   174

		uint32 r = Random();

   175

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

   176

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

   177

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

   178

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

   179

   180

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

   181

			PlaceTree(cur_tile, r);

   182

		}

   183

	}

   184

}

   185

   186

/**

   187

 * Place more trees on the map.

   188

 *

   189

 * This function add more trees to the map.

   190

 */

   191

static void PlaceMoreTrees()

   192

{

   193

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

   194

	do {

   195

		DoPlaceMoreTrees(RandomTile());

   196

	} while (--i);

   197

}

   198

   199

/**

   200

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

   201

 *

   202

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

   203

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

   204

 *

   205

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

   206

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

   207

 */

   208

static void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   209

{

   210

	uint i;

   211

   212

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

   213

		uint32 r = Random();

   214

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

   215

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

   216

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

   217

   218

		/* Keep in range of the existing tree */

   219

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

   220

   221

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

   222

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

   223

   224

		/* Not too much height difference */

   225

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

   226

   227

		/* Place one tree and quit */

   228

		PlaceTree(cur_tile, r);

   229

		break;

   230

	}

   231

}

   232

   233

/**

   234

 * Place some trees randomly

   235

 *

   236

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

   237

 */

   238

void PlaceTreesRandomly()

   239

{

   240

	uint i, j, ht;

   241

   242

	i = ScaleByMapSize(1000);

   243

	do {

   244

		uint32 r = Random();

   245

		TileIndex tile = RandomTileSeed(r);

   246

   247

		IncreaseGeneratingWorldProgress(GWP_TREE);

   248

   249

		if (CanPlantTreesOnTile(tile, true)) {

   250

			PlaceTree(tile, r);

   251

			if (_patches.tree_placer != TP_IMPROVED) continue;

   252

   253

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

   254

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

   255

			 *  It is almost real life ;) */

   256

			ht = GetTileZ(tile);

   257

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

   258

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   259

			while (j--) {

   260

				/* Above snowline more trees! */

   261

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

   262

					PlaceTreeAtSameHeight(tile, ht);

   263

					PlaceTreeAtSameHeight(tile, ht);

   264

				};

   265

   266

				PlaceTreeAtSameHeight(tile, ht);

   267

			}

   268

		}

   269

	} while (--i);

   270

   271

	/* place extra trees at rainforest area */

   272

	if (_opt.landscape == LT_TROPIC) {

   273

		i = ScaleByMapSize(15000);

   274

   275

		do {

   276

			uint32 r = Random();

   277

			TileIndex tile = RandomTileSeed(r);

   278

   279

			IncreaseGeneratingWorldProgress(GWP_TREE);

   280

   281

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

   282

				PlaceTree(tile, r);

   283

			}

   284

		} while (--i);

   285

	}

   286

}

   287

   288

/**

   289

 * Place new trees.

   290

 *

   291

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

   292

 * place randomly the trees for a new game.

   293

 */

   294

void GenerateTrees()

   295

{

   296

	uint i, total;

   297

   298

	if (_patches.tree_placer == TP_NONE) return;

   299

   300

	if (_opt.landscape != LT_TOYLAND) PlaceMoreTrees();

   301

   302

	switch (_patches.tree_placer) {

   303

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

   304

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

   305

		default: NOT_REACHED(); return;

   306

	}

   307

   308

	total = ScaleByMapSize(1000);

   309

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

   310

	total *= i;

   311

	SetGeneratingWorldProgress(GWP_TREE, total);

   312

   313

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

   314

		PlaceTreesRandomly();

   315

	}

   316

}

   317

   318

/** Plant a tree.

   319

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

   320

 * @param flags type of operation

   321

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

   322

 * @param p2 end tile of area-drag

   323

 */

   324

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

   325

{

   326

	StringID msg = INVALID_STRING_ID;

   327

	CommandCost cost(EXPENSES_OTHER);

   328

	int ex;

   329

	int ey;

   330

	int sx, sy, x, y;

   331

   332

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

   333

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

   334

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

   335

   336

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

   337

	ex = TileX(tile);

   338

	ey = TileY(tile);

   339

	sx = TileX(p2);

   340

	sy = TileY(p2);

   341

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

   342

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

   343

   344

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

   345

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

   346

			TileIndex tile = TileXY(x, y);

   347

   348

			switch (GetTileType(tile)) {

   349

				case MP_TREES:

   350

					/* no more space for trees? */

   351

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

   352

						msg = STR_2803_TREE_ALREADY_HERE;

   353

						continue;

   354

					}

   355

   356

					if (flags & DC_EXEC) {

   357

						AddTreeCount(tile, 1);

   358

						MarkTileDirtyByTile(tile);

   359

					}

   360

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

   361

					cost.AddCost(_price.build_trees * 2);

   362

					break;

   363

   364

				case MP_WATER:

   365

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

   366

						msg = STR_3807_CAN_T_BUILD_ON_WATER;

   367

						continue;

   368

					}

   369

				/* FALL THROUGH */

   370

				case MP_CLEAR:

   371

					if (IsBridgeAbove(tile)) {

   372

						msg = STR_2804_SITE_UNSUITABLE;

   373

						continue;

   374

					}

   375

   376

					if (IsTileType(tile, MP_CLEAR)) {

   377

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

   378

						switch (GetClearGround(tile)) {

   379

							case CLEAR_FIELDS:

   380

							case CLEAR_ROCKS: {

   381

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

   382

								if (CmdFailed(ret)) return ret;

   383

								cost.AddCost(ret);

   384

								break;

   385

							}

   386

   387

							default: break;

   388

						}

   389

					}

   390

   391

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

   392

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

   393

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

   394

					}

   395

   396

					if (flags & DC_EXEC) {

   397

						TreeType treetype;

   398

   399

						treetype = (TreeType)p1;

   400

						if (treetype == TREE_INVALID) {

   401

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

   402

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   403

						}

   404

   405

						/* Plant full grown trees in scenario editor */

   406

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

   407

						MarkTileDirtyByTile(tile);

   408

   409

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

   410

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

   411

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   412

					}

   413

					cost.AddCost(_price.build_trees);

   414

					break;

   415

   416

				default:

   417

					msg = STR_2804_SITE_UNSUITABLE;

   418

					break;

   419

			}

   420

		}

   421

	}

   422

   423

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

   424

		return_cmd_error(msg);

   425

	} else {

   426

		return cost;

   427

	}

   428

}

   429

   430

struct TreeListEnt {

   431

	SpriteID image;

   432

	SpriteID pal;

   433

	byte x, y;

   434

};

   435

   436

static void DrawTile_Trees(TileInfo *ti)

   437

{

   438

	switch (GetTreeGround(ti->tile)) {

   439

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

   440

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

   441

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   442

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

   443

	}

   444

   445

	DrawClearLandFence(ti);

   446

   447

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

   448

	if (IsInvisibilitySet(TO_TREES)) return;

   449

   450

	uint16 tmp = ti->x;

   451

   452

	tmp = ROR(tmp, 2);

   453

	tmp -= ti->y;

   454

	tmp = ROR(tmp, 3);

   455

	tmp -= ti->x;

   456

	tmp = ROR(tmp, 1);

   457

	tmp += ti->y;

   458

   459

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

   460

   461

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

   462

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

   463

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

   464

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

   465

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

   466

	}

   467

   468

	assert(index < lengthof(_tree_layout_sprite));

   469

   470

	const PalSpriteID *s = _tree_layout_sprite[index];

   471

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

   472

   473

	/* combine trees into one sprite object */

   474

	StartSpriteCombine();

   475

   476

	TreeListEnt te[4];

   477

   478

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

   479

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

   480

   481

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

   482

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

   483

		SpriteID pal = s[0].pal;

   484

   485

		te[i].image = image;

   486

		te[i].pal   = pal;