1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "bridge_map.h"

     6

#include "clear_map.h"

     7

#include "table/strings.h"

     8

#include "table/sprites.h"

     9

#include "table/tree_land.h"

    10

#include "functions.h"

    11

#include "map.h"

    12

#include "landscape.h"

    13

#include "tile.h"

    14

#include "tree_map.h"

    15

#include "viewport.h"

    16

#include "command.h"

    17

#include "town.h"

    18

#include "sound.h"

    19

#include "variables.h"

    20

#include "genworld.h"

    21

    22

enum TreePlacer {

    23

	TP_NONE,

    24

	TP_ORIGINAL,

    25

	TP_IMPROVED,

    26

};

    27

    28

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

    29

{

    30

	switch (_opt.landscape) {

    31

		case LT_TEMPERATE:

    32

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

    33

    34

		case LT_ARCTIC:

    35

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

    36

    37

		case LT_TROPIC:

    38

			switch (GetTropicZone(tile)) {

    39

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

    40

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

    41

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

    42

			}

    43

    44

		default:

    45

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

    46

	}

    47

}

    48

    49

static void PlaceTree(TileIndex tile, uint32 r)

    50

{

    51

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

    52

    53

	if (tree != TREE_INVALID) {

    54

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

    55

    56

		// above snowline?

    57

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

    58

			SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

    59

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

    60

		} else {

    61

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

    62

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

    63

		}

    64

	}

    65

}

    66

    67

static void DoPlaceMoreTrees(TileIndex tile)

    68

{

    69

	uint i;

    70

    71

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

    72

		uint32 r = Random();

    73

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

    74

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

    75

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

    76

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

    77

    78

		if (dist <= 13 &&

    79

				IsTileType(cur_tile, MP_CLEAR) &&

    80

				!IsBridgeAbove(cur_tile) &&

    81

				!IsClearGround(cur_tile, CLEAR_FIELDS) &&

    82

				!IsClearGround(cur_tile, CLEAR_ROCKS)) {

    83

			PlaceTree(cur_tile, r);

    84

		}

    85

	}

    86

}

    87

    88

static void PlaceMoreTrees()

    89

{

    90

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

    91

	do {

    92

		DoPlaceMoreTrees(RandomTile());

    93

	} while (--i);

    94

}

    95

    96

/**

    97

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

    98

 *  This gives cool effects to the map.

    99

 */

   100

void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   101

{

   102

	uint i;

   103

   104

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

   105

		uint32 r = Random();

   106

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

   107

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

   108

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

   109

   110

		/* Keep in range of the existing tree */

   111

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

   112

   113

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

   114

		if (!IsTileType(cur_tile, MP_CLEAR) ||

   115

				IsClearGround(cur_tile, CLEAR_FIELDS) ||

   116

				IsClearGround(cur_tile, CLEAR_ROCKS))

   117

			continue;

   118

   119

		/* Not too much height difference */

   120

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

   121

   122

		/* Place one tree and quit */

   123

		PlaceTree(cur_tile, r);

   124

		break;

   125

	}

   126

}

   127

   128

void PlaceTreesRandomly()

   129

{

   130

	uint i, j, ht;

   131

   132

	i = ScaleByMapSize(1000);

   133

	do {

   134

		uint32 r = Random();

   135

		TileIndex tile = RandomTileSeed(r);

   136

   137

		IncreaseGeneratingWorldProgress(GWP_TREE);

   138

   139

		if (IsTileType(tile, MP_CLEAR) &&

   140

				!IsBridgeAbove(tile) &&

   141

				!IsClearGround(tile, CLEAR_FIELDS) &&

   142

				!IsClearGround(tile, CLEAR_ROCKS)) {

   143

			PlaceTree(tile, r);

   144

			if (_patches.tree_placer != TP_IMPROVED) continue;

   145

   146

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

   147

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

   148

			 *  It is almost real life ;) */

   149

			ht = GetTileZ(tile);

   150

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

   151

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   152

			while (j--) {

   153

				/* Above snowline more trees! */

   154

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

   155

					PlaceTreeAtSameHeight(tile, ht);

   156

					PlaceTreeAtSameHeight(tile, ht);

   157

				};

   158

   159

				PlaceTreeAtSameHeight(tile, ht);

   160

			}

   161

		}

   162

	} while (--i);

   163

   164

	/* place extra trees at rainforest area */

   165

	if (_opt.landscape == LT_TROPIC) {

   166

		i = ScaleByMapSize(15000);

   167

   168

		do {

   169

			uint32 r = Random();

   170

			TileIndex tile = RandomTileSeed(r);

   171

   172

			IncreaseGeneratingWorldProgress(GWP_TREE);

   173

   174

			if (IsTileType(tile, MP_CLEAR) &&

   175

					!IsBridgeAbove(tile) &&

   176

					!IsClearGround(tile, CLEAR_FIELDS) &&

   177

					GetTropicZone(tile) == TROPICZONE_RAINFOREST) {

   178

				PlaceTree(tile, r);

   179

			}

   180

		} while (--i);

   181

	}

   182

}

   183

   184

void GenerateTrees()

   185

{

   186

	uint i, total;

   187

   188

	if (_patches.tree_placer == TP_NONE) return;

   189

   190

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

   191

   192

	switch (_patches.tree_placer) {

   193

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

   194

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

   195

		default: NOT_REACHED(); return;

   196

	}

   197

   198

	total = ScaleByMapSize(1000);

   199

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

   200

	total *= i;

   201

	SetGeneratingWorldProgress(GWP_TREE, total);

   202

   203

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

   204

		PlaceTreesRandomly();

   205

	}

   206

}

   207

   208

/** Plant a tree.

   209

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

   210

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

   211

 * @param p2 end tile of area-drag

   212

 */

   213

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

   214

{

   215

	StringID msg = INVALID_STRING_ID;

   216

	int32 cost;

   217

	int ex;

   218

	int ey;

   219

	int sx, sy, x, y;

   220

   221

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

   222

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

   223

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

   224

   225

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   226

   227

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

   228

	ex = TileX(tile);

   229

	ey = TileY(tile);

   230

	sx = TileX(p2);

   231

	sy = TileY(p2);

   232

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

   233

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

   234

   235

	cost = 0; // total cost

   236

   237

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

   238

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

   239

			TileIndex tile = TileXY(x, y);

   240

   241

			switch (GetTileType(tile)) {

   242

				case MP_TREES:

   243

					// no more space for trees?

   244

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

   245

						msg = STR_2803_TREE_ALREADY_HERE;

   246

						continue;

   247

					}

   248

   249

					if (flags & DC_EXEC) {

   250

						AddTreeCount(tile, 1);

   251

						MarkTileDirtyByTile(tile);

   252

					}

   253

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

   254

					cost += _price.build_trees * 2;

   255

					break;

   256

   257

				case MP_CLEAR:

   258

					if (!IsTileOwner(tile, OWNER_NONE) ||

   259

							IsBridgeAbove(tile)) {

   260

						msg = STR_2804_SITE_UNSUITABLE;

   261

						continue;

   262

					}

   263

   264

					switch (GetClearGround(tile)) {

   265

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

   266

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

   267

						default: break;

   268

					}

   269

   270

					if (flags & DC_EXEC) {

   271

						TreeType treetype;

   272

						uint growth;

   273

   274

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

   275

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

   276

							if (t != NULL)

   277

								ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   278

						}

   279

   280

						treetype = (TreeType)p1;

   281

						if (treetype == TREE_INVALID) {

   282

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

   283

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   284

						}

   285

   286

						growth = _game_mode == GM_EDITOR ? 3 : 0;

   287

						switch (GetClearGround(tile)) {

   288

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

   289

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

   290

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

   291

						}

   292

						MarkTileDirtyByTile(tile);

   293

   294

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

   295

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   296

					}

   297

					cost += _price.build_trees;

   298

					break;

   299

   300

				default:

   301

					msg = STR_2804_SITE_UNSUITABLE;

   302

					break;

   303

			}

   304

		}

   305

	}

   306

   307

	if (cost == 0) {

   308

		return_cmd_error(msg);

   309

	} else {

   310

		return cost;

   311

	}

   312

}

   313

   314

struct TreeListEnt {

   315

	SpriteID image;

   316

	SpriteID pal;

   317

	byte x,y;

   318

};

   319

   320

static void DrawTile_Trees(TileInfo *ti)

   321

{

   322

	const PalSpriteID *s;

   323

	const TreePos* d;

   324

	byte z;

   325

   326

	switch (GetTreeGround(ti->tile)) {

   327

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

   328

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   329

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

   330

	}

   331

   332

	DrawClearLandFence(ti);

   333

   334

	z = ti->z;

   335

	if (ti->tileh != SLOPE_FLAT) {

   336

		z += 4;

   337

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

   338

	}

   339

   340

	{

   341

		uint16 tmp = ti->x;

   342

		uint index;

   343

   344

		tmp = ROR(tmp, 2);

   345

		tmp -= ti->y;

   346

		tmp = ROR(tmp, 3);

   347

		tmp -= ti->x;

   348

		tmp = ROR(tmp, 1);

   349

		tmp += ti->y;

   350

   351

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

   352

   353

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

   354

   355

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

   356

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

   357

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

   358

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

   359

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

   360

		}

   361

   362

		assert(index < lengthof(_tree_layout_sprite));

   363

		s = _tree_layout_sprite[index];

   364

	}

   365

   366

	StartSpriteCombine();

   367

   368

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

   369

		TreeListEnt te[4];

   370

		uint i;

   371

   372

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

   373

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

   374

		do {

   375

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

   376

			SpriteID pal;

   377

			if (_display_opt & DO_TRANS_BUILDINGS) {

   378

				SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   379

				pal = PALETTE_TO_TRANSPARENT;

   380

			} else {

   381

				pal = s[0].pal;

   382

			}

   383

			te[i].image = image;

   384

			te[i].pal   = pal;

   385

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

   386

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

   387

			s++;

   388

			d++;

   389

		} while (i);

   390

   391

		/* draw them in a sorted way */

   392

		for (;;) {

   393

			byte min = 0xFF;

   394

			TreeListEnt *tep = NULL;

   395

   396

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

   397

			do {

   398

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

   399

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

   400

					tep = &te[i];

   401

				}

   402

			} while (i);

   403

   404

			if (tep == NULL) break;

   405

   406

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

   407

			tep->image = 0;

   408

		}

   409

	}

   410

   411

	EndSpriteCombine();

   412

}

   413

   414

   415

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

   416

{

   417

	uint z;

   418

	Slope tileh = GetTileSlope(tile, &z);

   419

   420

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

   421

}

   422

   423

static Slope GetSlopeTileh_Trees(TileIndex tile, Slope tileh)

   424

{

   425

	return tileh;

   426

}

   427

   428

static int32 ClearTile_Trees(TileIndex tile, byte flags)

   429

{

   430

	uint num;

   431

   432

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

   433

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

   434

		if (t != NULL)

   435

			ChangeTownRating(t, RATING_TREE_DOWN_STEP, RATING_TREE_MINIMUM);

   436

	}

   437

   438

	num = GetTreeCount(tile) + 1;

   439

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

   440

   441

	if (flags & DC_EXEC) DoClearSquare(tile);

   442

   443

	return num * _price.remove_trees;

   444

}

   445

   446

static void GetAcceptedCargo_Trees(TileIndex tile, AcceptedCargo ac)

   447

{

   448

	/* not used */

   449

}

   450

   451

static void GetTileDesc_Trees(TileIndex tile, TileDesc *td)

   452

{

   453

	TreeType tt = GetTreeType(tile);

   454

   455

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

   456

		td->str = STR_280F_RAINFOREST;

   457

	} else if (tt == TREE_CACTUS) {

   458

		td->str = STR_2810_CACTUS_PLANTS;

   459

	} else {

   460

		td->str = STR_280E_TREES;

   461

	}

   462

   463

	td->owner = GetTileOwner(tile);

   464

}

   465

   466

static void AnimateTile_Trees(TileIndex tile)

   467

{

   468

	/* not used */

   469

}

   470

   471

static void TileLoopTreesDesert(TileIndex tile)

   472

{

   473

	switch (GetTropicZone(tile)) {

   474

		case TROPICZONE_DESERT:

   475

			if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) {

   476

				SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

   477

				MarkTileDirtyByTile(tile);

   478

			}

   479

			break;

   480

   481

		case TROPICZONE_RAINFOREST: {

   482

			static const SoundFx forest_sounds[] = {

   483

				SND_42_LOON_BIRD,

   484

				SND_43_LION,

   485

				SND_44_MONKEYS,

   486

				SND_48_DISTANT_BIRD

   487

			};

   488

			uint32 r = Random();