1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "functions.h"

     7

#include "industry_map.h"

     8

#include "station_map.h"

     9

#include "table/strings.h"

    10

#include "table/sprites.h"

    11

#include "map.h"

    12

#include "tile.h"

    13

#include "viewport.h"

    14

#include "command.h"

    15

#include "industry.h"

    16

#include "town.h"

    17

#include "vehicle.h"

    18

#include "news.h"

    19

#include "saveload.h"

    20

#include "economy.h"

    21

#include "sound.h"

    22

#include "variables.h"

    23

#include "table/industry_land.h"

    24

#include "table/build_industry.h"

    25

#include "genworld.h"

    26

#include "date.h"

    27

    28

void ShowIndustryViewWindow(int industry);

    29

void BuildOilRig(TileIndex tile);

    30

void DeleteOilRig(TileIndex tile);

    31

    32

static byte _industry_sound_ctr;

    33

static TileIndex _industry_sound_tile;

    34

    35

/**

    36

 * Called if a new block is added to the industry-pool

    37

 */

    38

static void IndustryPoolNewBlock(uint start_item)

    39

{

    40

	Industry *i;

    41

    42

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

    43

	 * TODO - This is just a temporary stage, this will be removed. */

    45

}

    46

    48

    49

/**

    50

 * Retrieve the type for this industry.  Although it is accessed by a tile,

    51

 * it will return the general type of industry, and not the sprite index

    52

 * as would do GetIndustryGfx.

    53

 * The same information can be accessed by looking at Industry->type

    54

 * @param tile that is queried

    55

 * @pre IsTileType(tile, MP_INDUSTRY)

    56

 * @return general type for this industry, as defined in industry.h

    57

 **/

    58

IndustryType GetIndustryType(TileIndex tile)

    59

{

    60

	IndustryGfx this_type = GetIndustryGfx(tile);

    61

	IndustryType iloop;

    62

    63

	assert(IsTileType(tile, MP_INDUSTRY));

    64

    65

	for (iloop = IT_COAL_MINE; iloop < IT_END; iloop += 1) {

    66

		if (IS_BYTE_INSIDE(this_type, industry_gfx_Solver[iloop].MinGfx,

    67

				industry_gfx_Solver[iloop].MaxGfx+1)) {

    68

			return iloop;

    69

		}

    70

	}

    71

    72

	return IT_INVALID;  //we have not found equivalent, whatever the reason

    73

}

    74

    75

/**

    76

 * Accessor for array _industry_specs.

    77

 * This will ensure at once : proper access and

    78

 * not allowing modifications of it.

    79

 * @param thistype of industry (which is the index in _industry_specs)

    80

 * @pre thistype < IT_END

    81

 **/

    82

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    83

{

    84

	assert(thistype < IT_END);

    85

	return &_industry_specs[thistype];

    86

}

    87

    88

void DestroyIndustry(Industry *i)

    89

{

    90

	BEGIN_TILE_LOOP(tile_cur, i->width, i->height, i->xy);

    91

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

    92

			if (GetIndustryIndex(tile_cur) == i->index) {

    93

				DoClearSquare(tile_cur);

    94

			}

    95

		} else if (IsTileType(tile_cur, MP_STATION) && IsOilRig(tile_cur)) {

    96

			DeleteOilRig(tile_cur);

    97

		}

    98

	END_TILE_LOOP(tile_cur, i->width, i->height, i->xy);

    99

   100

	if (i->type == IT_FARM || i->type == IT_FARM_2) {

   101

		/* Remove the farmland and convert it to regular tiles over time. */

   102

		BEGIN_TILE_LOOP(tile_cur, 42, 42, i->xy - TileDiffXY(21, 21)) {

   103

			tile_cur = TILE_MASK(tile_cur);

   104

			if (IsTileType(tile_cur, MP_CLEAR) && IsClearGround(tile_cur, CLEAR_FIELDS) &&

   105

					GetIndustryIndexOfField(tile_cur) == i->index) {

   106

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   107

			}

   108

		} END_TILE_LOOP(tile_cur, 42, 42, i->xy - TileDiff(21, 21))

   109

	}

   110

   111

	_industry_sort_dirty = true;

   112

	DeleteSubsidyWithIndustry(i->index);

   113

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   114

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   115

}

   116

   117

static void IndustryDrawSugarMine(const TileInfo *ti)

   118

{

   119

	const DrawIndustrySpec1Struct *d;

   120

	uint32 image;

   121

   122

	if (!IsIndustryCompleted(ti->tile)) return;

   123

   124

	d = &_draw_industry_spec1[_m[ti->tile].m3];

   125

   126

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

   127

   128

	image = d->image_2;

   129

	if (image != 0) AddChildSpriteScreen(SPR_IT_SUGAR_MINE_CLOUDS + image - 1, 8, 41);

   130

   131

	image = d->image_3;

   132

	if (image != 0) {

   133

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1,

   134

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

   135

	}

   136

}

   137

   138

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   139

{

   140

	int x = 0;

   141

   142

	if (IsIndustryCompleted(ti->tile)) {

   143

		x = _industry_anim_offs[_m[ti->tile].m3];

   144

		if ( (byte)x == 0xFF)

   145

			x = 0;

   146

	}

   147

   148

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_SHOVEL, 22 - x, 24 + x);

   149

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, 6, 14);

   150

}

   151

   152

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   153

{

   154

	if (IsIndustryCompleted(ti->tile)) {

   155

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_BUBBLE, 5, _industry_anim_offs_2[_m[ti->tile].m3]);

   156

	} else {

   157

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, 3, 67);

   158

	}

   159

}

   160

   161

static void IndustryDrawToyFactory(const TileInfo *ti)

   162

{

   163

	const DrawIndustrySpec4Struct *d;

   164

   165

	d = &_industry_anim_offs_3[_m[ti->tile].m3];

   166

   167

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

   168

		AddChildSpriteScreen(SPR_IT_TOY_FACTORY_CLAY, 50 - d->image_1 * 2, 96 + d->image_1);

   169

	}

   170

   171

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

   172

		AddChildSpriteScreen(SPR_IT_TOY_FACTORY_ROBOT, 16 - d->image_2 * 2, 100 + d->image_2);

   173

	}

   174

   175

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP, 7, d->image_3);

   176

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, 0, 42);

   177

}

   178

   179

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   180

{

   181

	if (IsIndustryCompleted(ti->tile)) {

   182

		uint image = GB(_m[ti->tile].m1, 2, 5);

   183

   184

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

   185

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   186

				_coal_plant_sparks_x[image - 1],

   187

				_coal_plant_sparks_y[image - 1]

   188

			);

   189

		}

   190

	}

   191

}

   192

   193

typedef void IndustryDrawTileProc(const TileInfo *ti);

   194

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   195

	IndustryDrawSugarMine,

   196

	IndustryDrawToffeeQuarry,

   197

	IndustryDrawBubbleGenerator,

   198

	IndustryDrawToyFactory,

   199

	IndustryDrawCoalPlantSparks,

   200

};

   201

   202

static void DrawTile_Industry(TileInfo *ti)

   203

{

   204

	const Industry *ind;

   205

	const DrawBuildingsTileStruct *dits;

   206

	byte z;

   207

	uint32 image, ormod;

   208

   209

	/* Pointer to industry */

   210

	ind = GetIndustryByTile(ti->tile);

   211

	ormod = GENERAL_SPRITE_COLOR(ind->random_color);

   212

   213

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

   214

	dits = &_industry_draw_tile_data[GetIndustryGfx(ti->tile) << 2 | GetIndustryConstructionStage(ti->tile)];

   215

   216

	image = dits->ground;

   217

	if (image & PALETTE_MODIFIER_COLOR && (image & PALETTE_SPRITE_MASK) == 0)

   218

		image |= ormod;

   219

   220

	z = ti->z;

   221

	/* Add bricks below the industry? */

   222

	if (ti->tileh != SLOPE_FLAT) {

   223

		AddSortableSpriteToDraw(SPR_FOUNDATION_BASE + ti->tileh, ti->x, ti->y, 16, 16, 7, z);

   224

		AddChildSpriteScreen(image, 31, 1);

   225

		z += TILE_HEIGHT;

   226

	} else {

   227

		/* Else draw regular ground */

   228

		DrawGroundSprite(image);

   229

	}

   230

   231

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

   232

	image = dits->building;

   233

	if (image != 0) {

   234

		if (image & PALETTE_MODIFIER_COLOR && (image & PALETTE_SPRITE_MASK) == 0)

   235

			image |= ormod;

   236

   237

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   238

   239

		AddSortableSpriteToDraw(image,

   240

			ti->x + dits->subtile_x,

   241

			ti->y + dits->subtile_y,

   242

			dits->width  + 1,

   243

			dits->height + 1,

   244

			dits->dz,

   245

			z);

   246

   247

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   248

	}

   249

   250

	{

   251

		int proc = dits->draw_proc - 1;

   252

		if (proc >= 0) _industry_draw_tile_procs[proc](ti);

   253

	}

   254

}

   255

   256

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

   257

{

   258

	return GetTileMaxZ(tile);

   259

}

   260

   261

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   262

{

   263

	return SLOPE_FLAT;

   264

}

   265

   266

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   267

{

   268

	IndustryGfx gfx = GetIndustryGfx(tile);

   269

	CargoID a;

   270

   271

	a = _industry_section_accepts_1[gfx];

   272

	if (a != CT_INVALID) ac[a] = (a == 0) ? 1 : 8;

   273

   274

	a = _industry_section_accepts_2[gfx];

   275

	if (a != CT_INVALID) ac[a] = 8;

   276

   277

	a = _industry_section_accepts_3[gfx];

   278

	if (a != CT_INVALID) ac[a] = 8;

   279

}

   280

   281

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   282

{

   283

	const Industry *i = GetIndustryByTile(tile);

   284

   285

	td->owner = i->owner;

   286

	td->str = GetIndustrySpec(i->type)->name;

   287

	if (!IsIndustryCompleted(tile)) {

   288

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

   289

		td->str = STR_2058_UNDER_CONSTRUCTION;

   290

	}

   291

}

   292

   293

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   294

{

   295

	Industry *i = GetIndustryByTile(tile);

   296

   297

	/* water can destroy industries

   298

	 * in editor you can bulldoze industries

   299

	 * with magic_bulldozer cheat you can destroy industries

   300

	 * (area around OILRIG is water, so water shouldn't flood it

   301

	 */

   302

	if ((_current_player != OWNER_WATER && _game_mode != GM_EDITOR &&

   303

			!_cheats.magic_bulldozer.value) ||

   304

			(_current_player == OWNER_WATER && i->type == IT_OIL_RIG)) {

   305

		SetDParam(0, GetIndustrySpec(i->type)->name);

   306

		return_cmd_error(STR_4800_IN_THE_WAY);

   307

	}

   308

   309

	if (flags & DC_EXEC) DeleteIndustry(i);

   310

	return 0;

   311

}

   312

   313

static void TransportIndustryGoods(TileIndex tile)

   314

{

   315

	Industry *i = GetIndustryByTile(tile);

   316

	const IndustrySpec *indspec = GetIndustrySpec(i->type);

   317

	uint cw, am;

   318

   319

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

   320

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

   321

		i->cargo_waiting[0] -= cw;

   322

   323

		/* fluctuating economy? */

   324

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

   325

   326

		i->last_mo_production[0] += cw;

   327

   328

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

   329

		i->last_mo_transported[0] += am;

   330

		if (am != 0) {

   331

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   332

   333

			if (newgfx != 0xFF) {

   334

				ResetIndustryConstructionStage(tile);

   335

				SetIndustryCompleted(tile, true);

   336

				SetIndustryGfx(tile, newgfx);

   337

				MarkTileDirtyByTile(tile);

   338

			}

   339

		}

   340

	}

   341

   342

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

   343

	if (cw > indspec->minimal_cargo) {

   344

		i->cargo_waiting[1] -= cw;

   345

   346

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

   347

   348

		i->last_mo_production[1] += cw;

   349

   350

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

   351

		i->last_mo_transported[1] += am;

   352

	}

   353

}

   354

   355

   356

static void AnimateTile_Industry(TileIndex tile)

   357

{

   358

	byte m;

   359

   360

	switch (GetIndustryGfx(tile)) {

   361

	case GFX_SUGAR_MINE_SIEVE:

   362

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

   363

			m = _m[tile].m3 + 1;

   364

   365

			switch (m & 7) {

   366

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

   367

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

   368

			}

   369

   370

			if (m >= 96) {

   371

				m = 0;

   372

				DeleteAnimatedTile(tile);

   373

			}

   374

			_m[tile].m3 = m;

   375

   376

			MarkTileDirtyByTile(tile);

   377

		}

   378

		break;

   379

   380

	case GFX_TOFFEE_QUARY:

   381

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

   382

			m = _m[tile].m3;

   383

   384

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

   385

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   386

			}

   387

   388

			if (++m >= 70) {

   389

				m = 0;

   390

				DeleteAnimatedTile(tile);

   391

			}

   392

			_m[tile].m3 = m;

   393

   394

			MarkTileDirtyByTile(tile);

   395

		}

   396

		break;

   397

   398

	case GFX_BUBBLE_CATCHER:

   399

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

   400

			m = _m[tile].m3;

   401

   402

			if (++m >= 40) {

   403

				m = 0;

   404

				DeleteAnimatedTile(tile);

   405

			}

   406

			_m[tile].m3 = m;

   407

   408

			MarkTileDirtyByTile(tile);

   409

		}

   410

		break;

   411

   412

	// Sparks on a coal plant

   413

	case GFX_POWERPLANT_SPARKS:

   414

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

   415

			m = _m[tile].m1;

   416

			if (GB(m, 2, 5) == 6) {

   417

				SB(_m[tile].m1, 2, 5, 0);

   418

				DeleteAnimatedTile(tile);

   419

			} else {

   420

				_m[tile].m1 = m + (1<<2);

   421

				MarkTileDirtyByTile(tile);

   422

			}

   423

		}

   424

		break;

   425

   426

	case GFX_TOY_FACTORY:

   427

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

   428

			m = _m[tile].m3 + 1;

   429

   430

			if (m == 1) {

   431

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   432

			} else if (m == 23) {

   433

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   434

			} else if (m == 28) {

   435

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   436

			}

   437

   438

			if (m >= 50) {

   439

				int n = GetIndustryAnimationLoop(tile) + 1;

   440

				m = 0;

   441

				if (n >= 8) {

   442

					n = 0;

   443

					DeleteAnimatedTile(tile);

   444

				}

   445

				SetIndustryAnimationLoop(tile, n);

   446

			}

   447

			_m[tile].m3 = m;

   448

			MarkTileDirtyByTile(tile);

   449

		}

   450

		break;

   451

   452

	case 148: case 149: case 150: case 151:

   453

	case 152: case 153: case 154: case 155:

   454

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

   455

			IndustryGfx gfx = GetIndustryGfx(tile);

   456

   457

			gfx = (gfx < 155) ? gfx + 1 : 148;

   458

			SetIndustryGfx(tile, gfx);

   459

			MarkTileDirtyByTile(tile);

   460

		}

   461

		break;

   462

   463

	case GFX_OILWELL_ANIMATED_1:

   464

	case GFX_OILWELL_ANIMATED_2:

   465

	case GFX_OILWELL_ANIMATED_3:

   466

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

   467

			bool b = CHANCE16(1,7);

   468

			IndustryGfx gfx = GetIndustryGfx(tile);

   469

   470

			m = GB(_m[tile].m1, 0, 2) + 1;

   471

			if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {

   472

				_m[tile].m1 = 0x83;

   473

				SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);

   474

				DeleteAnimatedTile(tile);

   475

			} else {

   476

				SB(_m[tile].m1, 0, 2, m);

   477

				SetIndustryGfx(tile, gfx);

   478

				MarkTileDirtyByTile(tile);

   479

			}

   480

		}

   481

		break;

   482

   483

	case GFX_COAL_MINE_TOWER_ANIMATED:

   484

	case GFX_COPPER_MINE_TOWER_ANIMATED:

   485

	case GFX_GOLD_MINE_TOWER_ANIMATED: {

   486

			int state = _tick_counter & 0x7FF;

   487

   488

			if ((state -= 0x400) < 0)

   489

				return;

   490

   491

			if (state < 0x1A0) {

   492

				if (state < 0x20 || state >= 0x180) {

   493

					if (!(_m[tile].m1 & 0x40)) {

   494

						_m[tile].m1 |= 0x40;