1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "table/strings.h"

     7

#include "table/sprites.h"

     8

#include "table/tree_land.h"

     9

#include "functions.h"

    10

#include "map.h"

    11

#include "tile.h"

    12

#include "tree_map.h"

    13

#include "viewport.h"

    14

#include "command.h"

    15

#include "town.h"

    16

#include "sound.h"

    17

#include "variables.h"

    18

#include "genworld.h"

    19

    20

enum TreePlacer {

    21

	TP_NONE,

    22

	TP_ORIGINAL,

    23

	TP_IMPROVED,

    24

};

    25

    26

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

    27

{

    28

	switch (_opt.landscape) {

    29

		case LT_NORMAL:

    30

			return seed * TREE_COUNT_TEMPERATE / 256 + TREE_TEMPERATE;

    31

    32

		case LT_HILLY:

    33

			return seed * TREE_COUNT_SUB_ARCTIC / 256 + TREE_SUB_ARCTIC;

    34

    35

		case LT_DESERT:

    36

			switch (GetTropicZone(tile)) {

    37

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

    38

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

    39

				default:                 return seed * TREE_COUNT_RAINFOREST / 256 + TREE_RAINFOREST;

    40

			}

    41

    42

		default:

    43

			return seed * TREE_COUNT_TOYLAND / 256 + TREE_TOYLAND;

    44

	}

    45

}

    46

    47

static void PlaceTree(TileIndex tile, uint32 r)

    48

{

    49

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

    50

    51

	if (tree != TREE_INVALID) {

    52

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

    53

    54

		// above snowline?

    55

		if (_opt.landscape == LT_HILLY && GetTileZ(tile) > _opt.snow_line) {

    56

			SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

    57

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

    58

		} else {

    59

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

    60

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

    61

		}

    62

	}

    63

}

    64

    65

static void DoPlaceMoreTrees(TileIndex tile)

    66

{

    67

	uint i;

    68

    69

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

    70

		uint32 r = Random();

    71

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

    72

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

    73

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

    74

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

    75

    76

		if (dist <= 13 &&

    77

				IsTileType(cur_tile, MP_CLEAR) &&

    78

				!IsClearGround(cur_tile, CLEAR_FIELDS) &&

    79

				!IsClearGround(cur_tile, CLEAR_ROCKS)) {

    80

			PlaceTree(cur_tile, r);

    81

		}

    82

	}

    83

}

    84

    85

static void PlaceMoreTrees(void)

    86

{

    87

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

    88

	do {

    89

		DoPlaceMoreTrees(RandomTile());

    90

	} while (--i);

    91

}

    92

    93

/**

    94

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

    95

 *  This gives cool effects to the map.

    96

 */

    97

void PlaceTreeAtSameHeight(TileIndex tile, uint height)

    98

{

    99

	uint i;

   100

   101

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

   102

		uint32 r = Random();

   103

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

   104

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

   105

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

   106

   107

		/* Keep in range of the existing tree */

   108

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

   109

   110

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

   111

		if (!IsTileType(cur_tile, MP_CLEAR) ||

   112

				IsClearGround(cur_tile, CLEAR_FIELDS) ||

   113

				IsClearGround(cur_tile, CLEAR_ROCKS))

   114

			continue;

   115

   116

		/* Not too much height difference */

   117

		if (myabs(GetTileZ(cur_tile) - height) > 2) continue;

   118

   119

		/* Place one tree and quit */

   120

		PlaceTree(cur_tile, r);

   121

		break;

   122

	}

   123

}

   124

   125

void PlaceTreesRandomly(void)

   126

{

   127

	uint i, j, ht;

   128

   129

	i = ScaleByMapSize(1000);

   130

	do {

   131

		uint32 r = Random();

   132

		TileIndex tile = RandomTileSeed(r);

   133

   134

		IncreaseGeneratingWorldProgress(GWP_TREE);

   135

   136

		if (IsTileType(tile, MP_CLEAR) &&

   137

				!IsClearGround(tile, CLEAR_FIELDS) &&

   138

				!IsClearGround(tile, CLEAR_ROCKS)) {

   139

			PlaceTree(tile, r);

   140

			if (_patches.tree_placer != TP_IMPROVED) continue;

   141

   142

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

   143

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

   144

			 *  It is almost real life ;) */

   145

			ht = GetTileZ(tile);

   146

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

   147

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   148

			while (j--) {

   149

				/* Above snowline more trees! */

   150

				if (_opt.landscape == LT_HILLY && ht > _opt.snow_line) {

   151

					PlaceTreeAtSameHeight(tile, ht);

   152

					PlaceTreeAtSameHeight(tile, ht);

   153

				};

   154

   155

				PlaceTreeAtSameHeight(tile, ht);

   156

			}

   157

		}

   158

	} while (--i);

   159

   160

	/* place extra trees at rainforest area */

   161

	if (_opt.landscape == LT_DESERT) {

   162

		i = ScaleByMapSize(15000);

   163

   164

		do {

   165

			uint32 r = Random();

   166

			TileIndex tile = RandomTileSeed(r);

   167

   168

			IncreaseGeneratingWorldProgress(GWP_TREE);

   169

   170

			if (IsTileType(tile, MP_CLEAR) && !IsClearGround(tile, CLEAR_FIELDS) && GetTropicZone(tile) == TROPICZONE_RAINFOREST) {

   171

				PlaceTree(tile, r);

   172

			}

   173

		} while (--i);

   174

	}

   175

}

   176

   177

void GenerateTrees(void)

   178

{

   179

	uint i, total;

   180

   181

	if (_patches.tree_placer == TP_NONE) return;

   182

   183

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

   184

   185

	switch (_patches.tree_placer) {

   186

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

   187

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

   188

		default: NOT_REACHED(); return;

   189

	}

   190

   191

	total = ScaleByMapSize(1000);

   192

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

   193

	total *= i;

   194

	SetGeneratingWorldProgress(GWP_TREE, total);

   195

   196

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

   197

		PlaceTreesRandomly();

   198

	}

   199

}

   200

   201

/** Plant a tree.

   202

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

   203

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

   204

 * @param p2 end tile of area-drag

   205

 */

   206

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

   207

{

   208

	StringID msg = INVALID_STRING_ID;

   209

	int32 cost;

   210

	int ex;

   211

	int ey;

   212

	int sx, sy, x, y;

   213

   214

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

   215

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

   216

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

   217

   218

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   219

   220

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

   221

	ex = TileX(tile);

   222

	ey = TileY(tile);

   223

	sx = TileX(p2);

   224

	sy = TileY(p2);

   225

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

   226

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

   227

   228

	cost = 0; // total cost

   229

   230

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

   231

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

   232

			TileIndex tile = TileXY(x, y);

   233

   234

			if (!EnsureNoVehicle(tile)) continue;

   235

   236

			switch (GetTileType(tile)) {

   237

				case MP_TREES:

   238

					// no more space for trees?

   239

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

   240

						msg = STR_2803_TREE_ALREADY_HERE;

   241

						continue;

   242

					}

   243

   244

					if (flags & DC_EXEC) {

   245

						AddTreeCount(tile, 1);

   246

						MarkTileDirtyByTile(tile);

   247

					}

   248

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

   249

					cost += _price.build_trees * 2;

   250

					break;

   251

   252

				case MP_CLEAR:

   253

					if (!IsTileOwner(tile, OWNER_NONE)) {

   254

						msg = STR_2804_SITE_UNSUITABLE;

   255

						continue;

   256

					}

   257

   258

					switch (GetClearGround(tile)) {

   259

						case CLEAR_FIELDS: cost += _price.clear_3; break;

   260

						case CLEAR_ROCKS:  cost += _price.clear_2; break;

   261

						default: break;

   262

					}

   263

   264

					if (flags & DC_EXEC) {

   265

						TreeType treetype;

   266

						uint growth;

   267

   268

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

   269

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

   270

							if (t != NULL)

   271

								ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   272

						}

   273

   274

						treetype = p1;

   275

						if (treetype == TREE_INVALID) {

   276

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

   277

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   278

						}

   279

   280

						growth = _game_mode == GM_EDITOR ? 3 : 0;

   281

						switch (GetClearGround(tile)) {

   282

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

   283

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

   284

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

   285

						}

   286

						MarkTileDirtyByTile(tile);

   287

   288

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

   289

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   290

					}

   291

					cost += _price.build_trees;

   292

					break;

   293

   294

				default:

   295

					msg = STR_2804_SITE_UNSUITABLE;

   296

					break;

   297

			}

   298

		}

   299

	}

   300

   301

	if (cost == 0) {

   302

		return_cmd_error(msg);

   303

	} else {

   304

		return cost;

   305

	}

   306

}

   307

   308

typedef struct TreeListEnt {

   309

	uint32 image;

   310

	byte x,y;

   311

} TreeListEnt;

   312

   313

static void DrawTile_Trees(TileInfo *ti)

   314

{

   315

	const uint32 *s;

   316

	const TreePos* d;

   317

	byte z;

   318

   319

	switch (GetTreeGround(ti->tile)) {

   320

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

   321

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   322

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

   323

	}

   324

   325

	DrawClearLandFence(ti);

   326

   327

	z = ti->z;

   328

	if (ti->tileh != SLOPE_FLAT) {

   329

		z += 4;

   330

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

   331

	}

   332

   333

	{

   334

		uint16 tmp = ti->x;

   335

		uint index;

   336

   337

		tmp = ROR(tmp, 2);

   338

		tmp -= ti->y;

   339

		tmp = ROR(tmp, 3);

   340

		tmp -= ti->x;

   341

		tmp = ROR(tmp, 1);

   342

		tmp += ti->y;

   343

   344

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

   345

   346

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

   347

   348

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

   349

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

   350

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

   351

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

   352

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

   353

		}

   354

   355

		assert(index < lengthof(_tree_layout_sprite));

   356

		s = _tree_layout_sprite[index];

   357

	}

   358

   359

	StartSpriteCombine();

   360

   361

	if (!(_display_opt & DO_TRANS_BUILDINGS) || !_patches.invisible_trees) {

   362

		TreeListEnt te[4];

   363

		uint i;

   364

   365

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

   366

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

   367

		do {

   368

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

   369

			if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   370

			te[i].image = image;

   371

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

   372

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

   373

			s++;

   374

			d++;

   375

		} while (i);

   376

   377

		/* draw them in a sorted way */

   378

		for (;;) {

   379

			byte min = 0xFF;

   380

			TreeListEnt *tep = NULL;

   381

   382

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

   383

			do {

   384

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

   385

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

   386

					tep = &te[i];

   387

				}

   388

			} while (i);

   389

   390

			if (tep == NULL) break;

   391

   392

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

   393

			tep->image = 0;

   394

		}

   395

	}

   396

   397

	EndSpriteCombine();

   398

}

   399

   400

   401

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

   402

{

   403

	uint z;

   404

	uint tileh = GetTileSlope(tile, &z);

   405

   406

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

   407

}

   408

   409

static Slope GetSlopeTileh_Trees(TileIndex tile, Slope tileh)

   410

{

   411

	return tileh;

   412

}

   413

   414

static int32 ClearTile_Trees(TileIndex tile, byte flags)

   415

{

   416

	uint num;

   417

   418

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

   419

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

   420

		if (t != NULL)

   421

			ChangeTownRating(t, RATING_TREE_DOWN_STEP, RATING_TREE_MINIMUM);

   422

	}

   423

   424

	num = GetTreeCount(tile) + 1;

   425

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

   426

   427

	if (flags & DC_EXEC) DoClearSquare(tile);

   428

   429

	return num * _price.remove_trees;

   430

}

   431

   432

static void GetAcceptedCargo_Trees(TileIndex tile, AcceptedCargo ac)

   433

{

   434

	/* not used */

   435

}

   436

   437

static void GetTileDesc_Trees(TileIndex tile, TileDesc *td)

   438

{

   439

	TreeType tt = GetTreeType(tile);

   440

   441

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

   442

		td->str = STR_280F_RAINFOREST;

   443

	} else if (tt == TREE_CACTUS) {

   444

		td->str = STR_2810_CACTUS_PLANTS;

   445

	} else {

   446

		td->str = STR_280E_TREES;

   447

	}

   448

   449

	td->owner = GetTileOwner(tile);

   450

}

   451

   452

static void AnimateTile_Trees(TileIndex tile)

   453

{

   454

	/* not used */

   455

}

   456

   457

static void TileLoopTreesDesert(TileIndex tile)

   458

{

   459

	switch (GetTropicZone(tile)) {

   460

		case TROPICZONE_DESERT:

   461

			if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) {

   462

				SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

   463

				MarkTileDirtyByTile(tile);

   464

			}

   465

			break;

   466

   467

		case TROPICZONE_RAINFOREST: {

   468

			static const SoundFx forest_sounds[] = {

   469

				SND_42_LOON_BIRD,

   470

				SND_43_LION,

   471

				SND_44_MONKEYS,

   472

				SND_48_DISTANT_BIRD

   473

			};

   474

			uint32 r = Random();

   475

   476

			if (CHANCE16I(1, 200, r)) SndPlayTileFx(forest_sounds[GB(r, 16, 2)], tile);

   477

			break;

   478

		}

   479

   480

		default: break;

   481

	}

   482

}

   483

   484

static void TileLoopTreesAlps(TileIndex tile)

   485

{

   486

	int k = GetTileZ(tile) - _opt.snow_line + TILE_HEIGHT;

   487

   488

	if (k < 0) {

   489

		if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) return;

   490