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

    24

#include "table/strings.h"

    25

#include "table/sprites.h"

    26

#include "table/tree_land.h"

    27

    28

/**

    29

 * List of tree placer algorithm.

    30

 *

    31

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

    32

 */

    33

enum TreePlacer {

    34

	TP_NONE,     ///< No tree placer algorithm

    35

	TP_ORIGINAL, ///< The original algorithm

    36

	TP_IMPROVED, ///< A 'improved' algorithm

    37

};

    38

    39

/**

    40

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

    41

 *

    42

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

    43

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

    44

 * to get such a value.

    45

 *

    46

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

    47

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

    48

 * @return The random tree type

    49

 */

    50

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

    51

{

    52

	switch (_opt.landscape) {

    53

		case LT_TEMPERATE:

    54

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

    55

    56

		case LT_ARCTIC:

    57

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

    58

    59

		case LT_TROPIC:

    60

			switch (GetTropicZone(tile)) {

    61

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

    62

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

    63

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

    64

			}

    65

    66

		default:

    67

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

    68

	}

    69

}

    70

    71

/**

    72

 * Make a random tree tile of the given tile

    73

 *

    74

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

    75

 * randomness like type and number of trees.

    76

 *

    77

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

    78

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

    79

 */

    80

static void PlaceTree(TileIndex tile, uint32 r)

    81

{

    82

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

    83

    84

	if (tree != TREE_INVALID) {

    85

		MakeTree(tile, tree, GB(r, 22, 2), min(GB(r, 16, 3), 6), TREE_GROUND_GRASS, 0);

    86

    87

		/* above snowline? */

    88

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

    89

			SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

    90

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

    91

		} else {

    92

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

    93

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

    94

		}

    95

	}

    96

}

    97

    98

/**

    99

 * Place some amount of trees around a given tile.

   100

 *

   101

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

   102

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

   103

 * around the given tile.

   104

 *

   105

 * @param tile The center of the trees to add

   106

 */

   107

static void DoPlaceMoreTrees(TileIndex tile)

   108

{

   109

	uint i;

   110

   111

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

   112

		uint32 r = Random();

   113

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

   114

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

   115

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

   116

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

   117

   118

		if (dist <= 13 &&

   119

				IsTileType(cur_tile, MP_CLEAR) &&

   120

				!IsBridgeAbove(cur_tile) &&

   121

				!IsClearGround(cur_tile, CLEAR_FIELDS) &&

   122

				!IsClearGround(cur_tile, CLEAR_ROCKS)) {

   123

			PlaceTree(cur_tile, r);

   124

		}

   125

	}

   126

}

   127

   128

/**

   129

 * Place more trees on the map.

   130

 *

   131

 * This function add more trees to the map.

   132

 */

   133

static void PlaceMoreTrees()

   134

{

   135

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

   136

	do {

   137

		DoPlaceMoreTrees(RandomTile());

   138

	} while (--i);

   139

}

   140

   141

/**

   142

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

   143

 *

   144

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

   145

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

   146

 *

   147

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

   148

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

   149

 */

   150

void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   151

{

   152

	uint i;

   153

   154

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

   155

		uint32 r = Random();

   156

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

   157

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

   158

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

   159

   160

		/* Keep in range of the existing tree */

   161

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

   162

   163

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

   164

		if (!IsTileType(cur_tile, MP_CLEAR) ||

   165

				IsClearGround(cur_tile, CLEAR_FIELDS) ||

   166

				IsClearGround(cur_tile, CLEAR_ROCKS))

   167

			continue;

   168

   169

		/* Not too much height difference */

   170

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

   171

   172

		/* Place one tree and quit */

   173

		PlaceTree(cur_tile, r);

   174

		break;

   175

	}

   176

}

   177

   178

/**

   179

 * Place some trees randomly

   180

 *

   181

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

   182

 */

   183

void PlaceTreesRandomly()

   184

{

   185

	uint i, j, ht;

   186

   187

	i = ScaleByMapSize(1000);

   188

	do {

   189

		uint32 r = Random();

   190

		TileIndex tile = RandomTileSeed(r);

   191

   192

		IncreaseGeneratingWorldProgress(GWP_TREE);

   193

   194

		if (IsTileType(tile, MP_CLEAR) &&

   195

				!IsBridgeAbove(tile) &&

   196

				!IsClearGround(tile, CLEAR_FIELDS) &&

   197

				!IsClearGround(tile, CLEAR_ROCKS)) {

   198

			PlaceTree(tile, r);

   199

			if (_patches.tree_placer != TP_IMPROVED) continue;

   200

   201

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

   202

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

   203

			 *  It is almost real life ;) */

   204

			ht = GetTileZ(tile);

   205

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

   206

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   207

			while (j--) {

   208

				/* Above snowline more trees! */

   209

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

   210

					PlaceTreeAtSameHeight(tile, ht);

   211

					PlaceTreeAtSameHeight(tile, ht);

   212

				};

   213

   214

				PlaceTreeAtSameHeight(tile, ht);

   215

			}

   216

		}

   217

	} while (--i);

   218

   219

	/* place extra trees at rainforest area */

   220

	if (_opt.landscape == LT_TROPIC) {

   221

		i = ScaleByMapSize(15000);

   222

   223

		do {

   224

			uint32 r = Random();

   225

			TileIndex tile = RandomTileSeed(r);

   226

   227

			IncreaseGeneratingWorldProgress(GWP_TREE);

   228

   229

			if (IsTileType(tile, MP_CLEAR) &&

   230

					!IsBridgeAbove(tile) &&

   231

					!IsClearGround(tile, CLEAR_FIELDS) &&

   232

					GetTropicZone(tile) == TROPICZONE_RAINFOREST) {

   233

				PlaceTree(tile, r);

   234

			}

   235

		} while (--i);

   236

	}

   237

}

   238

   239

/**

   240

 * Place new trees.

   241

 *

   242

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

   243

 * place randomly the trees for a new game.

   244

 */

   245

void GenerateTrees()

   246

{

   247

	uint i, total;

   248

   249

	if (_patches.tree_placer == TP_NONE) return;

   250

   251

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

   252

   253

	switch (_patches.tree_placer) {

   254

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

   255

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

   256

		default: NOT_REACHED(); return;

   257

	}

   258

   259

	total = ScaleByMapSize(1000);

   260

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

   261

	total *= i;

   262

	SetGeneratingWorldProgress(GWP_TREE, total);

   263

   264

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

   265

		PlaceTreesRandomly();

   266

	}

   267

}

   268

   269

/** Plant a tree.

   270

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

   271

 * @param flags type of operation

   272

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

   273

 * @param p2 end tile of area-drag

   274

 */

   275

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

   276

{

   277

	StringID msg = INVALID_STRING_ID;

   278

	CommandCost cost(EXPENSES_OTHER);

   279

	int ex;

   280

	int ey;

   281

	int sx, sy, x, y;

   282

   283

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

   284

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

   285

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

   286

   287

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

   288

	ex = TileX(tile);

   289

	ey = TileY(tile);

   290

	sx = TileX(p2);

   291

	sy = TileY(p2);

   292

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

   293

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

   294

   295

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

   296

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

   297

			TileIndex tile = TileXY(x, y);

   298

   299

			switch (GetTileType(tile)) {

   300

				case MP_TREES:

   301

					/* no more space for trees? */

   302

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

   303

						msg = STR_2803_TREE_ALREADY_HERE;

   304

						continue;

   305

					}

   306

   307

					if (flags & DC_EXEC) {

   308

						AddTreeCount(tile, 1);

   309

						MarkTileDirtyByTile(tile);

   310

					}

   311

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

   312

					cost.AddCost(_price.build_trees * 2);

   313

					break;

   314

   315

				case MP_WATER:

   316

					msg = STR_3807_CAN_T_BUILD_ON_WATER;

   317

					continue;

   318

					break;

   319

   320

				case MP_CLEAR:

   321

					if (!IsTileOwner(tile, OWNER_NONE) ||

   322

							IsBridgeAbove(tile)) {

   323

						msg = STR_2804_SITE_UNSUITABLE;

   324

						continue;

   325

					}

   326

   327

					switch (GetClearGround(tile)) {

   328

						case CLEAR_FIELDS: cost.AddCost(_price.clear_fields); break;

   329

						case CLEAR_ROCKS:  cost.AddCost(_price.clear_rocks); break;

   330

						default: break;

   331

					}

   332

   333

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

   334

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

   335

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

   336

					}

   337

   338

					if (flags & DC_EXEC) {

   339

						TreeType treetype;

   340

						uint growth;

   341

   342

						treetype = (TreeType)p1;

   343

						if (treetype == TREE_INVALID) {

   344

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

   345

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   346

						}

   347

   348

						growth = _game_mode == GM_EDITOR ? 3 : 0;

   349

						switch (GetClearGround(tile)) {

   350

							case CLEAR_ROUGH:  MakeTree(tile, treetype, 0, growth, TREE_GROUND_ROUGH, 3); break;

   351

							case CLEAR_SNOW:

   352

							case CLEAR_DESERT: MakeTree(tile, treetype, 0, growth, TREE_GROUND_SNOW_DESERT, GetClearDensity(tile)); break;

   353

							default:           MakeTree(tile, treetype, 0, growth, TREE_GROUND_GRASS, GetClearDensity(tile)); break;

   354

						}

   355

						MarkTileDirtyByTile(tile);

   356

   357

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

   358

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   359

					}

   360

					cost.AddCost(_price.build_trees);

   361

					break;

   362

   363

				default:

   364

					msg = STR_2804_SITE_UNSUITABLE;

   365

					break;

   366

			}

   367

		}

   368

	}

   369

   370

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

   371

		return_cmd_error(msg);

   372

	} else {

   373

		return cost;

   374

	}

   375

}

   376

   377

struct TreeListEnt {

   378

	SpriteID image;

   379

	SpriteID pal;

   380

	byte x, y;

   381

};

   382

   383

static void DrawTile_Trees(TileInfo *ti)

   384

{

   385

	const PalSpriteID *s;

   386

	const TreePos* d;

   387

	byte z;

   388

   389

	switch (GetTreeGround(ti->tile)) {

   390

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

   391

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   392

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

   393

	}

   394

   395

	DrawClearLandFence(ti);

   396

   397

	z = ti->z;

   398

	if (ti->tileh != SLOPE_FLAT) {

   399

		z += 4;

   400

		if (IsSteepSlope(ti->tileh)) z += 4;

   401

	}

   402

   403

	{

   404

		uint16 tmp = ti->x;

   405

		uint index;

   406

   407

		tmp = ROR(tmp, 2);

   408

		tmp -= ti->y;

   409

		tmp = ROR(tmp, 3);

   410

		tmp -= ti->x;

   411

		tmp = ROR(tmp, 1);

   412

		tmp += ti->y;

   413

   414

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

   415

   416

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

   417

   418

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

   419

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

   420

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

   421

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

   422

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

   423

		}

   424

   425

		assert(index < lengthof(_tree_layout_sprite));

   426

		s = _tree_layout_sprite[index];

   427

	}

   428

   429

	StartSpriteCombine();

   430

   431

	if (!(IsTransparencySet(TO_TREES) && _patches.invisible_trees)) {

   432

		TreeListEnt te[4];

   433

		uint i;

   434

   435

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

   436

		i = GetTreeCount(ti->tile) + 1;

   437

		do {

   438

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

   439

			SpriteID pal = s[0].pal;

   440

   441

			te[i].image = image;

   442

			te[i].pal   = pal;

   443

			te[i].x = d->x;

   444

			te[i].y = d->y;

   445

			s++;

   446

			d++;

   447

		} while (i);

   448

   449

		/* draw them in a sorted way */

   450

		for (;;) {

   451

			byte min = 0xFF;

   452

			TreeListEnt *tep = NULL;

   453

   454

			i = GetTreeCount(ti->tile) + 1;

   455

			do {

   456

				if (te[--i].image != 0 && te[i].x + te[i].y < min) {

   457

					min = te[i].x + te[i].y;

   458

					tep = &te[i];

   459

				}

   460

			} while (i);

   461

   462

			if (tep == NULL) break;

   463

   464

			AddSortableSpriteToDraw(tep->image, tep->pal, ti->x + tep->x, ti->y + tep->y, 16 - tep->x, 16 - tep->y, 0x30, z, IsTransparencySet(TO_TREES), -tep->x, -tep->y);

   465

			tep->image = 0;

   466

		}

   467

	}

   468

   469

	EndSpriteCombine();

   470

}

   471

   472

   473

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

   474

{

   475

	uint z;

   476

	Slope tileh = GetTileSlope(tile, &z);

   477

   478

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

   479

}

   480

   481

static Foundation GetFoundation_Trees(TileIndex tile, Slope tileh)

   482

{

   483

	return FOUNDATION_NONE;

   484

}

   485

   486

static CommandCost ClearTile_Trees(TileIndex tile, byte flags)