1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "viewport.h"

     6

#include "command.h"

     7

#include "town.h"

     8

#include "sound.h"

     9

    10

static int GetRandomTreeType(uint tile, uint seed)

    11

{

    12

	byte i;

    13

    14

	if (_opt.landscape == LT_NORMAL) {

    15

		return seed * 12 >> 8;

    16

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

    17

		return (seed >> 5) + 12;

    18

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

    19

		i = GetMapExtraBits(tile);

    20

		if (i == 0) {

    21

			return (seed >> 6) + 28;

    22

		} else if (i == 1) {

    23

			if (seed > 12)

    24

				return -1;

    25

			return 27;

    26

		} else {

    27

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

    28

		}

    29

	} else {

    30

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

    31

	}

    32

}

    33

    34

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

    35

{

    36

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

    37

	byte m5;

    38

    39

	if (tree >= 0) {

    40

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

    41

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

    42

    43

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

    44

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

    45

    46

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

    47

		_map3_hi[tile] = 0;		// no hedge

    48

    49

		// above snowline?

    50

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

    51

		{

    52

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

    53

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

    54

		}

    55

		else

    56

		{

    57

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

    58

		}

    59

    60

    61

		// make it tree class

    62

		_map_type_and_height[tile] |= MP_TREES << 4;

    63

	}

    64

}

    65

    66

static void DoPlaceMoreTrees(uint tile)

    67

{

    68

	int i = 1000;

    69

	int x,y;

    70

	uint cur_tile;

    71

	int dist;

    72

    73

	do {

    74

		uint32 r = Random();

    75

		x = (r & 0x1F) - 16;

    76

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

    77

    78

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

    79

    80

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

    81

    82

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

    83

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

    84

		}

    85

	} while (--i);

    86

}

    87

    88

static void PlaceMoreTrees()

    89

{

    90

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

    91

	do {

    92

		DoPlaceMoreTrees(TILE_MASK(Random()));

    93

	} while (--i);

    94

}

    95

    96

void PlaceTreesRandomly()

    97

{

    98

	int i;

    99

	uint32 r;

   100

	uint tile;

   101

   102

	i = 1000;

   103

	do {

   104

		r = Random();

   105

		tile = TILE_MASK(r);

   106

		if (IS_TILETYPE(tile, MP_CLEAR)) {

   107

			PlaceTree(tile, r, 0);

   108

		}

   109

	} while (--i);

   110

   111

	/* place extra trees at rainforest area */

   112

	if (_opt.landscape == LT_DESERT) {

   113

		i = 15000;

   114

   115

		do {

   116

			r = Random();

   117

			tile = TILE_MASK(r);

   118

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

   119

				PlaceTree(tile, r, 0);

   120

			}

   121

		} while (--i);

   122

	}

   123

}

   124

   125

void GenerateTrees()

   126

{

   127

	int i;

   128

   129

	if (_opt.landscape != LT_CANDY) {

   130

		PlaceMoreTrees();

   131

	}

   132

   133

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

   134

	do {

   135

		PlaceTreesRandomly();

   136

	} while (--i);

   137

}

   138

   139

/* Plant a tree

   140

 * p1 = tree type, -1 means random.

   141

 * p2 = end tile

   142

 */

   143

   144

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

   145

{

   146

	TileInfo ti;

   147

	int32 cost;

   148

	int sx,sy,x,y;

   149

	int treetype;

   150

   151

	SET_EXPENSES_TYPE(EXPENSES_OTHER);

   152

   153

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

   154

	sx = GET_TILE_X(p2)*16;

   155

	sy = GET_TILE_Y(p2)*16;

   156

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

   157

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

   158

   159

	cost = 0; // total cost

   160

   161

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

   162

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

   163

			FindLandscapeHeight(&ti, x, y);

   164

			if (!EnsureNoVehicle(ti.tile))

   165

				continue;

   166

   167

			if (ti.type == MP_TREES) {

   168

				// no more space for trees?

   169

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

   170

					_error_message = STR_2803_TREE_ALREADY_HERE;

   171

					continue;

   172

				}

   173

   174

				if (flags & DC_EXEC) {

   175

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

   176

					MarkTileDirtyByTile(ti.tile);

   177

				}

   178

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

   179

				cost += _price.build_trees * 2;

   180

			} else {

   181

				// don't allow building on rocks

   182

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

   183

					_error_message = STR_2804_SITE_UNSUITABLE;

   184

					continue;

   185

				}

   186

   187

				// it's expensive to clear farmland

   188

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

   189

   190

				if (flags & DC_EXEC) {

   191

					int m2;

   192

   193

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

   194

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

   195

						if (t != NULL)

   196

							ChangeTownRating(t, 7, 220);

   197

					}

   198

					m2 = 0;

   199

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

   200

						m2 = 16;

   201

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

   202

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

   203

					}

   204

   205

					treetype = p1;

   206

					if (treetype == -1) {

   207

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

   208

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

   209

					}

   210

   211

					ModifyTile(ti.tile,

   212

						MP_SETTYPE(MP_TREES) |

   213

						MP_MAP2 | MP_MAP3LO | MP_MAP3HI_CLEAR | MP_MAP5,

   214

						m2, /* map2 */

   215

						treetype, /* map3lo */

   216

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

   217

					);

   218

   219

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

   220

						SetMapExtraBits(ti.tile, 2);

   221

					}

   222

				}

   223

				cost += _price.build_trees;

   224

			}

   225

		}

   226

	}

   227

   228

	if (cost == 0) return CMD_ERROR;

   229

	return cost;

   230

}

   231

   232

typedef struct TreeListEnt {

   233

	uint32 image;

   234

	byte x,y;

   235

} TreeListEnt;

   236

   237

   238

#include "table/tree_land.h"

   239

   240

   241

static void DrawTile_Trees(TileInfo *ti)

   242

{

   243

	byte m2;

   244

	const uint32 *s;

   245

	const byte *d;

   246

	byte z;

   247

	TreeListEnt te[4];

   248

   249

	m2 = _map2[ti->tile];

   250

   251

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

   252

		DrawClearLandTile(ti, 3);

   253

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

   254

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

   255

	} else {

   256

		DrawHillyLandTile(ti);

   257

	}

   258

   259

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

   260

   261

	z = ti->z;

   262

	if (ti->tileh != 0) {

   263

		z += 4;

   264

		if (ti->tileh & 0x10)

   265

			z += 4;

   266

	}

   267

   268

	{

   269

		uint16 tmp = ti->x;

   270

		int index;

   271

   272

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

   273

		tmp -= ti->y;

   274

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

   275

		tmp -= ti->x;

   276

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

   277

		tmp += ti->y;

   278

   279

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

   280

   281

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

   282

   283

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

   284

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

   285

			index += 164 - 48;

   286

   287

		assert(index < lengthof(_tree_layout_sprite));

   288

		s = _tree_layout_sprite[index];

   289

	}

   290

   291

	StartSpriteCombine();

   292

   293

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

   294

	{

   295

		int i;

   296

   297

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

   298

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

   299

		do {

   300

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

   301

			if (_display_opt & DO_TRANS_BUILDINGS)

   302

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

   303

			te[i].image = image;

   304

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

   305

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

   306

			s++;

   307

			d+=2;

   308

		} while (i);

   309

   310

		/* draw them in a sorted way */

   311

		for(;;) {

   312

			byte min = 0xFF;

   313

			TreeListEnt *tep = NULL;

   314

   315

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

   316

			do {

   317

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

   318

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

   319

					tep = &te[i];

   320

				}

   321

			} while (i);

   322

   323

			if (tep == NULL)

   324

				break;

   325

   326

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

   327

			tep->image = 0;

   328

		}

   329

	}

   330

   331

	EndSpriteCombine();

   332

}

   333

   334

   335

static uint GetSlopeZ_Trees(TileInfo *ti) {

   336

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

   337

}

   338

   339

static uint GetSlopeTileh_Trees(TileInfo *ti) {

   340

	return ti->tileh;

   341

}

   342

   343

static int32 ClearTile_Trees(uint tile, byte flags) {

   344

	int num;

   345

   346

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

   347

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

   348

		if (t != NULL)

   349

			ChangeTownRating(t, -35, -1000);

   350

	}

   351

   352

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

   353

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

   354

		num <<= 2;

   355

   356

	if (flags & DC_EXEC)

   357

		DoClearSquare(tile);

   358

   359

	return num * _price.remove_trees;

   360

}

   361

   362

static void GetAcceptedCargo_Trees(uint tile, AcceptedCargo ac)

   363

{

   364

	/* not used */

   365

}

   366

   367

static void GetTileDesc_Trees(uint tile, TileDesc *td)

   368

{

   369

	byte b;

   370

	StringID str;

   371

   372

	td->owner = _map_owner[tile];

   373

   374

	b = _map3_lo[tile];

   375

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

   376

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

   377

	(str=STR_280E_TREES, true);

   378

	td->str = str;

   379

}

   380

   381

static void AnimateTile_Trees(uint tile)

   382

{

   383

	/* not used */

   384

}

   385

   386

static SoundFx _desert_sounds[] = {

   387

	SND_42_LOON_BIRD,

   388

	SND_43_LION,

   389

	SND_44_MONKEYS,

   390

	SND_48_DISTANT_BIRD

   391

};

   392

   393

static void TileLoopTreesDesert(uint tile)

   394

{

   395

	byte b;

   396

   397

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

   398

		uint32 r;

   399

   400

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

   401

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

   402

		}

   403

	} else if (b == 1) {

   404

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

   405

			_map2[tile] &= 0xF;

   406

			_map2[tile] |= 0xE0;

   407

			MarkTileDirtyByTile(tile);

   408

		}

   409

	}

   410

}

   411

   412

static void TileLoopTreesAlps(uint tile)

   413

{

   414

	byte tmp, m2;

   415

	int k;

   416

   417

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

   418

	k = GetTileZ(tile) - _opt.snow_line;

   419

   420

	tmp = _map5[tile] & 0xF0;

   421

   422

	if (k < -8) {

   423

		/* snow_m2_down */

   424

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

   425

			return;

   426

		m2 = 0;

   427

	} else if (k == -8) {

   428

		/* snow_m1 */

   429

		m2 = 0x20;

   430

		if (tmp == m2)

   431

			return;

   432

	} else if (k < 8) {

   433

		/* snow_0 */

   434

		m2 = 0x60;

   435

		if (tmp == m2)

   436

			return;

   437

	} else if (k == 8) {

   438

		/* snow_p1 */

   439

		m2 = 0xA0;

   440

		if (tmp == m2)

   441

			return;

   442

	} else {

   443

		/* snow_p2_up */

   444

		if (tmp == 0xC0) {

   445

			uint32 r;

   446

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

   447

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

   448

			}

   449

			return;

   450

		} else {

   451

			m2 = 0xE0;

   452

		}

   453

	}

   454

   455

	_map2[tile] &= 0xF;

   456

	_map2[tile] |= m2;

   457

	MarkTileDirtyByTile(tile);

   458

}

   459

   460

static void TileLoop_Trees(uint tile)

   461

{

   462

	byte m5, m2;

   463

   464

	static const TileIndexDiff _tileloop_trees_dir[] = {

   465

		TILE_XY(-1,-1),

   466

		TILE_XY(0,-1),

   467

		TILE_XY(1,-1),

   468

		TILE_XY(-1,0),

   469

		TILE_XY(1,0),

   470

		TILE_XY(-1,1),

   471

		TILE_XY(0,1),

   472

		TILE_XY(1,1),

   473

	};

   474

   475

	if (_opt.landscape == LT_DESERT) {

   476

		TileLoopTreesDesert(tile);

   477

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

   478

		TileLoopTreesAlps(tile);

   479

	}

   480

   481

	TileLoopClearHelper(tile);

   482

   483

	/* increase counter */

   484

	{

   485

		byte m2 = _map2[tile];

   486

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

   487

		if (m2 & 0xF)

   488

			return;

   489

	}

   490

   491

	m5 = _map5[tile];

   492

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

   493

		/* regular sized tree */

   494

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

   495

			m5++; /* start destructing */

   496

		} else {

   497

			switch(Random() & 0x7) {

   498

			case 0: /* start destructing */

   499

				m5++;

   500

				break;

   501

   502

			case 1: /* add a tree */

   503

				if (m5 < 0xC0) {

   504

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

   505

					break;

   506

				}

   507

				/* fall through */

   508

   509

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

   510

				byte m3 = _map3_lo[tile];

   511

   512

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

   513

   514

				if (!IS_TILETYPE(tile, MP_CLEAR))

   515

					return;

   516

   517

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

   518

					_map2[tile] = 0x10;

   519

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

   520

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

   521

				} else {

   522

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

   523

						return;

   524

					_map2[tile] = 0;