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

enum {

    36

	/* Max industries: 64000 (8 * 8000) */

    37

	INDUSTRY_POOL_BLOCK_SIZE_BITS = 3,       /* In bits, so (1 << 3) == 8 */

    38

	INDUSTRY_POOL_MAX_BLOCKS      = 8000,

    39

};

    40

    41

/**

    42

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

    43

 */

    44

static void IndustryPoolNewBlock(uint start_item)

    45

{

    46

	Industry *i;

    47

    48

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

    49

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

    50

	for (i = GetIndustry(start_item); i != NULL; i = (i->index + 1 < GetIndustryPoolSize()) ? GetIndustry(i->index + 1) : NULL) i->index = start_item++;

    51

}

    52

    53

/* Initialize the industry-pool */

    54

MemoryPool _industry_pool = { "Industry", INDUSTRY_POOL_MAX_BLOCKS, INDUSTRY_POOL_BLOCK_SIZE_BITS, sizeof(Industry), &IndustryPoolNewBlock, NULL, 0, 0, NULL };

    55

    56

/**

    57

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

    58

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

    59

 * as would do GetIndustryGfx.

    60

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

    61

 * @param tile that is queried

    62

 * @pre IsTileType(tile, MP_INDUSTRY)

    63

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

    64

 **/

    65

IndustryType GetIndustryType(TileIndex tile)

    66

{

    67

	IndustryGfx this_type = GetIndustryGfx(tile);

    68

	IndustryType iloop;

    69

    70

	assert(IsTileType(tile, MP_INDUSTRY));

    71

    72

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

    73

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

    74

				industry_gfx_Solver[iloop].MaxGfx+1)) {

    75

			return iloop;

    76

		}

    77

	}

    78

    79

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

    80

}

    81

    82

/**

    83

 * Accessor for array _industry_specs.

    84

 * This will ensure at once : proper access and

    85

 * not allowing modifications of it.

    86

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

    87

 * @pre thistype < IT_END

    88

 **/

    89

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    90

{

    91

	assert(thistype < IT_END);

    92

	return &_industry_specs[thistype];

    93

}

    94

    95

void DestroyIndustry(Industry *i)

    96

{

    97

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

    98

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

    99

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

   100

				DoClearSquare(tile_cur);

   101

			}

   102

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

   103

			DeleteOilRig(tile_cur);

   104

		}

   105

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

   106

   107

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

   108

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

   109

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

   110

			tile_cur = TILE_MASK(tile_cur);

   111

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

   112

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

   113

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   114

			}

   115

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

   116

	}

   117

   118

	_industry_sort_dirty = true;

   119

	DeleteSubsidyWithIndustry(i->index);

   120

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   121

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   122

}

   123

   124

static void IndustryDrawSugarMine(const TileInfo *ti)

   125

{

   126

	const DrawIndustrySpec1Struct *d;

   127

	uint32 image;

   128

   129

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

   130

   131

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

   132

   133

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

   134

   135

	image = d->image_2;

   136

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

   137

   138

	image = d->image_3;

   139

	if (image != 0) {

   140

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1,

   141

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

   142

	}

   143

}

   144

   145

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   146

{

   147

	int x = 0;

   148

   149

	if (IsIndustryCompleted(ti->tile)) {

   150

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

   151

		if ( (byte)x == 0xFF)

   152

			x = 0;

   153

	}

   154

   155

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

   156

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, 6, 14);

   157

}

   158

   159

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   160

{

   161

	if (IsIndustryCompleted(ti->tile)) {

   162

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

   163

	} else {

   164

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, 3, 67);

   165

	}

   166

}

   167

   168

static void IndustryDrawToyFactory(const TileInfo *ti)

   169

{

   170

	const DrawIndustrySpec4Struct *d;

   171

   172

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

   173

   174

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

   175

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

   176

	}

   177

   178

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

   179

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

   180

	}

   181

   182

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

   183

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, 0, 42);

   184

}

   185

   186

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   187

{

   188

	if (IsIndustryCompleted(ti->tile)) {

   189

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

   190

   191

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

   192

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   193

				_coal_plant_sparks_x[image - 1],

   194

				_coal_plant_sparks_y[image - 1]

   195

			);

   196

		}

   197

	}

   198

}

   199

   200

typedef void IndustryDrawTileProc(const TileInfo *ti);

   201

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   202

	IndustryDrawSugarMine,

   203

	IndustryDrawToffeeQuarry,

   204

	IndustryDrawBubbleGenerator,

   205

	IndustryDrawToyFactory,

   206

	IndustryDrawCoalPlantSparks,

   207

};

   208

   209

static void DrawTile_Industry(TileInfo *ti)

   210

{

   211

	const Industry *ind;

   212

	const DrawBuildingsTileStruct *dits;

   213

	byte z;

   214

	uint32 image, ormod;

   215

   216

	/* Pointer to industry */

   217

	ind = GetIndustryByTile(ti->tile);

   219

   220

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

   221

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

   222

   223

	image = dits->ground;

   224

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

   225

		image |= ormod;

   226

   227

	z = ti->z;

   228

	/* Add bricks below the industry? */

   229

	if (ti->tileh != SLOPE_FLAT) {

   230

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

   231

		AddChildSpriteScreen(image, 31, 1);

   232

		z += TILE_HEIGHT;

   233

	} else {

   234

		/* Else draw regular ground */

   235

		DrawGroundSprite(image);

   236

	}

   237

   238

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

   239

	image = dits->building;

   240

	if (image != 0) {

   241

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

   242

			image |= ormod;

   243

   244

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   245

   246

		AddSortableSpriteToDraw(image,

   247

			ti->x + dits->subtile_x,

   248

			ti->y + dits->subtile_y,

   249

			dits->width  + 1,

   250

			dits->height + 1,

   251

			dits->dz,

   252

			z);

   253

   254

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   255

	}

   256

   257

	{

   258

		int proc = dits->draw_proc - 1;

   259

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

   260

	}

   261

}

   262

   263

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

   264

{

   265

	return GetTileMaxZ(tile);

   266

}

   267

   268

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   269

{

   270

	return SLOPE_FLAT;

   271

}

   272

   273

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   274

{

   275

	IndustryGfx gfx = GetIndustryGfx(tile);

   276

	CargoID a;

   277

   278

	a = _industry_section_accepts_1[gfx];

   279

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

   280

   281

	a = _industry_section_accepts_2[gfx];

   282

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

   283

   284

	a = _industry_section_accepts_3[gfx];

   285

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

   286

}

   287

   288

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   289

{

   290

	const Industry *i = GetIndustryByTile(tile);

   291

   292

	td->owner = i->owner;

   294

	if (!IsIndustryCompleted(tile)) {

   295

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

   296

		td->str = STR_2058_UNDER_CONSTRUCTION;

   297

	}

   298

}

   299

   300

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   301

{

   302

	Industry *i = GetIndustryByTile(tile);

   303

   304

	/* water can destroy industries

   305

	 * in editor you can bulldoze industries

   306

	 * with magic_bulldozer cheat you can destroy industries

   307

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

   308

	 */

   309

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

   310

			!_cheats.magic_bulldozer.value) ||

   311

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

   313

		return_cmd_error(STR_4800_IN_THE_WAY);

   314

	}

   315

   316

	if (flags & DC_EXEC) DeleteIndustry(i);

   317

	return 0;

   318

}

   319

   320

static void TransportIndustryGoods(TileIndex tile)

   321

{

   322

	Industry *i = GetIndustryByTile(tile);

   323

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

   324

	uint cw, am;

   325

   326

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

   327

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

   328

		i->cargo_waiting[0] -= cw;

   329

   330

		/* fluctuating economy? */

   331

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

   332

   333

		i->last_mo_production[0] += cw;

   334

   335

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

   336

		i->last_mo_transported[0] += am;

   337

		if (am != 0) {

   338

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   339

   340

			if (newgfx != 0xFF) {

   341

				ResetIndustryConstructionStage(tile);

   342

				SetIndustryCompleted(tile, true);

   343

				SetIndustryGfx(tile, newgfx);

   344

				MarkTileDirtyByTile(tile);

   345

			}

   346

		}

   347

	}

   348

   349

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

   350

	if (cw > indspec->minimal_cargo) {

   351

		i->cargo_waiting[1] -= cw;

   352

   353

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

   354

   355

		i->last_mo_production[1] += cw;

   356

   357

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

   358

		i->last_mo_transported[1] += am;

   359

	}

   360

}

   361

   362

   363

static void AnimateTile_Industry(TileIndex tile)

   364

{

   365

	byte m;

   366

   367

	switch (GetIndustryGfx(tile)) {

   368

	case GFX_SUGAR_MINE_SIEVE:

   369

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

   370

			m = _m[tile].m3 + 1;

   371

   372

			switch (m & 7) {

   373

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

   374

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

   375

			}

   376

   377

			if (m >= 96) {

   378

				m = 0;

   379

				DeleteAnimatedTile(tile);

   380

			}

   381

			_m[tile].m3 = m;

   382

   383

			MarkTileDirtyByTile(tile);

   384

		}

   385

		break;

   386

   387

	case GFX_TOFFEE_QUARY:

   388

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

   389

			m = _m[tile].m3;

   390

   391

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

   392

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   393

			}

   394

   395

			if (++m >= 70) {

   396

				m = 0;

   397

				DeleteAnimatedTile(tile);

   398

			}

   399

			_m[tile].m3 = m;

   400

   401

			MarkTileDirtyByTile(tile);

   402

		}

   403

		break;

   404

   405

	case GFX_BUBBLE_CATCHER:

   406

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

   407

			m = _m[tile].m3;

   408

   409

			if (++m >= 40) {

   410

				m = 0;

   411

				DeleteAnimatedTile(tile);

   412

			}

   413

			_m[tile].m3 = m;

   414

   415

			MarkTileDirtyByTile(tile);

   416

		}

   417

		break;

   418

   419

	// Sparks on a coal plant

   420

	case GFX_POWERPLANT_SPARKS:

   421

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

   422

			m = _m[tile].m1;

   423

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

   424

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

   425

				DeleteAnimatedTile(tile);

   426

			} else {

   427

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

   428

				MarkTileDirtyByTile(tile);

   429

			}

   430

		}

   431

		break;

   432

   433

	case GFX_TOY_FACTORY:

   434

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

   435

			m = _m[tile].m3 + 1;

   436

   437

			if (m == 1) {

   438

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   439

			} else if (m == 23) {

   440

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   441

			} else if (m == 28) {

   442

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   443

			}

   444

   445

			if (m >= 50) {

   446

				int n = GetIndustryAnimationLoop(tile) + 1;

   447

				m = 0;

   448

				if (n >= 8) {

   449

					n = 0;

   450

					DeleteAnimatedTile(tile);

   451

				}

   452

				SetIndustryAnimationLoop(tile, n);

   453

			}

   454

			_m[tile].m3 = m;

   455

			MarkTileDirtyByTile(tile);

   456

		}

   457

		break;

   458

   459

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

   460

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

   461

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

   462

			IndustryGfx gfx = GetIndustryGfx(tile);

   463

   464

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

   465

			SetIndustryGfx(tile, gfx);

   466

			MarkTileDirtyByTile(tile);

   467

		}

   468

		break;

   469

   470

	case GFX_OILWELL_ANIMATED_1:

   471

	case GFX_OILWELL_ANIMATED_2:

   472

	case GFX_OILWELL_ANIMATED_3:

   473

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

   474

			bool b = CHANCE16(1,7);

   475

			IndustryGfx gfx = GetIndustryGfx(tile);

   476

   477

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

   478

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

   479

				_m[tile].m1 = 0x83;

   480

				SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);

   481

				DeleteAnimatedTile(tile);

   482

			} else {

   483

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

   484

				SetIndustryGfx(tile, gfx);

   485

				MarkTileDirtyByTile(tile);

   486

			}

   487

		}

   488

		break;

   489

   490

	case GFX_COAL_MINE_TOWER_ANIMATED:

   491

	case GFX_COPPER_MINE_TOWER_ANIMATED:

   492

	case GFX_GOLD_MINE_TOWER_ANIMATED: {

   493

			int state = _tick_counter & 0x7FF;

   494