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 "tile.h"

    13

#include "tree_map.h"

    14

#include "viewport.h"

    15

#include "command.h"

    16

#include "town.h"

    17

#include "sound.h"

    18

#include "variables.h"

    19

#include "genworld.h"

    20

    21

enum TreePlacer {

    22

	TP_NONE,

    23

	TP_ORIGINAL,

    24

	TP_IMPROVED,

    25

};

    26

    27

static TreeType GetRandomTreeType(TileIndex tile, uint seed)

    28

{

    29

	switch (_opt.landscape) {

    30

		case LT_NORMAL:

    31

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

    32

    33

		case LT_HILLY:

    34

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

    35

    36

		case LT_DESERT:

    37

			switch (GetTropicZone(tile)) {

    38

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

    39

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

    40

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

    41

			}

    42

    43

		default:

    44

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

    45

	}

    46

}

    47

    48

static void PlaceTree(TileIndex tile, uint32 r)

    49

{

    50

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

    51

    52

	if (tree != TREE_INVALID) {

    53

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

    54

    55

		// above snowline?

    56

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

    57

			SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

    58

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

    59

		} else {

    60

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

    61

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

    62

		}

    63

	}

    64

}

    65

    66

static void DoPlaceMoreTrees(TileIndex tile)

    67

{

    68

	uint i;

    69

    70

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

    71

		uint32 r = Random();

    72

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

    73

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

    74

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

    75

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

    76

    77

		if (dist <= 13 &&

    78

				IsTileType(cur_tile, MP_CLEAR) &&

    79

				!IsBridgeAbove(cur_tile) &&

    80

				!IsClearGround(cur_tile, CLEAR_FIELDS) &&

    81

				!IsClearGround(cur_tile, CLEAR_ROCKS)) {

    82

			PlaceTree(cur_tile, r);

    83

		}

    84

	}

    85

}

    86

    87

static void PlaceMoreTrees(void)

    88

{

    89

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

    90

	do {

    91

		DoPlaceMoreTrees(RandomTile());

    92

	} while (--i);

    93

}

    94

    95

/**

    96

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

    97

 *  This gives cool effects to the map.

    98

 */

    99

void PlaceTreeAtSameHeight(TileIndex tile, uint height)

   100

{

   101

	uint i;

   102

   103

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

   104

		uint32 r = Random();

   105

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

   106

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

   107

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

   108

   109

		/* Keep in range of the existing tree */

   110

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

   111

   112

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

   113

		if (!IsTileType(cur_tile, MP_CLEAR) ||

   114

				IsClearGround(cur_tile, CLEAR_FIELDS) ||

   115

				IsClearGround(cur_tile, CLEAR_ROCKS))

   116

			continue;

   117

   118

		/* Not too much height difference */

   119

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

   120

   121

		/* Place one tree and quit */

   122

		PlaceTree(cur_tile, r);

   123

		break;

   124

	}

   125

}

   126

   127

void PlaceTreesRandomly(void)

   128

{

   129

	uint i, j, ht;

   130

   131

	i = ScaleByMapSize(1000);

   132

	do {

   133

		uint32 r = Random();

   134

		TileIndex tile = RandomTileSeed(r);

   135

   136

		IncreaseGeneratingWorldProgress(GWP_TREE);

   137

   138

		if (IsTileType(tile, MP_CLEAR) &&

   139

				!IsBridgeAbove(tile) &&

   140

				!IsClearGround(tile, CLEAR_FIELDS) &&

   141

				!IsClearGround(tile, CLEAR_ROCKS)) {

   142

			PlaceTree(tile, r);

   143

			if (_patches.tree_placer != TP_IMPROVED) continue;

   144

   145

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

   146

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

   147

			 *  It is almost real life ;) */

   148

			ht = GetTileZ(tile);

   149

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

   150

			j = GetTileZ(tile) / TILE_HEIGHT * 2;

   151

			while (j--) {

   152

				/* Above snowline more trees! */

   153

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

   154

					PlaceTreeAtSameHeight(tile, ht);

   155

					PlaceTreeAtSameHeight(tile, ht);

   156

				};

   157

   158

				PlaceTreeAtSameHeight(tile, ht);

   159

			}

   160

		}

   161

	} while (--i);

   162

   163

	/* place extra trees at rainforest area */

   164

	if (_opt.landscape == LT_DESERT) {

   165

		i = ScaleByMapSize(15000);

   166

   167

		do {

   168

			uint32 r = Random();

   169

			TileIndex tile = RandomTileSeed(r);

   170

   171

			IncreaseGeneratingWorldProgress(GWP_TREE);

   172

   173

			if (IsTileType(tile, MP_CLEAR) &&

   174

					!IsBridgeAbove(tile) &&

   175

					!IsClearGround(tile, CLEAR_FIELDS) &&

   176

					GetTropicZone(tile) == TROPICZONE_RAINFOREST) {

   177

				PlaceTree(tile, r);

   178

			}

   179

		} while (--i);

   180

	}

   181

}

   182

   183

void GenerateTrees(void)

   184

{

   185

	uint i, total;

   186

   187

	if (_patches.tree_placer == TP_NONE) return;

   188

   189

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

   190

   191

	switch (_patches.tree_placer) {

   192

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

   193

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

   194

		default: NOT_REACHED(); return;

   195

	}

   196

   197

	total = ScaleByMapSize(1000);

   198

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

   199

	total *= i;

   200

	SetGeneratingWorldProgress(GWP_TREE, total);

   201

   202

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

   203

		PlaceTreesRandomly();

   204

	}

   205

}

   206

   207

/** Plant a tree.

   208

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

   209

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

   210

 * @param p2 end tile of area-drag

   211

 */

   212

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

   213

{

   214

	StringID msg = INVALID_STRING_ID;

   215

	int32 cost;

   216

	int ex;

   217

	int ey;

   218

	int sx, sy, x, y;

   219

   220

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

   221

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

   222

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

   223

   224

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   225

   226

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

   227

	ex = TileX(tile);

   228

	ey = TileY(tile);

   229

	sx = TileX(p2);

   230

	sy = TileY(p2);

   231

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

   232

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

   233

   234

	cost = 0; // total cost

   235

   236

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

   237

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

   238

			TileIndex tile = TileXY(x, y);

   239

   240

			if (!EnsureNoVehicle(tile)) continue;

   241

   242

			switch (GetTileType(tile)) {

   243

				case MP_TREES:

   244

					// no more space for trees?

   245

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

   246

						msg = STR_2803_TREE_ALREADY_HERE;

   247

						continue;

   248

					}

   249

   250

					if (flags & DC_EXEC) {

   251

						AddTreeCount(tile, 1);

   252

						MarkTileDirtyByTile(tile);

   253

					}

   254

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

   255

					cost += _price.build_trees * 2;

   256

					break;

   257

   258

				case MP_CLEAR:

   259

					if (!IsTileOwner(tile, OWNER_NONE) ||

   260

							IsBridgeAbove(tile)) {

   261

						msg = STR_2804_SITE_UNSUITABLE;

   262

						continue;

   263

					}

   264

   265

					switch (GetClearGround(tile)) {

   266

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

   267

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

   268

						default: break;

   269

					}

   270

   271

					if (flags & DC_EXEC) {

   272

						TreeType treetype;

   273

						uint growth;

   274

   275

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

   276

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

   277

							if (t != NULL)

   278

								ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   279

						}

   280

   281

						treetype = (TreeType)p1;

   282

						if (treetype == TREE_INVALID) {

   283

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

   284

							if (treetype == TREE_INVALID) treetype = TREE_CACTUS;

   285

						}

   286

   287

						growth = _game_mode == GM_EDITOR ? 3 : 0;

   288

						switch (GetClearGround(tile)) {

   289

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

   290

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

   291

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

   292

						}

   293

						MarkTileDirtyByTile(tile);

   294

   295

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

   296

							SetTropicZone(tile, TROPICZONE_RAINFOREST);

   297

					}

   298

					cost += _price.build_trees;

   299

					break;

   300

   301

				default:

   302

					msg = STR_2804_SITE_UNSUITABLE;

   303

					break;

   304

			}

   305

		}

   306

	}

   307

   308

	if (cost == 0) {

   309

		return_cmd_error(msg);

   310

	} else {

   311

		return cost;

   312

	}

   313

}

   314

   315

typedef struct TreeListEnt {

   318

	byte x,y;

   319

} TreeListEnt;

   320

   321

static void DrawTile_Trees(TileInfo *ti)

   322

{

   324

	const TreePos* d;

   325

	byte z;

   326

   327

	switch (GetTreeGround(ti->tile)) {

   328

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

   329

		case TREE_GROUND_ROUGH: DrawHillyLandTile(ti); break;

   331

	}

   332

   333

	DrawClearLandFence(ti);

   334

   335

	z = ti->z;

   336

	if (ti->tileh != SLOPE_FLAT) {

   337

		z += 4;

   338

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

   339

	}

   340

   341

	{

   342

		uint16 tmp = ti->x;

   343

		uint index;

   344

   345

		tmp = ROR(tmp, 2);

   346

		tmp -= ti->y;

   347

		tmp = ROR(tmp, 3);

   348

		tmp -= ti->x;

   349

		tmp = ROR(tmp, 1);

   350

		tmp += ti->y;

   351

   352

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

   353

   354

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

   355

   356

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

   357

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

   358

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

   359

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

   360

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

   361

		}

   362

   363

		assert(index < lengthof(_tree_layout_sprite));

   364

		s = _tree_layout_sprite[index];

   365

	}

   366

   367

	StartSpriteCombine();

   368

   369

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

   370

		TreeListEnt te[4];

   371

		uint i;

   372

   373

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

   374

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

   375

		do {

   384

			te[i].image = image;

   386

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

   387

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

   388

			s++;

   389

			d++;

   390

		} while (i);

   391

   392

		/* draw them in a sorted way */

   393

		for (;;) {

   394

			byte min = 0xFF;

   395

			TreeListEnt *tep = NULL;

   396

   397

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

   398

			do {

   399

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

   400

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

   401

					tep = &te[i];

   402

				}

   403

			} while (i);

   404

   405

			if (tep == NULL) break;

   406

   408

			tep->image = 0;

   409

		}

   410

	}

   411

   412

	EndSpriteCombine();

   413

}

   414

   415

   416

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

   417

{

   418

	uint z;

   419

	Slope tileh = GetTileSlope(tile, &z);

   420

   421

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

   422

}

   423

   424

static Slope GetSlopeTileh_Trees(TileIndex tile, Slope tileh)

   425

{

   426

	return tileh;

   427

}

   428

   429

static int32 ClearTile_Trees(TileIndex tile, byte flags)

   430

{

   431

	uint num;

   432

   433

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

   434

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

   435

		if (t != NULL)

   436

			ChangeTownRating(t, RATING_TREE_DOWN_STEP, RATING_TREE_MINIMUM);

   437

	}

   438

   439

	num = GetTreeCount(tile) + 1;

   440

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

   441

   442

	if (flags & DC_EXEC) DoClearSquare(tile);

   443

   444

	return num * _price.remove_trees;

   445

}

   446

   447

static void GetAcceptedCargo_Trees(TileIndex tile, AcceptedCargo ac)

   448

{

   449

	/* not used */

   450

}

   451

   452

static void GetTileDesc_Trees(TileIndex tile, TileDesc *td)

   453

{

   454

	TreeType tt = GetTreeType(tile);

   455

   456

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

   457

		td->str = STR_280F_RAINFOREST;

   458

	} else if (tt == TREE_CACTUS) {

   459

		td->str = STR_2810_CACTUS_PLANTS;

   460

	} else {

   461

		td->str = STR_280E_TREES;

   462

	}

   463

   464

	td->owner = GetTileOwner(tile);

   465

}

   466

   467

static void AnimateTile_Trees(TileIndex tile)

   468

{

   469

	/* not used */

   470

}

   471

   472

static void TileLoopTreesDesert(TileIndex tile)

   473

{

   474

	switch (GetTropicZone(tile)) {

   475

		case TROPICZONE_DESERT:

   476

			if (GetTreeGround(tile) != TREE_GROUND_SNOW_DESERT) {

   477

				SetTreeGroundDensity(tile, TREE_GROUND_SNOW_DESERT, 3);

   478

				MarkTileDirtyByTile(tile);

   479

			}

   480

			break;

   481

   482

		case TROPICZONE_RAINFOREST: {

   483

			static const SoundFx forest_sounds[] = {

   484

				SND_42_LOON_BIRD,

   485

				SND_43_LION,

   486

				SND_44_MONKEYS,

   487

				SND_48_DISTANT_BIRD

   488

			};

   489

			uint32 r = Random();