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

    27

#include "table/strings.h"

    28

#include "table/sprites.h"

    29

#include "table/tree_land.h"

    30

    31

/**

    32

 * List of tree placer algorithm.

    33

 *

    34

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

    35

 */

    36

enum TreePlacer {

    37

	TP_NONE,     ///< No tree placer algorithm

    38

	TP_ORIGINAL, ///< The original algorithm

    39

	TP_IMPROVED, ///< A 'improved' algorithm

    40

};

    41

    42

/**

    43

 * Tests if a tile can be converted to MP_TREES

    44

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

    45

 *

    46

 * @param tile the tile of interest

    47

 * @param allow_desert Allow planting trees on CLEAR_DESERT?

    48

 * @return true if trees can be built.

    49

 */

    50

static bool CanPlantTreesOnTile(TileIndex tile, bool allow_desert)

    51

{

    52

	switch (GetTileType(tile)) {

    53

		case MP_WATER:

    54

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

    55

    56

		case MP_CLEAR:

    57

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

    58

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

    59

    60

		default: return false;

    61

	}

    62

}

    63

    64

/**

    65

 * Creates a tree tile

    66

 * Ground type and density is preserved.

    67

 *

    68

 * @pre the tile must be suitable for trees.

    69

 *

    70

 * @param tile where to plant the trees.

    71

 * @param type The type of the tree

    72

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

    73

 * @param growth the growth status

    74

 */

    75

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

    76

{

    77

	assert(treetype != TREE_INVALID);

    78

	assert(CanPlantTreesOnTile(tile, true));

    79

    80

	TreeGround ground;

    81

	uint density = 3;

    82

    83

	switch (GetTileType(tile)) {

    84

		case MP_WATER:

    85

			ground = TREE_GROUND_SHORE;

    86

			break;

    87

    88

		case MP_CLEAR:

    89

			switch (GetClearGround(tile)) {

    90

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

    91

				case CLEAR_ROUGH:  ground = TREE_GROUND_ROUGH;                                        break;

    92

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

    93

			}

    94

			break;

    95

    96

		default: NOT_REACHED();

    97

	}

    98

    99

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

   100

}

   101

   102

/**

   103

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

   104

 *

   105

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

   106

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

   107

 * to get such a value.

   108

 *

   109

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

   110

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

   111

 * @return The random tree type

   112

 */

   113

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

   114

{

   115

	switch (_settings_game.game_creation.landscape) {

   116

		case LT_TEMPERATE:

   117

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

   118

   119

		case LT_ARCTIC:

   120

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

   121

   122

		case LT_TROPIC:

   123

			switch (GetTropicZone(tile)) {

   124

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

   125

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

   126

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

   127

			}

   128

   129

		default:

   130

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

   131

	}

   132

}

   133

   134

/**

   135

 * Make a random tree tile of the given tile

   136

 *

   137

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

   138

 * randomness like type and number of trees.

   139

 *

   140

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

   141

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

   142

 */

   143

static void PlaceTree(TileIndex tile, uint32 r)

   144

{

   145

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

   146

   147

	if (tree != TREE_INVALID) {

   148

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

   149

   150

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

   151

		TreeGround ground = GetTreeGround(tile);

   152

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

   153

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

   154

		}

   155

   156

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

   157

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

   158

	}

   159

}

   160

   161

/**

   162

 * Place some amount of trees around a given tile.

   163

 *

   164

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

   165

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

   166

 * around the given tile.

   167

 *

   168

 * @param tile The center of the trees to add

   169

 */

   170

static void DoPlaceMoreTrees(TileIndex tile)

   171

{

   172

	uint i;

   173

   174

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

   175

		uint32 r = Random();

   176

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

   177

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

   178

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

   179

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

   180

   181

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

   182

			PlaceTree(cur_tile, r);

   183

		}

   184

	}

   185

}

   186

   187

/**

   188

 * Place more trees on the map.

   189

 *

   190

 * This function add more trees to the map.

   191

 */

   192

static void PlaceMoreTrees()

   193

{

   194

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

   195

	do {

   196

		DoPlaceMoreTrees(RandomTile());

   197

	} while (--i);

   198

}

   199

   200

/**

   201

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

   202

 *

   203

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

   204

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

   205

 *

   206

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

   207

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

   208

 */

   209

static void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   210

{

   211

	uint i;

   212

   213

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

   214

		uint32 r = Random();

   215

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

   216

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

   217

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

   218

   219

		/* Keep in range of the existing tree */

   220

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

   221

   222

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

   223

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

   224

   225

		/* Not too much height difference */

   226

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

   227

   228

		/* Place one tree and quit */

   229

		PlaceTree(cur_tile, r);

   230

		break;

   231

	}

   232

}

   233

   234

/**

   235

 * Place some trees randomly

   236

 *

   237

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

   238

 */

   239

void PlaceTreesRandomly()

   240

{

   241

	uint i, j, ht;

   242

   243

	i = ScaleByMapSize(1000);

   244

	do {

   245

		uint32 r = Random();

   246

		TileIndex tile = RandomTileSeed(r);

   247

   248

		IncreaseGeneratingWorldProgress(GWP_TREE);

   249

   250

		if (CanPlantTreesOnTile(tile, true)) {

   251

			PlaceTree(tile, r);

   252

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

   253

   254

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

   255

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

   256

			 *  It is almost real life ;) */

   257

			ht = GetTileZ(tile);

   258

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

   259

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   260

			while (j--) {

   261

				/* Above snowline more trees! */

   262

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

   263

					PlaceTreeAtSameHeight(tile, ht);

   264

					PlaceTreeAtSameHeight(tile, ht);

   265

				};

   266

   267

				PlaceTreeAtSameHeight(tile, ht);

   268

			}

   269

		}

   270

	} while (--i);

   271

   272

	/* place extra trees at rainforest area */

   273

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

   274

		i = ScaleByMapSize(15000);

   275

   276

		do {

   277

			uint32 r = Random();

   278

			TileIndex tile = RandomTileSeed(r);

   279

   280

			IncreaseGeneratingWorldProgress(GWP_TREE);

   281

   282

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

   283

				PlaceTree(tile, r);

   284

			}

   285

		} while (--i);

   286

	}

   287

}

   288

   289

/**

   290

 * Place new trees.

   291

 *

   292

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

   293

 * place randomly the trees for a new game.

   294

 */

   295

void GenerateTrees()

   296

{

   297

	uint i, total;

   298

   299

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

   300

   301

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

   302

   303

	switch (_settings_game.game_creation.tree_placer) {

   304

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

   305

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

   306

		default: NOT_REACHED(); return;

   307

	}

   308

   309

	total = ScaleByMapSize(1000);

   310

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

   311

	total *= i;

   312

	SetGeneratingWorldProgress(GWP_TREE, total);

   313

   314

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

   315

		PlaceTreesRandomly();

   316

	}

   317

}

   318

   319

/** Plant a tree.

   320

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

   321

 * @param flags type of operation

   322

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

   323

 * @param p2 end tile of area-drag

   324

 */

   325

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

   326

{

   327

	StringID msg = INVALID_STRING_ID;

   328

	CommandCost cost(EXPENSES_OTHER);

   329

	int ex;

   330

	int ey;

   331

	int sx, sy, x, y;

   332

   333

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

   334

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

   335

	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;

   336

   337

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

   338

	ex = TileX(tile);

   339

	ey = TileY(tile);

   340

	sx = TileX(p2);

   341

	sy = TileY(p2);

   342

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

   343

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

   344

   345

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

   346

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

   347

			TileIndex tile = TileXY(x, y);

   348

   349

			switch (GetTileType(tile)) {

   350

				case MP_TREES:

   351

					/* no more space for trees? */

   352

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

   353

						msg = STR_2803_TREE_ALREADY_HERE;

   354

						continue;

   355

					}

   356

   357

					if (flags & DC_EXEC) {

   358

						AddTreeCount(tile, 1);

   359

						MarkTileDirtyByTile(tile);

   360

					}

   361

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

   362

					cost.AddCost(_price.build_trees * 2);

   363

					break;

   364

   365

				case MP_WATER:

   366

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

   367

						msg = STR_3807_CAN_T_BUILD_ON_WATER;

   368

						continue;

   369

					}

   370

				/* FALL THROUGH */

   371

				case MP_CLEAR:

   372

					if (IsBridgeAbove(tile)) {

   373

						msg = STR_2804_SITE_UNSUITABLE;

   374

						continue;

   375

					}

   376

   377

					if (IsTileType(tile, MP_CLEAR)) {

   378

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

   379

						switch (GetClearGround(tile)) {

   380

							case CLEAR_FIELDS:

   381

							case CLEAR_ROCKS: {

   382

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

   383

								if (CmdFailed(ret)) return ret;

   384

								cost.AddCost(ret);

   385

								break;

   386

							}

   387

   388

							default: break;

   389

						}

   390

					}

   391

   392

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

   393

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

   394

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

   395

					}

   396

   397

					if (flags & DC_EXEC) {

   398

						TreeType treetype;

   399

   400

						treetype = (TreeType)p1;

   401

						if (treetype == TREE_INVALID) {

   402

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

   403

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   404

						}

   405

   406

						/* Plant full grown trees in scenario editor */

   407

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

   408

						MarkTileDirtyByTile(tile);

   409

   410

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

   411

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

   412

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   413

					}

   414

					cost.AddCost(_price.build_trees);

   415

					break;

   416

   417

				default:

   418

					msg = STR_2804_SITE_UNSUITABLE;

   419

					break;

   420

			}

   421

		}

   422

	}

   423

   424

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

   425

		return_cmd_error(msg);

   426

	} else {

   427

		return cost;

   428

	}

   429

}

   430

   431

struct TreeListEnt {

   432

	SpriteID image;

   433

	SpriteID pal;

   434

	byte x, y;

   435

};

   436

   437

static void DrawTile_Trees(TileInfo *ti)

   438

{

   439

	switch (GetTreeGround(ti->tile)) {

   440

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

   441

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

   442

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   443

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

   444

	}

   445

   446

	DrawClearLandFence(ti);

   447

   448

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

   449

	if (IsInvisibilitySet(TO_TREES)) return;

   450

   451

	uint16 tmp = ti->x;

   452

   453

	tmp = ROR(tmp, 2);

   454

	tmp -= ti->y;

   455

	tmp = ROR(tmp, 3);

   456

	tmp -= ti->x;

   457

	tmp = ROR(tmp, 1);

   458

	tmp += ti->y;

   459

   460

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

   461

   462

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

   463

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

   464

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

   465

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

   466

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

   467

	}

   468

   469

	assert(index < lengthof(_tree_layout_sprite));

   470

   471

	const PalSpriteID *s = _tree_layout_sprite[index];

   472

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

   473

   474

	/* combine trees into one sprite object */

   475

	StartSpriteCombine();

   476

   477

	TreeListEnt te[4];

   478

   479

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

   480

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

   481

   482

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

   483

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

   484

		SpriteID pal = s[0].pal;

   485

   486