1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "viewport.h"

     5

#include "command.h"

     6

#include "town.h"

     7

#include "sound.h"

     8

     9

static int GetRandomTreeType(uint tile, uint seed)

    10

{

    11

	byte i;

    12

    13

	if (_opt.landscape == LT_NORMAL) {

    14

		return seed * 12 >> 8;

    15

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

    16

		return (seed >> 5) + 12;

    17

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

    18

		i = GetMapExtraBits(tile);

    19

		if (i == 0) {

    20

			return (seed >> 6) + 28;

    21

		} else if (i == 1) {

    22

			if (seed > 12)

    23

				return -1;

    24

			return 27;

    25

		} else {

    26

			return (seed * 7 >> 8) + 20;

    27

		}

    28

	} else {

    29

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

    30

	}

    31

}

    32

    33

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

    34

{

    35

	int tree = GetRandomTreeType(tile, (r >> 24));

    36

	byte m5;

    37

    38

	if (tree >= 0) {

    39

		m5 = (byte)(r >> 16);

    40

		if ((m5 & 0x7) == 7) m5--; // there is no growth state 7

    41

    42

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

    43

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

    44

    45

		_map3_lo[tile] = tree;		// set type of tree

    46

		_map3_hi[tile] = 0;		// no hedge

    47

    48

		// above snowline?

    49

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

    50

		{

    51

			_map2[tile] = 0xE0;	// set land type to snow

    52

			_map2[tile] |= (byte)(r >> 24)&0x07; // randomize counter

    53

		}

    54

		else

    55

		{

    56

			_map2[tile] = (byte)(r >> 24)&0x1F; // randomize counter and ground

    57

		}

    58

    59

    60

		// make it tree class

    61

		_map_type_and_height[tile] |= MP_TREES << 4;

    62

	}

    63

}

    64

    65

static void DoPlaceMoreTrees(uint tile)

    66

{

    67

	int i = 1000;

    68

	int x,y;

    69

	uint cur_tile;

    70

	int dist;

    71

    72

	do {

    73

		uint32 r = Random();

    74

		x = (r & 0x1F) - 16;

    75

		y = ((r>>8) & 0x1F) - 16;

    76

    77

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

    78

    79

		cur_tile=TILE_MASK(tile + TILE_XY(x,y));

    80

    81

		if (dist <= 13 && IS_TILETYPE(cur_tile, MP_CLEAR)) {

    82

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

    83

		}

    84

	} while (--i);

    85

}

    86

    87

static void PlaceMoreTrees()

    88

{

    89

	int i = (Random() & 0x1F) + 25;

    90

	do {

    91

		DoPlaceMoreTrees(TILE_MASK(Random()));

    92

	} while (--i);

    93

}

    94

    95

void PlaceTreesRandomly()

    96

{

    97

	int i;

    98

	uint32 r;

    99

	uint tile;

   100

   101

	i = 1000;

   102

	do {

   103

		r = Random();

   104

		tile = TILE_MASK(r);

   105

		if (IS_TILETYPE(tile, MP_CLEAR)) {

   106

			PlaceTree(tile, r, 0);

   107

		}

   108

	} while (--i);

   109

   110

	/* place extra trees at rainforest area */

   111

	if (_opt.landscape == LT_DESERT) {

   112

		i = 15000;

   113

   114

		do {

   115

			r = Random();

   116

			tile = TILE_MASK(r);

   117

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

   118

				PlaceTree(tile, r, 0);

   119

			}

   120

		} while (--i);

   121

	}

   122

}

   123

   124

void GenerateTrees()

   125

{

   126

	int i;

   127

   128

	if (_opt.landscape != LT_CANDY) {

   129

		PlaceMoreTrees();

   130

	}

   131

   132

	i = _opt.landscape == LT_HILLY ? 15 : 6;

   133

	do {

   134

		PlaceTreesRandomly();

   135

	} while (--i);

   136

}

   137

   138

/* Plant a tree

   139

 * p1 = tree type, -1 means random.

   140

 * p2 = end tile

   141

 */

   142

   143

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

   144

{

   145

	TileInfo ti;

   146

	int32 cost;

   147

	int sx,sy,x,y;

   148

	int treetype;

   149

   150

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   151

   152

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

   153

	sx = GET_TILE_X(p2)*16;

   154

	sy = GET_TILE_Y(p2)*16;

   155

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

   156

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

   157

   158

	cost = 0; // total cost

   159

   160

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

   161

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

   162

			FindLandscapeHeight(&ti, x, y);

   163

			if (!EnsureNoVehicle(ti.tile))

   164

				continue;

   165

   166

			if (ti.type == MP_TREES) {

   167

				// no more space for trees?

   168

				if (_game_mode != GM_EDITOR && (ti.map5 & 0xC0) == 0xC0) {

   169

					_error_message = STR_2803_TREE_ALREADY_HERE;

   170

					continue;

   171

				}

   172

   173

				if (flags & DC_EXEC) {

   174

					_map5[ti.tile] = ti.map5 + 0x40;

   175

					MarkTileDirtyByTile(ti.tile);

   176

				}

   177

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

   178

				cost += _price.build_trees * 2;

   179

			} else {

   180

				// don't allow building on rocks

   181

				if (ti.type != MP_CLEAR || _map_owner[ti.tile] != OWNER_NONE || (ti.map5 & 0x1C) == 8) {

   182

					_error_message = STR_2804_SITE_UNSUITABLE;

   183

					continue;

   184

				}

   185

   186

				// it's expensive to clear farmland

   187

				if ((ti.map5 & 0x1F) == 0xF) cost += _price.clear_3;

   188

   189

				if (flags & DC_EXEC) {

   190

					int m2;

   191

   192

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

   193

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

   194

						if (t != NULL)

   195

							ChangeTownRating(t, 7, 220);

   196

					}

   197

					m2 = 0;

   198

					if ( (ti.map5 & 0x1C) == 4 ) {

   199

						m2 = 16;

   200

					} else if ( (ti.map5 & 0x1C) == 16 ) {

   201

						m2 = (ti.map5 << 6) | 0x20;

   202

					}

   203

   204

					treetype = p1;

   205

					if (treetype == -1) {

   206

						treetype = GetRandomTreeType(ti.tile, Random()>>24);

   207

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

   208

					}

   209

   210

					ModifyTile(ti.tile,

   211

						MP_SETTYPE(MP_TREES) |

   212

						MP_MAP2 | MP_MAP3LO | MP_MAP3HI_CLEAR | MP_MAP5,

   213

						m2, /* map2 */

   214

						treetype, /* map3lo */

   215

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

   216

					);

   217

   218

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

   219

						SetMapExtraBits(ti.tile, 2);

   220

					}

   221

				}

   222

				cost += _price.build_trees;

   223

			}

   224

		}

   225

	}

   226

   227

	if (cost == 0) return CMD_ERROR;

   228

	return cost;

   229

}

   230

   231

typedef struct TreeListEnt {

   232

	uint32 image;

   233

	byte x,y;

   234

} TreeListEnt;

   235

   236

   237

#include "table/tree_land.h"

   238

   239

   240

static void DrawTile_Trees(TileInfo *ti)

   241

{

   242

	byte m2;

   243

	const uint32 *s;

   244

	const byte *d;

   245

	byte z;

   246

	TreeListEnt te[4];

   247

   248

	m2 = _map2[ti->tile];

   249

   250

	if ( (m2&0x30) == 0) {

   251

		DrawClearLandTile(ti, 3);

   252

	} else if ((m2&0x30) == 0x20) {

   253

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

   254

	} else {

   255

		DrawHillyLandTile(ti);

   256

	}

   257

   258

	DrawClearLandFence(ti, _map3_hi[ti->tile] >> 2);

   259

   260

	z = ti->z;

   261

	if (ti->tileh != 0) {

   262

		z += 4;

   263

		if (ti->tileh & 0x10)

   264

			z += 4;

   265

	}

   266

   267

	{

   268

		uint16 tmp = ti->x;

   269

		int index;

   270

   271

		tmp = (tmp >> 2) | (tmp << 14);

   272

		tmp -= ti->y;

   273

		tmp = (tmp >> 3) | (tmp << 13);

   274

		tmp -= ti->x;

   275

		tmp = (tmp >> 1) | (tmp << 15);

   276

		tmp += ti->y;

   277

   278

		d = _tree_layout_xy[(tmp & 0x30) >> 4];

   279

   280

		index = ((tmp>>6)&3) + (_map3_lo[ti->tile]<<2);

   281

   282

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

   283

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

   284

			index += 164 - 48;

   285

   286

		assert(index < lengthof(_tree_layout_sprite));

   287

		s = _tree_layout_sprite[index];

   288

	}

   289

   290

	StartSpriteCombine();

   291

   292

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

   293

	{

   294

		int i;

   295

   296

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

   297

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

   298

		do {

   299

			uint32 image = s[0] + (--i==0 ? (ti->map5 & 7) : 3);

   300

			if (_display_opt & DO_TRANS_BUILDINGS)

   301

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

   302

			te[i].image = image;

   303

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

   304

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

   305

			s++;

   306

			d+=2;

   307

		} while (i);

   308

   309

		/* draw them in a sorted way */

   310

		for(;;) {

   311

			byte min = 0xFF;

   312

			TreeListEnt *tep = NULL;

   313

   314

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

   315

			do {

   316

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

   317

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

   318

					tep = &te[i];

   319

				}

   320

			} while (i);

   321

   322

			if (tep == NULL)

   323

				break;

   324

   325

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

   326

			tep->image = 0;

   327

		}

   328

	}

   329

   330

	EndSpriteCombine();

   331

}

   332

   333

   334

static uint GetSlopeZ_Trees(TileInfo *ti) {

   335

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

   336

}

   337

   338

static uint GetSlopeTileh_Trees(TileInfo *ti) {

   339

	return ti->tileh;

   340

}

   341

   342

static int32 ClearTile_Trees(uint tile, byte flags) {

   343

	int num;

   344

   345

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

   346

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

   347

		if (t != NULL)

   348

			ChangeTownRating(t, -35, -1000);

   349

	}

   350

   351

	num = (_map5[tile] >> 6) + 1;

   352

	if ( (byte)(_map3_lo[tile]-0x14) <= (0x1A-0x14))

   353

		num <<= 2;

   354

   355

	if (flags & DC_EXEC)

   356

		DoClearSquare(tile);

   357

   358

	return num * _price.remove_trees;

   359

}

   360

   361

static void GetAcceptedCargo_Trees(uint tile, AcceptedCargo ac)

   362

{

   363

	/* not used */

   364

}

   365

   366

static void GetTileDesc_Trees(uint tile, TileDesc *td)

   367

{

   368

	byte b;

   369

	StringID str;

   370

   371

	td->owner = _map_owner[tile];

   372

   373

	b = _map3_lo[tile];

   374

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

   375

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

   376

	(str=STR_280E_TREES, true);

   377

	td->str = str;

   378

}

   379

   380

static void AnimateTile_Trees(uint tile)

   381

{

   382

	/* not used */

   383

}

   384

   385

static byte _desert_sounds[] = {

   386

	66,67,68,72

   387

};

   388

   389

static void TileLoopTreesDesert(uint tile)

   390

{

   391

	byte b;

   392

   393

	if ((b=GetMapExtraBits(tile)) == 2) {

   394

		uint32 r;

   395

   396

		if (CHANCE16I(1,200,r=Random())) {

   397

			SndPlayTileFx(_desert_sounds[(r >> 16) & 3], tile);

   398

		}

   399

	} else if (b == 1) {

   400

		if ((_map2[tile] & 0x30) != 0x20) {

   401

			_map2[tile] &= 0xF;

   402

			_map2[tile] |= 0xE0;

   403

			MarkTileDirtyByTile(tile);

   404

		}

   405

	}

   406

}

   407

   408

static void TileLoopTreesAlps(uint tile)

   409

{

   410

	byte tmp, m2;

   411

	int k;

   412

   413

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

   414

	k = GetTileZ(tile) - _opt.snow_line;

   415

   416

	tmp = _map5[tile] & 0xF0;

   417

   418

	if (k < -8) {

   419

		/* snow_m2_down */

   420

		if ((tmp&0x30) != 0x20)

   421

			return;

   422

		m2 = 0;

   423

	} else if (k == -8) {

   424

		/* snow_m1 */

   425

		m2 = 0x20;

   426

		if (tmp == m2)

   427

			return;

   428

	} else if (k < 8) {

   429

		/* snow_0 */

   430

		m2 = 0x60;

   431

		if (tmp == m2)

   432

			return;

   433

	} else if (k == 8) {

   434

		/* snow_p1 */

   435

		m2 = 0xA0;

   436

		if (tmp == m2)

   437

			return;

   438

	} else {

   439

		/* snow_p2_up */

   440

		if (tmp == 0xC0) {

   441

			uint32 r;

   442

			if (CHANCE16I(1,200,r=Random())) {

   443

				SndPlayTileFx( (r&0x80000000) ? 57 : 52, tile);

   444

			}

   445

			return;

   446

		} else {

   447

			m2 = 0xE0;

   448

		}

   449

	}

   450

   451

	_map2[tile] &= 0xF;

   452

	_map2[tile] |= m2;

   453

	MarkTileDirtyByTile(tile);

   454

}

   455

   456

static void TileLoop_Trees(uint tile)

   457

{

   458

	byte m5, m2;

   459

   460

	static const TileIndexDiff _tileloop_trees_dir[] = {

   461

		TILE_XY(-1,-1),

   462

		TILE_XY(0,-1),

   463

		TILE_XY(1,-1),

   464

		TILE_XY(-1,0),

   465

		TILE_XY(1,0),

   466

		TILE_XY(-1,1),

   467

		TILE_XY(0,1),

   468

		TILE_XY(1,1),

   469

	};

   470

   471

	if (_opt.landscape == LT_DESERT) {

   472

		TileLoopTreesDesert(tile);

   473

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

   474

		TileLoopTreesAlps(tile);

   475

	}

   476

   477

	TileLoopClearHelper(tile);

   478

   479

	/* increase counter */

   480

	{

   481

		byte m2 = _map2[tile];

   482

		_map2[tile] = m2 = (m2 & 0xF0) | ((m2+1)&0xF);

   483

		if (m2 & 0xF)

   484

			return;

   485

	}

   486

   487

	m5 = _map5[tile];

   488

	if ((m5&7) == 3) {

   489

		/* regular sized tree */

   490

		if (_opt.landscape == LT_DESERT && _map3_lo[tile]!=0x1B && GetMapExtraBits(tile)==1) {

   491

			m5++; /* start destructing */

   492

		} else {

   493

			switch(Random() & 0x7) {

   494

			case 0: /* start destructing */

   495

				m5++;

   496

				break;

   497

   498

			case 1: /* add a tree */

   499

				if (m5 < 0xC0) {

   500

					m5 = (m5 + 0x40) & ~7;

   501

					break;

   502

				}

   503

				/* fall through */

   504

   505

			case 2: { /* add a neighbouring tree */

   506

				byte m3 = _map3_lo[tile];

   507

   508

				tile += _tileloop_trees_dir[Random() & 7];

   509

   510

				if (!IS_TILETYPE(tile, MP_CLEAR))

   511

					return;

   512

   513

				if ( (_map5[tile] & 0x1C) == 4) {

   514

					_map2[tile] = 0x10;

   515

				} else if ((_map5[tile] & 0x1C) == 16) {

   516

					_map2[tile] = (_map5[tile] << 6) | 0x20;

   517

				} else {

   518

					if ((_map5[tile] & 0x1F) != 3)

   519

						return;

   520

					_map2[tile] = 0;

   521

				}

   522

   523

				_map3_lo[tile] = m3;

   524

				_map3_hi[tile] = 0;

   525

				_map_type_and_height[tile] &= 0xF;