1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "table/strings.h"

     4

#include "table/tree_land.h"

     5

#include "map.h"

     6

#include "tile.h"

     7

#include "viewport.h"

     8

#include "command.h"

     9

#include "town.h"

    10

#include "sound.h"

    11

    12

static int GetRandomTreeType(TileIndex tile, uint seed)

    13

{

    14

	switch (_opt.landscape) {

    15

		case LT_NORMAL:

    16

			return seed * 12 >> 8;

    17

    18

		case LT_HILLY:

    19

			return (seed >> 5) + 12;

    20

    21

		case LT_DESERT:

    22

			switch (GetMapExtraBits(tile)) {

    26

			}

    27

    28

		default:

    29

			return (seed * 9 >> 8) + 32;

    30

	}

    31

}

    32

    33

static void PlaceTree(TileIndex tile, uint32 r, byte m5_or)

    34

{

    36

	byte m5;

    37

    38

	if (tree >= 0) {

    43

    44

		_m[tile].m5 = m5 & 0x07;	// growth state;

    45

		_m[tile].m5 |=  m5 & 0xC0;	// amount of trees

    46

    47

		_m[tile].m3 = tree;		// set type of tree

    48

		_m[tile].m4 = 0;		// no hedge

    49

    50

		// above snowline?

    51

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

    52

			_m[tile].m2 = 0xE0;	// set land type to snow

    56

		}

    57

	}

    58

}

    59

    60

static void DoPlaceMoreTrees(TileIndex tile)

    61

{

    63

    65

		uint32 r = Random();

    70

    71

		/* Only on tiles within 13 squares from tile,

    72

		    on clear tiles, and NOT on farm-tiles or rocks */

    73

		if (dist <= 13 && IsTileType(cur_tile, MP_CLEAR) &&

    74

			 (_m[cur_tile].m5 & 0x1F) != 0x0F && (_m[cur_tile].m5 & 0x1C) != 8) {

    75

			PlaceTree(cur_tile, r, dist <= 6 ? 0xC0 : 0);

    76

		}

    78

}

    79

    80

static void PlaceMoreTrees(void)

    81

{

    83

	do {

    84

		DoPlaceMoreTrees(RandomTile());

    85

	} while (--i);

    86

}

    87

    88

void PlaceTreesRandomly(void)

    89

{

    91

    92

	i = ScaleByMapSize(1000);

    93

	do {

    96

		/* Only on clear tiles, and NOT on farm-tiles or rocks */

    97

		if (IsTileType(tile, MP_CLEAR) && (_m[tile].m5 & 0x1F) != 0x0F && (_m[tile].m5 & 0x1C) != 8) {

    98

			PlaceTree(tile, r, 0);

    99

		}

   100

	} while (--i);

   101

   102

	/* place extra trees at rainforest area */

   103

	if (_opt.landscape == LT_DESERT) {

   104

		i = ScaleByMapSize(15000);

   105

   106

		do {

   109

			if (IsTileType(tile, MP_CLEAR) && GetMapExtraBits(tile) == 2) {

   110

				PlaceTree(tile, r, 0);

   111

			}

   112

		} while (--i);

   113

	}

   114

}

   115

   116

void GenerateTrees(void)

   117

{

   119

   124

	}

   125

}

   126

   127

/** Plant a tree.

   128

 * @param x,y start tile of area-drag of tree plantation

   129

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

   130

 * @param p2 end tile of area-drag

   131

 */

   132

int32 CmdPlantTree(int ex, int ey, uint32 flags, uint32 p1, uint32 p2)

   133

{

   134

	int32 cost;

   135

	int sx;

   136

	int sy;

   137

	int x;

   138

	int y;

   139

   140

	if (p2 > MapSize()) return CMD_ERROR;

   141

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

   142

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

   143

   144

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   145

   146

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

   147

	sx = TileX(p2) * 16;

   148

	sy = TileY(p2) * 16;

   149

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

   150

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

   151

   152

	cost = 0; // total cost

   153

   154

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

   155

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

   157

   159

   161

				case MP_TREES:

   162

					// no more space for trees?

   164

						_error_message = STR_2803_TREE_ALREADY_HERE;

   165

						continue;

   166

					}

   167

   168

					if (flags & DC_EXEC) {

   171

					}

   172

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

   173

					cost += _price.build_trees * 2;

   174

					break;

   175

   176

				case MP_CLEAR:

   178

						_error_message = STR_2804_SITE_UNSUITABLE;

   179

						continue;

   180

					}

   181

   182

					// it's expensive to clear farmland

   184

						cost += _price.clear_3;

   186

						cost += _price.clear_2;

   187

   188

					if (flags & DC_EXEC) {

   189

						int treetype;

   190

						int m2;

   191

   192

						if (_game_mode != GM_EDITOR && _current_player < MAX_PLAYERS) {

   194

							if (t != NULL)

   195

								ChangeTownRating(t, RATING_TREE_UP_STEP, RATING_TREE_MAXIMUM);

   196

						}

   197

   199

							case 0x04:

   200

								m2 = 16;

   201

								break;

   202

   203

							case 0x10:

   205

								break;

   206

   207

							default:

   208

								m2 = 0;

   209

								break;

   210

						}

   211

   212

						treetype = p1;

   213

						if (treetype == -1) {

   215

							if (treetype == -1) treetype = 27;

   216

						}

   217

   219

							MP_SETTYPE(MP_TREES) |

   220

							MP_MAP2 | MP_MAP3LO | MP_MAP3HI_CLEAR | MP_MAP5,

   221

							m2, /* map2 */

   222

							treetype, /* map3lo */

   223

							_game_mode == GM_EDITOR ? 3 : 0 /* map5 */

   224

						);

   225

   226

						if (_game_mode == GM_EDITOR && IS_BYTE_INSIDE(treetype, 0x14, 0x1B))

   228

					}

   229

					cost += _price.build_trees;

   230

					break;

   231

   232

				default:

   233

					_error_message = STR_2804_SITE_UNSUITABLE;

   234

					break;

   235

			}

   236

		}

   237

	}

   238

   239

	return (cost == 0) ? CMD_ERROR : cost;

   240

}

   241

   242

typedef struct TreeListEnt {

   243

	uint32 image;

   244

	byte x,y;

   245

} TreeListEnt;

   246

   247

static void DrawTile_Trees(TileInfo *ti)

   248

{

   249

	uint16 m2;

   250

	const uint32 *s;

   251

	const byte *d;

   252

	byte z;

   253

   254

	m2 = _m[ti->tile].m2;

   255

   257

		DrawClearLandTile(ti, 3);

   259

		DrawGroundSprite(_tree_sprites_1[m2 >> 6] + _tileh_to_sprite[ti->tileh]);

   260

	} else {

   261

		DrawHillyLandTile(ti);

   262

	}

   263

   264

	DrawClearLandFence(ti, _m[ti->tile].m4 >> 2);

   265

   266

	z = ti->z;

   267

	if (ti->tileh != 0) {

   268

		z += 4;

   269

		if (IsSteepTileh(ti->tileh))

   270

			z += 4;

   271

	}

   272

   273

	{

   274

		uint16 tmp = ti->x;

   275

		uint index;

   276

   278

		tmp -= ti->y;

   280

		tmp -= ti->x;

   282

		tmp += ti->y;

   283

   285

   287

   288

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

   289

		if ((m2 & 0xB0) == 0xA0 && index >= 48 && index < 80)

   290

			index += 164 - 48;

   291

   292

		assert(index < lengthof(_tree_layout_sprite));

   293

		s = _tree_layout_sprite[index];

   294

	}

   295

   296

	StartSpriteCombine();

   297

   301

   302

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

   303

		i = (ti->map5 >> 6) + 1;

   304

		do {

   306

			if (_display_opt & DO_TRANS_BUILDINGS)

   307

				image = (image & 0x3FFF) | 0x3224000;

   308

			te[i].image = image;

   309

			te[i].x = d[0];

   310

			te[i].y = d[1];

   311

			s++;

   313

		} while (i);

   314

   315

		/* draw them in a sorted way */

   316

		for(;;) {

   317

			byte min = 0xFF;

   318

			TreeListEnt *tep = NULL;

   319

   320

			i = (ti->map5 >> 6) + 1;

   321

			do {

   323

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

   324

					tep = &te[i];

   325

				}

   326

			} while (i);

   327

   329

   330

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

   331

			tep->image = 0;

   332

		}

   333

	}

   334

   335

	EndSpriteCombine();

   336

}

   337

   338

   339

static uint GetSlopeZ_Trees(TileInfo *ti) {

   340

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

   341

}

   342

   343

static uint GetSlopeTileh_Trees(TileInfo *ti) {

   344

	return ti->tileh;

   345

}

   346

   347

static int32 ClearTile_Trees(TileIndex tile, byte flags)

   348

{

   349

	int num;

   350

   351

	if (flags & DC_EXEC && _current_player < MAX_PLAYERS) {

   352

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

   353

		if (t != NULL)

   354

			ChangeTownRating(t, RATING_TREE_DOWN_STEP, RATING_TREE_MINIMUM);

   355

	}

   356

   357

	num = (_m[tile].m5 >> 6) + 1;

   358

	if ( (byte)(_m[tile].m3-0x14) <= (0x1A-0x14))

   359

		num <<= 2;

   360

   361

	if (flags & DC_EXEC)

   362

		DoClearSquare(tile);

   363

   364

	return num * _price.remove_trees;

   365

}

   366

   367

static void GetAcceptedCargo_Trees(TileIndex tile, AcceptedCargo ac)

   368

{

   369

	/* not used */

   370

}

   371

   372

static void GetTileDesc_Trees(TileIndex tile, TileDesc *td)

   373

{

   374

	byte b;

   375

	StringID str;

   376

   377

	td->owner = GetTileOwner(tile);

   378

   379

	b = _m[tile].m3;

   380

	(str=STR_2810_CACTUS_PLANTS, b==0x1B) ||

   381

	(str=STR_280F_RAINFOREST, IS_BYTE_INSIDE(b, 0x14, 0x1A+1)) ||

   382

	(str=STR_280E_TREES, true);

   383

	td->str = str;

   384

}

   385

   386

static void AnimateTile_Trees(TileIndex tile)

   387

{

   388

	/* not used */

   389

}

   390

   391

static SoundFx _desert_sounds[] = {

   392

	SND_42_LOON_BIRD,

   393

	SND_43_LION,

   394

	SND_44_MONKEYS,

   395

	SND_48_DISTANT_BIRD

   396

};

   397

   398

static void TileLoopTreesDesert(TileIndex tile)

   399

{

   400

	byte b;

   401

   405

   407

	} else if (b == 1) {

   408

		if ((_m[tile].m2 & 0x30) != 0x20) {

   409

			_m[tile].m2 &= 0xF;

   410

			_m[tile].m2 |= 0xE0;

   411

			MarkTileDirtyByTile(tile);

   412

		}

   413

	}

   414

}

   415

   416

static void TileLoopTreesAlps(TileIndex tile)

   417

{

   418

	byte tmp, m2;

   419

	int k;

   420

   421

	/* distance from snow line, in steps of 8 */

   422

	k = GetTileZ(tile) - _opt.snow_line;

   423

   424

	tmp = _m[tile].m5 & 0xF0;

   425

   426

	if (k < -8) {

   427

		/* snow_m2_down */

   429

		m2 = 0;

   430

	} else if (k == -8) {

   431

		/* snow_m1 */

   432

		m2 = 0x20;

   434

	} else if (k < 8) {

   435

		/* snow_0 */

   436

		m2 = 0x60;

   438

	} else if (k == 8) {

   439

		/* snow_p1 */

   440

		m2 = 0xA0;

   442

	} else {

   443

		/* snow_p2_up */

   444

		if (tmp == 0xC0) {

   447

				SndPlayTileFx((r & 0x80000000) ? SND_39_HEAVY_WIND : SND_34_WIND, tile);

   448

			}

   449

			return;

   450

		} else {

   451

			m2 = 0xE0;

   452

		}

   453

	}

   454

   455

	_m[tile].m2 &= 0xF;

   456

	_m[tile].m2 |= m2;

   457

	MarkTileDirtyByTile(tile);

   458

}

   459

   460

static void TileLoop_Trees(TileIndex tile)

   461

{

   462

	byte m5;

   463

	uint16 m2;

   464

   465

	static const TileIndexDiffC _tileloop_trees_dir[] = {

   466

		{-1, -1},

   467

		{ 0, -1},

   468

		{ 1, -1},

   469

		{-1,  0},

   470

		{ 1,  0},

   471

		{-1,  1},

   472

		{ 0,  1},

   473

		{ 1,  1}

   474

	};

   475

   476

	if (_opt.landscape == LT_DESERT) {

   477

		TileLoopTreesDesert(tile);

   478

	} else if (_opt.landscape == LT_HILLY) {

   479

		TileLoopTreesAlps(tile);

   480

	}

   481

   482

	TileLoopClearHelper(tile);

   483

   484

	/* increase counter */

   485

	{

   486

		uint16 m2 = _m[tile].m2;

   489

	}

   490

   491

	m5 = _m[tile].m5;

   493

		/* regular sized tree */

   495

			m5++; /* start destructing */

   496

		} else {

   497

			switch(Random() & 0x7) {

   498

			case 0: /* start destructing */