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 "table/strings.h"

    10

#include "table/sprites.h"

    11

#include "table/tree_land.h"

    12

#include "functions.h"

    13

#include "map.h"

    14

#include "landscape.h"

    15

#include "tile.h"

    16

#include "tree_map.h"

    17

#include "viewport.h"

    18

#include "command.h"

    19

#include "town.h"

    20

#include "sound.h"

    21

#include "variables.h"

    22

#include "genworld.h"

    23

    24

enum TreePlacer {

    25

	TP_NONE,

    26

	TP_ORIGINAL,

    27

	TP_IMPROVED,

    28

};

    29

    30

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

    31

{

    32

	switch (_opt.landscape) {

    33

		case LT_TEMPERATE:

    34

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

    35

    36

		case LT_ARCTIC:

    37

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

    38

    39

		case LT_TROPIC:

    40

			switch (GetTropicZone(tile)) {

    41

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

    42

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

    43

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

    44

			}

    45

    46

		default:

    47

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

    48

	}

    49

}

    50

    51

static void PlaceTree(TileIndex tile, uint32 r)

    52

{

    53

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

    54

    55

	if (tree != TREE_INVALID) {

    56

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

    57

    58

		/* above snowline? */

    59

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

    60

			SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

    61

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

    62

		} else {

    63

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

    64

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

    65

		}

    66

	}

    67

}

    68

    69

static void DoPlaceMoreTrees(TileIndex tile)

    70

{

    71

	uint i;

    72

    73

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

    74

		uint32 r = Random();

    75

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

    76

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

    77

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

    78

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

    79

    80

		if (dist <= 13 &&

    81

				IsTileType(cur_tile, MP_CLEAR) &&

    82

				!IsBridgeAbove(cur_tile) &&

    83

				!IsClearGround(cur_tile, CLEAR_FIELDS) &&

    84

				!IsClearGround(cur_tile, CLEAR_ROCKS)) {

    85

			PlaceTree(cur_tile, r);

    86

		}

    87

	}

    88

}

    89

    90

static void PlaceMoreTrees()

    91

{

    92

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

    93

	do {

    94

		DoPlaceMoreTrees(RandomTile());

    95

	} while (--i);

    96

}

    97

    98

/**

    99

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

   100

 *  This gives cool effects to the map.

   101

 */

   102

void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   103

{

   104

	uint i;

   105

   106

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

   107

		uint32 r = Random();

   108

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

   109

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

   110

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

   111

   112

		/* Keep in range of the existing tree */

   113

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

   114

   115

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

   116

		if (!IsTileType(cur_tile, MP_CLEAR) ||

   117

				IsClearGround(cur_tile, CLEAR_FIELDS) ||

   118

				IsClearGround(cur_tile, CLEAR_ROCKS))

   119

			continue;

   120

   121

		/* Not too much height difference */

   122

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

   123

   124

		/* Place one tree and quit */

   125

		PlaceTree(cur_tile, r);

   126

		break;

   127

	}

   128

}

   129

   130

void PlaceTreesRandomly()

   131

{

   132

	uint i, j, ht;

   133

   134

	i = ScaleByMapSize(1000);

   135

	do {

   136

		uint32 r = Random();

   137

		TileIndex tile = RandomTileSeed(r);

   138

   139

		IncreaseGeneratingWorldProgress(GWP_TREE);

   140

   141

		if (IsTileType(tile, MP_CLEAR) &&

   142

				!IsBridgeAbove(tile) &&

   143

				!IsClearGround(tile, CLEAR_FIELDS) &&

   144

				!IsClearGround(tile, CLEAR_ROCKS)) {

   145

			PlaceTree(tile, r);

   146

			if (_patches.tree_placer != TP_IMPROVED) continue;

   147

   148

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

   149

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

   150

			 *  It is almost real life ;) */

   151

			ht = GetTileZ(tile);

   152

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

   153

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   154

			while (j--) {

   155

				/* Above snowline more trees! */

   156

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

   157

					PlaceTreeAtSameHeight(tile, ht);

   158

					PlaceTreeAtSameHeight(tile, ht);

   159

				};

   160

   161

				PlaceTreeAtSameHeight(tile, ht);

   162

			}

   163

		}

   164

	} while (--i);

   165

   166

	/* place extra trees at rainforest area */

   167

	if (_opt.landscape == LT_TROPIC) {

   168

		i = ScaleByMapSize(15000);

   169

   170

		do {

   171

			uint32 r = Random();

   172

			TileIndex tile = RandomTileSeed(r);

   173

   174

			IncreaseGeneratingWorldProgress(GWP_TREE);

   175

   176

			if (IsTileType(tile, MP_CLEAR) &&

   177

					!IsBridgeAbove(tile) &&

   178

					!IsClearGround(tile, CLEAR_FIELDS) &&

   179

					GetTropicZone(tile) == TROPICZONE_RAINFOREST) {

   180

				PlaceTree(tile, r);

   181

			}

   182

		} while (--i);

   183

	}

   184

}

   185

   186

void GenerateTrees()

   187

{

   188

	uint i, total;

   189

   190

	if (_patches.tree_placer == TP_NONE) return;

   191

   192

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

   193

   194

	switch (_patches.tree_placer) {

   195

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

   196

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

   197

		default: NOT_REACHED(); return;

   198

	}

   199

   200

	total = ScaleByMapSize(1000);

   201

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

   202

	total *= i;

   203

	SetGeneratingWorldProgress(GWP_TREE, total);

   204

   205

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

   206

		PlaceTreesRandomly();

   207

	}

   208

}

   209

   210

/** Plant a tree.

   211

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

   212

 * @param flags type of operation

   213

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

   214

 * @param p2 end tile of area-drag

   215

 */

   217

{

   218

	StringID msg = INVALID_STRING_ID;

   220

	int ex;

   221

	int ey;

   222

	int sx, sy, x, y;

   223

   224

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

   225

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

   226

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

   227

   228

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   229

   230

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

   231

	ex = TileX(tile);

   232

	ey = TileY(tile);

   233

	sx = TileX(p2);

   234

	sy = TileY(p2);

   235

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

   236

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

   237

   238

	cost = 0; // total cost

   239

   240

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

   241

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

   242

			TileIndex tile = TileXY(x, y);

   243

   244

			switch (GetTileType(tile)) {

   245

				case MP_TREES:

   246

					/* no more space for trees? */

   247

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

   248

						msg = STR_2803_TREE_ALREADY_HERE;

   249

						continue;

   250

					}

   251

   252

					if (flags & DC_EXEC) {

   253

						AddTreeCount(tile, 1);

   254

						MarkTileDirtyByTile(tile);

   255

					}

   256

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

   257

					cost += _eco->GetPrice(CEconomy::BUILD_TREES) * 2;

   258

					break;

   259

   260

				case MP_CLEAR:

   261

					if (!IsTileOwner(tile, OWNER_NONE) ||

   262

							IsBridgeAbove(tile)) {

   263

						msg = STR_2804_SITE_UNSUITABLE;

   264

						continue;

   265

					}

   266

   267

					switch (GetClearGround(tile)) {

   268

						case CLEAR_FIELDS: cost += _eco->GetPrice(CEconomy::CLEAR_3); break;

   269

						case CLEAR_ROCKS:  cost += _eco->GetPrice(CEconomy::CLEAR_2); break;

   270

						default: break;

   271

					}

   272

   273

					if (flags & DC_EXEC) {

   274

						TreeType treetype;

   275

						uint growth;

   276

   277

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

   278

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

   279

							if (t != NULL)

   280

								ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   281

						}

   282

   283

						treetype = (TreeType)p1;

   284

						if (treetype == TREE_INVALID) {

   285

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

   286

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   287

						}

   288

   289

						growth = _game_mode == GM_EDITOR ? 3 : 0;

   290

						switch (GetClearGround(tile)) {

   291

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

   292

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

   293

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

   294

						}

   295

						MarkTileDirtyByTile(tile);

   296

   297

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

   298

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   299

					}

   300

					cost += _eco->GetPrice(CEconomy::BUILD_TREES);

   301

					break;

   302

   303

				default:

   304

					msg = STR_2804_SITE_UNSUITABLE;

   305

					break;

   306

			}

   307

		}

   308

	}

   309

   310

	if (cost == 0) {

   311

		return_cmd_error(msg);

   312

	} else {

   313

		return cost;

   314

	}

   315

}

   316

   317

struct TreeListEnt {

   318

	SpriteID image;

   319

	SpriteID pal;

   320

	byte x, y;

   321

};

   322

   323

static void DrawTile_Trees(TileInfo *ti)

   324

{

   325

	const PalSpriteID *s;

   326

	const TreePos* d;

   327

	byte z;

   328

   329

	switch (GetTreeGround(ti->tile)) {

   330

		case TREE_GROUND_GRASS: DrawClearLandTile(ti, 3); break;

   331

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   332

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

   333

	}

   334

   335

	DrawClearLandFence(ti);

   336

   337

	z = ti->z;

   338

	if (ti->tileh != SLOPE_FLAT) {

   339

		z += 4;

   340

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

   341

	}

   342

   343

	{

   344

		uint16 tmp = ti->x;

   345

		uint index;

   346

   347

		tmp = ROR(tmp, 2);

   348

		tmp -= ti->y;

   349

		tmp = ROR(tmp, 3);

   350

		tmp -= ti->x;

   351

		tmp = ROR(tmp, 1);

   352

		tmp += ti->y;

   353

   354

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

   355

   356

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

   357

   358

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

   359

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

   360

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

   361

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

   362

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

   363

		}

   364

   365

		assert(index < lengthof(_tree_layout_sprite));

   366

		s = _tree_layout_sprite[index];

   367

	}

   368

   369

	StartSpriteCombine();

   370

   371

	if (!HASBIT(_transparent_opt, TO_TREES) || !_patches.invisible_trees) {

   372

		TreeListEnt te[4];

   373

		uint i;

   374

   375

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

   376

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

   377

		do {

   378

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

   379

			SpriteID pal;

   380

			if (HASBIT(_transparent_opt, TO_TREES)) {

   381

				SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   382

				pal = PALETTE_TO_TRANSPARENT;

   383

			} else {

   384

				pal = s[0].pal;

   385

			}

   386

			te[i].image = image;

   387

			te[i].pal   = pal;

   388

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

   389

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

   390

			s++;

   391

			d++;

   392

		} while (i);

   393

   394

		/* draw them in a sorted way */

   395

		for (;;) {

   396

			byte min = 0xFF;

   397

			TreeListEnt *tep = NULL;

   398

   399

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

   400

			do {

   401

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

   402

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

   403

					tep = &te[i];

   404

				}

   405

			} while (i);

   406

   407

			if (tep == NULL) break;

   408

   409

			AddSortableSpriteToDraw(tep->image, tep->pal, ti->x + tep->x, ti->y + tep->y, 5, 5, 0x10, z);

   410

			tep->image = 0;

   411

		}

   412

	}

   413

   414

	EndSpriteCombine();

   415

}

   416

   417

   418

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

   419

{

   420

	uint z;

   421

	Slope tileh = GetTileSlope(tile, &z);

   422

   423

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

   424

}

   425

   426

static Slope GetSlopeTileh_Trees(TileIndex tile, Slope tileh)

   427

{

   428

	return tileh;

   429

}

   430

   432

{

   433

	uint num;

   434

   435

	if ((flags & DC_EXEC) && IsValidPlayer(_current_player)) {

   436

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

   437

		if (t != NULL)

   438

			ChangeTownRating(t, RATING_TREE_DOWN_STEP, RATING_TREE_MINIMUM);

   439

	}

   440

   441

	num = GetTreeCount(tile) + 1;

   442

	if (IS_INT_INSIDE(GetTreeType(tile), TREE_RAINFOREST, TREE_CACTUS)) num *= 4;

   443

   444

	if (flags & DC_EXEC) DoClearSquare(tile);

   445

   446

	return num * _eco->GetPrice(CEconomy::REMOVE_TREES);

   447

}

   448

   449

static void GetAcceptedCargo_Trees(TileIndex tile, AcceptedCargo ac)

   450

{

   451

	/* not used */

   452

}

   453

   454

static void GetTileDesc_Trees(TileIndex tile, TileDesc *td)

   455

{

   456

	TreeType tt = GetTreeType(tile);

   457

   458

	if (IS_INT_INSIDE(tt, TREE_RAINFOREST, TREE_CACTUS)) {

   459

		td->str = STR_280F_RAINFOREST;

   460

	} else if (tt == TREE_CACTUS) {

   461

		td->str = STR_2810_CACTUS_PLANTS;

   462

	} else {

   463

		td->str = STR_280E_TREES;

   464

	}

   465

   466

	td->owner = GetTileOwner(tile);

   467

}

   468

   469

static void AnimateTile_Trees(TileIndex tile)

   470

{

   471

	/* not used */

   472

}

   473

   474

static void TileLoopTreesDesert(TileIndex tile)

   475

{

   476

	switch (GetTropicZone(tile)) {

   477

		case TROPICZONE_DESERT:

   478

			if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) {

   479

				SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

   480

				MarkTileDirtyByTile(tile);

   481

			}

   482

			break;

   483

   484

		case TROPICZONE_RAINFOREST: {

   485

			static const SoundFx forest_sounds[] = {

   486

				SND_42_LOON_BIRD,

   487

				SND_43_LION,