1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "viewport.h"

     4

#include "command.h"

     5

#include "industry.h"

     6

#include "town.h"

     7

#include "vehicle.h"

     8

#include "news.h"

     9

#include "saveload.h"

    10

#include "economy.h"

    11

    12

byte _industry_sound_ctr;

    13

TileIndex _industry_sound_tile;

    14

    15

void ShowIndustryViewWindow(int industry);

    16

void BuildOilRig(uint tile);

    17

void DeleteOilRig(uint tile);

    18

    19

typedef struct DrawIndustryTileStruct {

    20

	uint32 sprite_1;

    21

	uint32 sprite_2;

    22

    23

	byte subtile_xy;

    24

	byte width_height;

    25

	byte dz;

    26

	byte proc;

    27

} DrawIndustryTileStruct;

    28

    29

    30

typedef struct DrawIndustrySpec1Struct {

    31

	byte x;

    32

	byte image_1;

    33

	byte image_2;

    34

	byte image_3;

    35

} DrawIndustrySpec1Struct;

    36

    37

typedef struct DrawIndustrySpec4Struct {

    38

	byte image_1;

    39

	byte image_2;

    40

	byte image_3;

    41

} DrawIndustrySpec4Struct;

    42

    43

    44

    45

#include "table/industry_land.h"

    46

    47

    48

typedef struct IndustryTileTable {

    49

	TileIndexDiff ti;

    50

	byte map5;

    51

} IndustryTileTable;

    52

    53

typedef struct IndustrySpec {

    54

	const IndustryTileTable * const * table;

    55

	byte num_table;

    56

	byte a,b,c;

    57

	byte produced_cargo[2];

    58

	byte production_rate[2];

    59

	byte accepts_cargo[3];

    60

	byte check_proc;

    61

} IndustrySpec;

    62

    63

#include "table/build_industry.h"

    64

    65

static const byte _industry_close_mode[37] = {

    66

	1,0,2,1,2,1,2,2,2,1,1,1,0,2,2,1,0,1,1,1,1,1,0,2,1,2,1,2,1,1,0,2,1,2,1,1,1,

    67

};

    68

    69

static const StringID _industry_prod_up_strings[] = {

    70

	STR_4836_NEW_COAL_SEAM_FOUND_AT,

    71

	STR_4835_INCREASES_PRODUCTION,

    72

	STR_4835_INCREASES_PRODUCTION,

    73

	STR_4835_INCREASES_PRODUCTION,

    74

	STR_4835_INCREASES_PRODUCTION,

    75

	STR_4837_NEW_OIL_RESERVES_FOUND,

    76

	STR_4835_INCREASES_PRODUCTION,

    77

	STR_4835_INCREASES_PRODUCTION,

    78

	STR_4835_INCREASES_PRODUCTION,

    79

	STR_4838_IMPROVED_FARMING_METHODS,

    80

	STR_4835_INCREASES_PRODUCTION,

    81

	STR_4837_NEW_OIL_RESERVES_FOUND,

    82

	STR_4835_INCREASES_PRODUCTION,

    83

	STR_4835_INCREASES_PRODUCTION,

    84

	STR_4835_INCREASES_PRODUCTION,

    85

	STR_4835_INCREASES_PRODUCTION,

    86

	STR_4835_INCREASES_PRODUCTION,

    87

	STR_4835_INCREASES_PRODUCTION,

    88

	STR_4835_INCREASES_PRODUCTION,

    89

	STR_4838_IMPROVED_FARMING_METHODS,

    90

	STR_4838_IMPROVED_FARMING_METHODS,

    91

	STR_4835_INCREASES_PRODUCTION,

    92

	STR_4835_INCREASES_PRODUCTION,

    93

	STR_4835_INCREASES_PRODUCTION,

    94

	STR_4838_IMPROVED_FARMING_METHODS,

    95

	STR_4835_INCREASES_PRODUCTION,

    96

	STR_4838_IMPROVED_FARMING_METHODS,

    97

	STR_4835_INCREASES_PRODUCTION,

    98

	STR_4838_IMPROVED_FARMING_METHODS,

    99

	STR_4835_INCREASES_PRODUCTION,

   100

	STR_4835_INCREASES_PRODUCTION,

   101

	STR_4835_INCREASES_PRODUCTION,

   102

	STR_4835_INCREASES_PRODUCTION,

   103

	STR_4835_INCREASES_PRODUCTION,

   104

	STR_4835_INCREASES_PRODUCTION,

   105

	STR_4835_INCREASES_PRODUCTION,

   106

	STR_4835_INCREASES_PRODUCTION,

   107

};

   108

   109

static const StringID _industry_prod_down_strings[] = {

   110

	STR_4839_PRODUCTION_DOWN_BY_50,

   111

	STR_4839_PRODUCTION_DOWN_BY_50,

   112

	STR_4839_PRODUCTION_DOWN_BY_50,

   113

	STR_483A_INSECT_INFESTATION_CAUSES,

   114

	STR_4839_PRODUCTION_DOWN_BY_50,

   115

	STR_4839_PRODUCTION_DOWN_BY_50,

   116

	STR_4839_PRODUCTION_DOWN_BY_50,

   117

	STR_4839_PRODUCTION_DOWN_BY_50,

   118

	STR_4839_PRODUCTION_DOWN_BY_50,

   119

	STR_483A_INSECT_INFESTATION_CAUSES,

   120

	STR_4839_PRODUCTION_DOWN_BY_50,

   121

	STR_4839_PRODUCTION_DOWN_BY_50,

   122

	STR_4839_PRODUCTION_DOWN_BY_50,

   123

	STR_4839_PRODUCTION_DOWN_BY_50,

   124

	STR_4839_PRODUCTION_DOWN_BY_50,

   125

	STR_4839_PRODUCTION_DOWN_BY_50,

   126

	STR_4839_PRODUCTION_DOWN_BY_50,

   127

	STR_4839_PRODUCTION_DOWN_BY_50,

   128

	STR_4839_PRODUCTION_DOWN_BY_50,

   129

	STR_483A_INSECT_INFESTATION_CAUSES,

   130

	STR_483A_INSECT_INFESTATION_CAUSES,

   131

	STR_4839_PRODUCTION_DOWN_BY_50,

   132

	STR_4839_PRODUCTION_DOWN_BY_50,

   133

	STR_4839_PRODUCTION_DOWN_BY_50,

   134

	STR_483A_INSECT_INFESTATION_CAUSES,

   135

	STR_4839_PRODUCTION_DOWN_BY_50,

   136

	STR_4839_PRODUCTION_DOWN_BY_50,

   137

	STR_4839_PRODUCTION_DOWN_BY_50,

   138

	STR_483A_INSECT_INFESTATION_CAUSES,

   139

	STR_4839_PRODUCTION_DOWN_BY_50,

   140

	STR_4839_PRODUCTION_DOWN_BY_50,

   141

	STR_4839_PRODUCTION_DOWN_BY_50,

   142

	STR_4839_PRODUCTION_DOWN_BY_50,

   143

	STR_4839_PRODUCTION_DOWN_BY_50,

   144

	STR_4839_PRODUCTION_DOWN_BY_50,

   145

	STR_4839_PRODUCTION_DOWN_BY_50,

   146

	STR_4839_PRODUCTION_DOWN_BY_50,

   147

};

   148

   149

static const StringID _industry_close_strings[] = {

   150

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   151

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   152

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   153

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   154

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   155

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   156

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   157

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   158

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   159

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   160

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   161

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   162

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   163

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   164

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   165

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   166

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   167

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   168

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   169

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   170

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   171

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   172

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   173

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   174

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   175

	STR_4834_LACK_OF_NEARBY_TREES_CAUSES,

   176

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   177

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   178

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   179

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   180

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   181

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   182

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   183

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   184

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   185

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   186

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE	,

   187

};

   188

   189

   190

static void IndustryDrawTileProc1(TileInfo *ti)

   191

{

   192

	const DrawIndustrySpec1Struct *d;

   193

	uint32 image;

   194

   195

	if (!(_map_owner[ti->tile] & 0x80))

   196

		return;

   197

   198

	d = &_draw_industry_spec1[_map3_lo[ti->tile]];

   199

   200

	AddChildSpriteScreen(0x12A7 + d->image_1, d->x, 0);

   201

   202

	if ( (image = d->image_2) != 0)

   203

		AddChildSpriteScreen(0x12B0 + image - 1, 8, 41);

   204

   205

	if ( (image = d->image_3) != 0)

   206

		AddChildSpriteScreen(0x12AC + image - 1, 

   207

			_drawtile_proc1_x[image-1], _drawtile_proc1_y[image-1]);

   208

}

   209

   210

static void IndustryDrawTileProc2(TileInfo *ti)

   211

{

   212

	int x = 0;

   213

   214

	if (_map_owner[ti->tile] & 0x80) {

   215

		x = _industry_anim_offs[_map3_lo[ti->tile]];

   216

		if ( (byte)x == 0xFF)

   217

			x = 0;

   218

	}

   219

   220

	AddChildSpriteScreen(0x129F, 22-x, x+24);

   221

	AddChildSpriteScreen(0x129E, 6, 0xE);

   222

}

   223

   224

static void IndustryDrawTileProc3(TileInfo *ti)

   225

{

   226

	if (_map_owner[ti->tile] & 0x80) {

   227

		AddChildSpriteScreen(0x128B, 5, 

   228

			_industry_anim_offs_2[_map3_lo[ti->tile]]);

   229

	}

   230

	AddChildSpriteScreen(0x30B928A, 3, 67);

   231

}

   232

   233

static void IndustryDrawTileProc4(TileInfo *ti)

   234

{

   235

	const DrawIndustrySpec4Struct *d;

   236

   237

	d = &_industry_anim_offs_3[_map3_lo[ti->tile]];

   238

   239

	if (d->image_1 != 0xFF) {

   240

		AddChildSpriteScreen(0x126F, 0x32 - d->image_1 * 2, 0x60 + d->image_1);

   241

	}

   242

   243

	if (d->image_2 != 0xFF) {

   244

		AddChildSpriteScreen(0x1270, 0x10 - d->image_2*2, 100 + d->image_2);

   245

	}

   246

   247

	AddChildSpriteScreen(0x126E, 7, d->image_3);

   248

	AddChildSpriteScreen(0x126D, 0, 42);

   249

}

   250

   251

static void DrawCoalPlantSparkles(TileInfo *ti)

   252

{

   253

	int image = _map_owner[ti->tile];

   254

	if (image & 0x80) {

   255

		image = (image >> 2) & 0x1F;

   256

		if (image != 0 && image < 7) {

   257

			AddChildSpriteScreen(image + 0x806, 

   258

				_coal_plant_sparkles_x[image-1],

   259

				_coal_plant_sparkles_y[image-1]

   260

			);

   261

		}

   262

	}

   263

}

   264

   265

typedef void IndustryDrawTileProc(TileInfo *ti);

   266

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   267

	IndustryDrawTileProc1,

   268

	IndustryDrawTileProc2,

   269

	IndustryDrawTileProc3,

   270

	IndustryDrawTileProc4,

   271

	DrawCoalPlantSparkles,

   272

};

   273

   274

static void DrawTile_Industry(TileInfo *ti)

   275

{

   276

	Industry *ind;

   277

	const DrawIndustryTileStruct *dits;

   278

	byte z;

   279

	uint32 image, ormod;

   280

   281

	/* Pointer to industry */

   282

	ind = DEREF_INDUSTRY(_map2[ti->tile]);

   283

	ormod = (ind->color_map+0x307)<<16;

   284

   285

	/* Retrieve pointer to the draw industry tile struct */

   286

	dits = &_industry_draw_tile_data[(ti->map5<<2) | (_map_owner[ti->tile]&3)];

   287

   288

	image = dits->sprite_1;

   289

	if (image&0x8000 && (image & 0xFFFF0000) == 0)

   290

		image |= ormod;

   291

   292

	z = ti->z;

   293

	/* Add bricks below the industry? */

   294

	if (ti->tileh & 0xF) {

   295

		AddSortableSpriteToDraw((ti->tileh & 0xF) + 0x3DD, ti->x, ti->y, 16, 16, 7, z);

   296

		AddChildSpriteScreen(image, 0x1F, 1);

   297

		z += 8;

   298

	} else {

   299

		/* Else draw regular ground */

   300

		DrawGroundSprite(image);

   301

	}

   302

   303

	/* Add industry on top of the ground? */

   304

	if ((image = dits->sprite_2) != 0) {

   305

   306

		if (image&0x8000 && (image & 0xFFFF0000) == 0)

   307

			image |= ormod;

   308

   309

		if (!(_display_opt & DO_TRANS_BUILDINGS))

   310

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

   311

   312

		AddSortableSpriteToDraw(image, 

   313

			ti->x | (dits->subtile_xy>>4),

   314

			ti->y | (dits->subtile_xy&0xF),

   315

			(dits->width_height>>4)+1,

   316

			(dits->width_height&0xF)+1,

   317

			dits->dz,

   318

			z);

   319

   320

		if (!(_display_opt & DO_TRANS_BUILDINGS))

   321

			return;

   322

	}

   323

   324

	/* TTDBUG: strange code here, return if AddSortableSpriteToDraw failed?  */	

   325

		{

   326

		int proc;

   327

		if ((proc=dits->proc-1) >= 0 )

   328

			_industry_draw_tile_procs[proc](ti);

   329

	}

   330

}

   331

   332

   333

static uint GetSlopeZ_Industry(TileInfo *ti) {

   334

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

   335

}

   336

   337

static void GetAcceptedCargo_Industry(uint tile, AcceptedCargo *ac)

   338

{

   339

	int m5 = _map5[tile];

   340

	int a;

   341

   342

	a = _industry_map5_accepts_1[m5];

   343

	if (a >= 0) {

   344

		ac->type_1 = a;

   345

		ac->amount_1 = (a == 0) ? 1 : 8;

   346

	}

   347

   348

	a = _industry_map5_accepts_2[m5];

   349

	if (a >= 0) {

   350

		ac->type_2 = a;

   351

		ac->amount_2 = 8;

   352

	}

   353

   354

	a = _industry_map5_accepts_3[m5];

   355

	if (a >= 0) {

   356

		ac->type_3 = a;

   357

		ac->amount_3 = 8;

   358

	}

   359

}

   360

   361

static void GetTileDesc_Industry(uint tile, TileDesc *td)

   362

{

   363

	Industry *i = DEREF_INDUSTRY(_map2[tile]);

   364

   365

	td->owner = i->owner;

   366

	td->str = STR_4802_COAL_MINE + i->type;

   367

	if ((_map_owner[tile] & 0x80) == 0) {

   368

		SET_DPARAMX16(td->dparam, 0, td->str);

   369

		td->str = STR_2058_UNDER_CONSTRUCTION;

   370

	}

   371

}

   372

   373

static int32 ClearTile_Industry(uint tile, byte flags)

   374

{

   375

	Industry *i = DEREF_INDUSTRY(_map2[tile]);

   376

   377

 if ((_current_player == OWNER_WATER || _game_mode != GM_EDITOR) && !_cheats.magic_bulldozer.value) {

   378

 		SET_DPARAM16(0, STR_4802_COAL_MINE + i->type);

   379

		return_cmd_error(STR_4800_IN_THE_WAY);

   380

	}

   381

   382

	if (flags & DC_EXEC) {

   383

 		DeleteIndustry(i);

   384

	}

   385

	return 0;

   386

}

   387

   388

/* p1 index of industry to destroy */

   389

/* Destroy Industry button costing money removed per request of dominik

   390

int32 CmdDestroyIndustry(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   391

{

   392

	uint tile = TILE_FROM_XY(x,y);

   393

	Industry *i = DEREF_INDUSTRY((uint16)p1);

   394

  Town *t = ClosestTownFromTile(tile, (uint)-1); // find closest town to penaltize (ALWAYS penaltize)

   395

   396

	// check if you're allowed to remove the industry. Minimum amount

   397

	// of ratings to remove the industry depends on difficulty setting

   398

	if (!CheckforTownRating(tile, flags, t, INDUSTRY_REMOVE)) 

   399

		return CMD_ERROR;

   400

   401

	if (flags & DC_EXEC) {

   402

		DeleteIndustry(i);

   403

		CreateEffectVehicleAbove(x + 8,y + 8, 2, EV_DEMOLISH);

   404

		ChangeTownRating(t, -1500, -1000);	// penalty is 1500

   405

	}

   406

   407

	return (_price.build_industry >> 5) * _industry_type_costs[i->type]*2;

   408

}

   409

*/

   410

   411

static const byte _industry_min_cargo[] = {

   412

	5, 5, 5, 30, 5, 5, 5, 5,

   413

	5, 5, 5, 5, 2, 5, 5, 5,

   414

	5, 5, 5, 15, 15, 5, 5, 5,

   415

	5, 5, 30, 5, 30, 5, 5, 5,

   416

	5, 5, 5, 5, 5,

   417

};

   418

   419

void TransportIndustryGoods(uint tile)

   420

{

   421

	Industry *i;

   422

	int type;

   423

	uint cw, am;

   424

	byte m5;

   425

   426

	i = DEREF_INDUSTRY(_map2[tile]);

   427

   428

	type = i->type;

   429

	cw = min(i->cargo_waiting[0], 255);

   430

	if (cw > _industry_min_cargo[type]/* && i->produced_cargo[0] != 0xFF*/) {

   431

		i->cargo_waiting[0] -= cw;

   432

   433

		/* fluctuating economy? */

   434

		if (_economy.fluct <= 0) cw = (cw + 1) >> 1;

   435

   436

		i->last_mo_production[0] += cw;

   437

   438

		am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[0], cw);

   439

		i->last_mo_transported[0] += am;

   440

		if (am != 0 && (m5 = _industry_produce_map5[_map5[tile]]) != 0xFF) {

   441

			_map5[tile] = m5;

   442

			_map_owner[tile] = 0x80;

   443

			MarkTileDirtyByTile(tile);

   444

		}

   445

	}

   446

   447

	type = i->type;

   448

	cw = min(i->cargo_waiting[1], 255);

   449

	if (cw > _industry_min_cargo[type]) {

   450

		i->cargo_waiting[1] -= cw;

   451

   452

		if (_economy.fluct <= 0) cw = (cw + 1) >> 1;

   453

   454

		i->last_mo_production[1] += cw;

   455

   456

		am = MoveGoodsToStation(i->xy, i->width, i->height, i->produced_cargo[1], cw);

   457

		i->last_mo_transported[1] += am;

   458

	}

   459

}

   460

   461

   462

static void AnimateTile_Industry(uint tile)

   463

{

   464

	byte m,n;

   465

   466

	switch(_map5[tile]) {

   467

	case 174:

   468

		if ((_tick_counter & 1) == 0) {

   469

			m = _map3_lo[tile] + 1;

   470

   471

			switch(m & 7) {

   472

			case 2:	SndPlayTileFx(45, tile); break;

   473

			case 6: SndPlayTileFx(41, tile); break;

   474

			}

   475

   476

			if (m >= 96) {

   477

				m = 0;

   478

				DeleteAnimatedTile(tile);

   479

			}

   480

			_map3_lo[tile] = m;

   481

   482

			MarkTileDirtyByTile(tile);

   483

		}

   484

		break;

   485

   486

	case 165:

   487

		if ((_tick_counter & 3) == 0) {

   488

			m = _map3_lo[tile];

   489

   490

			if (_industry_anim_offs[m] == 0xFF) {

   491

				SndPlayTileFx(48, tile);

   492

			}

   493

   494

			if (++m >= 70) {

   495

				m = 0;

   496

				DeleteAnimatedTile(tile);

   497

			}

   498

			_map3_lo[tile] = m;

   499

   500

			MarkTileDirtyByTile(tile);

   501

		}

   502

		break;

   503

   504

	case 162:

   505

		if ((_tick_counter&1) == 0) {

   506

			m = _map3_lo[tile];

   507

   508

			if (++m >= 40) {

   509

				m = 0;

   510

				DeleteAnimatedTile(tile);

   511

			}

   512

			_map3_lo[tile] = m;

   513

   514

			MarkTileDirtyByTile(tile);

   515

		}

   516

		break;

   517

   518

	// Sparks on a coal plant

   519

	case 10:

   520

		if ((_tick_counter & 3) == 0) {

   521

			m = _map_owner[tile];

   522

			if ((m & (31<<2)) == (6 << 2)) {

   523

				_map_owner[tile] = m&~(31<<2);

   524

				DeleteAnimatedTile(tile);

   525

			} else {

   526

				_map_owner[tile] = m + (1<<2);

   527

				MarkTileDirtyByTile(tile);

   528

			}

   529

		}

   530