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

static const IndustryType _industry_close_mode[IT_END] = {

    57

	/* COAL_MINE */          INDUSTRYLIFE_PRODUCTION,

    58

	/* POWER_STATION */      INDUSTRYLIFE_NOT_CLOSABLE,

    59

	/* SAWMILL */            INDUSTRYLIFE_CLOSABLE,

    60

	/* FOREST */             INDUSTRYLIFE_PRODUCTION,

    61

	/* OIL_REFINERY */       INDUSTRYLIFE_CLOSABLE,

    62

	/* OIL_RIG */            INDUSTRYLIFE_PRODUCTION,

    63

	/* FACTORY */            INDUSTRYLIFE_CLOSABLE,

    64

	/* PRINTING_WORKS */     INDUSTRYLIFE_CLOSABLE,

    65

	/* STEEL_MILL */         INDUSTRYLIFE_CLOSABLE,

    66

	/* FARM */               INDUSTRYLIFE_PRODUCTION,

    67

	/* COPPER_MINE */        INDUSTRYLIFE_PRODUCTION,

    68

	/* OIL_WELL */           INDUSTRYLIFE_PRODUCTION,

    69

	/* BANK */               INDUSTRYLIFE_NOT_CLOSABLE,

    70

	/* FOOD_PROCESS */       INDUSTRYLIFE_CLOSABLE,

    71

	/* PAPER_MILL */         INDUSTRYLIFE_CLOSABLE,

    72

	/* GOLD_MINE */          INDUSTRYLIFE_PRODUCTION,

    73

	/* BANK_2,  */           INDUSTRYLIFE_NOT_CLOSABLE,

    74

	/* DIAMOND_MINE */       INDUSTRYLIFE_PRODUCTION,

    75

	/* IRON_MINE */          INDUSTRYLIFE_PRODUCTION,

    76

	/* FRUIT_PLANTATION */   INDUSTRYLIFE_PRODUCTION,

    77

	/* RUBBER_PLANTATION */  INDUSTRYLIFE_PRODUCTION,

    78

	/* WATER_SUPPLY */       INDUSTRYLIFE_PRODUCTION,

    79

	/* WATER_TOWER */        INDUSTRYLIFE_NOT_CLOSABLE,

    80

	/* FACTORY_2 */          INDUSTRYLIFE_CLOSABLE,

    81

	/* FARM_2 */             INDUSTRYLIFE_PRODUCTION,

    82

	/* LUMBER_MILL */        INDUSTRYLIFE_CLOSABLE,

    83

	/* COTTON_CANDY */       INDUSTRYLIFE_PRODUCTION,

    84

	/* CANDY_FACTORY */      INDUSTRYLIFE_CLOSABLE,

    85

	/* BATTERY_FARM */       INDUSTRYLIFE_PRODUCTION,

    86

	/* COLA_WELLS */         INDUSTRYLIFE_PRODUCTION,

    87

	/* TOY_SHOP */           INDUSTRYLIFE_NOT_CLOSABLE,

    88

	/* TOY_FACTORY */        INDUSTRYLIFE_CLOSABLE,

    89

	/* PLASTIC_FOUNTAINS */  INDUSTRYLIFE_PRODUCTION,

    90

	/* FIZZY_DRINK_FACTORY */INDUSTRYLIFE_CLOSABLE,

    91

	/* BUBBLE_GENERATOR */   INDUSTRYLIFE_PRODUCTION,

    92

	/* TOFFEE_QUARRY */      INDUSTRYLIFE_PRODUCTION,

    93

	/* SUGAR_MINE */         INDUSTRYLIFE_PRODUCTION

    94

};

    95

    96

/**

    97

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

    98

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

    99

 * as would do GetIndustryGfx.

   100

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

   101

 * @param tile that is queried

   102

 * @pre IsTileType(tile, MP_INDUSTRY)

   103

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

   104

 **/

   105

IndustryType GetIndustryType(TileIndex tile)

   106

{

   107

	IndustryGfx this_type = GetIndustryGfx(tile);

   108

	IndustryType iloop;

   109

   110

	assert(IsTileType(tile, MP_INDUSTRY));

   111

   112

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

   113

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

   114

				industry_gfx_Solver[iloop].MaxGfx+1)) {

   115

			return iloop;

   116

		}

   117

	}

   118

   119

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

   120

}

   121

   122

/**

   123

 * Accessor for array _industry_specs.

   124

 * This will ensure at once : proper access and

   125

 * not allowing modifications of it.

   126

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

   127

 * @pre thistype < IT_END

   128

 **/

   129

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

   130

{

   131

	assert(thistype < IT_END);

   132

	return &_industry_specs[thistype];

   133

}

   134

   135

void DestroyIndustry(Industry *i)

   136

{

   137

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

   138

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

   139

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

   140

				DoClearSquare(tile_cur);

   141

			}

   142

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

   143

			DeleteOilRig(tile_cur);

   144

		}

   145

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

   146

   147

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

   148

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

   149

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

   150

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

   151

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

   152

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   153

			}

   154

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

   155

	}

   156

   157

	_industry_sort_dirty = true;

   158

	DeleteSubsidyWithIndustry(i->index);

   159

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   160

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   161

}

   162

   163

static void IndustryDrawSugarMine(const TileInfo *ti)

   164

{

   165

	const DrawIndustrySpec1Struct *d;

   166

	uint32 image;

   167

   168

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

   169

   170

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

   171

   172

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

   173

   174

	image = d->image_2;

   175

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

   176

   177

	image = d->image_3;

   178

	if (image != 0) {

   179

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1,

   180

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

   181

	}

   182

}

   183

   184

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   185

{

   186

	int x = 0;

   187

   188

	if (IsIndustryCompleted(ti->tile)) {

   189

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

   190

		if ( (byte)x == 0xFF)

   191

			x = 0;

   192

	}

   193

   194

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

   195

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, 6, 14);

   196

}

   197

   198

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   199

{

   200

	if (IsIndustryCompleted(ti->tile)) {

   201

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

   202

	} else {

   203

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, 3, 67);

   204

	}

   205

}

   206

   207

static void IndustryDrawToyFactory(const TileInfo *ti)

   208

{

   209

	const DrawIndustrySpec4Struct *d;

   210

   211

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

   212

   213

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

   214

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

   215

	}

   216

   217

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

   218

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

   219

	}

   220

   221

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

   222

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, 0, 42);

   223

}

   224

   225

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   226

{

   227

	if (IsIndustryCompleted(ti->tile)) {

   228

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

   229

   230

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

   231

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   232

				_coal_plant_sparks_x[image - 1],

   233

				_coal_plant_sparks_y[image - 1]

   234

			);

   235

		}

   236

	}

   237

}

   238

   239

typedef void IndustryDrawTileProc(const TileInfo *ti);

   240

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   241

	IndustryDrawSugarMine,

   242

	IndustryDrawToffeeQuarry,

   243

	IndustryDrawBubbleGenerator,

   244

	IndustryDrawToyFactory,

   245

	IndustryDrawCoalPlantSparks,

   246

};

   247

   248

static void DrawTile_Industry(TileInfo *ti)

   249

{

   250

	const Industry *ind;

   251

	const DrawBuildingsTileStruct *dits;

   252

	byte z;

   253

	uint32 image, ormod;

   254

   255

	/* Pointer to industry */

   256

	ind = GetIndustryByTile(ti->tile);

   257

	ormod = GENERAL_SPRITE_COLOR(ind->color_map);

   258

   259

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

   260

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

   261

   262

	image = dits->ground;

   263

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

   264

		image |= ormod;

   265

   266

	z = ti->z;

   267

	/* Add bricks below the industry? */

   268

	if (ti->tileh != SLOPE_FLAT) {

   269

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

   270

		AddChildSpriteScreen(image, 31, 1);

   271

		z += TILE_HEIGHT;

   272

	} else {

   273

		/* Else draw regular ground */

   274

		DrawGroundSprite(image);

   275

	}

   276

   277

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

   278

	image = dits->building;

   279

	if (image != 0) {

   280

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

   281

			image |= ormod;

   282

   283

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   284

   285

		AddSortableSpriteToDraw(image,

   286

			ti->x + dits->subtile_x,

   287

			ti->y + dits->subtile_y,

   288

			dits->width  + 1,

   289

			dits->height + 1,

   290

			dits->dz,

   291

			z);

   292

   293

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   294

	}

   295

   296

	{

   297

		int proc = dits->draw_proc - 1;

   298

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

   299

	}

   300

}

   301

   302

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

   303

{

   304

	return GetTileMaxZ(tile);

   305

}

   306

   307

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   308

{

   309

	return SLOPE_FLAT;

   310

}

   311

   312

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   313

{

   314

	IndustryGfx gfx = GetIndustryGfx(tile);

   315

	CargoID a;

   316

   317

	a = _industry_section_accepts_1[gfx];

   318

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

   319

   320

	a = _industry_section_accepts_2[gfx];

   321

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

   322

   323

	a = _industry_section_accepts_3[gfx];

   324

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

   325

}

   326

   327

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   328

{

   329

	const Industry *i = GetIndustryByTile(tile);

   330

   331

	td->owner = i->owner;

   332

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

   333

	if (!IsIndustryCompleted(tile)) {

   334

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

   335

		td->str = STR_2058_UNDER_CONSTRUCTION;

   336

	}

   337

}

   338

   339

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   340

{

   341

	Industry *i = GetIndustryByTile(tile);

   342

   343

	/* water can destroy industries

   344

	 * in editor you can bulldoze industries

   345

	 * with magic_bulldozer cheat you can destroy industries

   346

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

   347

	 */

   348

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

   349

			!_cheats.magic_bulldozer.value) ||

   350

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

   351

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

   352

		return_cmd_error(STR_4800_IN_THE_WAY);

   353

	}

   354

   355

	if (flags & DC_EXEC) DeleteIndustry(i);

   356

	return 0;

   357

}

   358

   359

static void TransportIndustryGoods(TileIndex tile)

   360

{

   361

	Industry *i = GetIndustryByTile(tile);

   362

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

   363

	uint cw, am;

   364

   365

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

   366

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

   367

		i->cargo_waiting[0] -= cw;

   368

   369

		/* fluctuating economy? */

   370

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

   371

   372

		i->last_mo_production[0] += cw;

   373

   374

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

   375

		i->last_mo_transported[0] += am;

   376

		if (am != 0) {

   377

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   378

   379

			if (newgfx != 0xFF) {

   380

				ResetIndustryConstructionStage(tile);

   381

				SetIndustryCompleted(tile, true);

   382

				SetIndustryGfx(tile, newgfx);

   383

				MarkTileDirtyByTile(tile);

   384

			}

   385

		}

   386

	}

   387

   388

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

   389

	if (cw > indspec->minimal_cargo) {

   390

		i->cargo_waiting[1] -= cw;

   391

   392

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

   393

   394

		i->last_mo_production[1] += cw;

   395

   396

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

   397

		i->last_mo_transported[1] += am;

   398

	}

   399

}

   400

   401

   402

static void AnimateTile_Industry(TileIndex tile)

   403

{

   404

	byte m;

   405

   406

	switch (GetIndustryGfx(tile)) {

   407

	case GFX_SUGAR_MINE_SIEVE:

   408

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

   409

			m = _m[tile].m3 + 1;

   410

   411

			switch (m & 7) {

   412

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

   413

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

   414

			}

   415

   416

			if (m >= 96) {

   417

				m = 0;

   418

				DeleteAnimatedTile(tile);

   419

			}

   420

			_m[tile].m3 = m;

   421

   422

			MarkTileDirtyByTile(tile);

   423

		}

   424

		break;

   425

   426

	case GFX_TOFFEE_QUARY:

   427

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

   428

			m = _m[tile].m3;

   429

   430

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

   431

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   432

			}

   433

   434

			if (++m >= 70) {

   435

				m = 0;

   436

				DeleteAnimatedTile(tile);

   437

			}

   438

			_m[tile].m3 = m;

   439

   440

			MarkTileDirtyByTile(tile);

   441

		}

   442

		break;

   443

   444

	case GFX_BUBBLE_CATCHER:

   445

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

   446

			m = _m[tile].m3;

   447

   448

			if (++m >= 40) {

   449

				m = 0;

   450

				DeleteAnimatedTile(tile);

   451

			}

   452

			_m[tile].m3 = m;

   453

   454

			MarkTileDirtyByTile(tile);

   455

		}

   456

		break;

   457

   458

	// Sparks on a coal plant

   459

	case GFX_POWERPLANT_SPARKS:

   460

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

   461

			m = _m[tile].m1;

   462

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

   463

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

   464

				DeleteAnimatedTile(tile);

   465

			} else {

   466

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

   467

				MarkTileDirtyByTile(tile);

   468

			}

   469

		}

   470

		break;

   471

   472

	case GFX_TOY_FACTORY:

   473

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

   474

			m = _m[tile].m3 + 1;

   475

   476

			if (m == 1) {

   477

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   478

			} else if (m == 23) {

   479

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   480

			} else if (m == 28) {

   481

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   482

			}

   483

   484

			if (m >= 50) {

   485

				int n = GetIndustryAnimationLoop(tile) + 1;

   486

				m = 0;

   487

				if (n >= 8) {

   488

					n = 0;

   489

					DeleteAnimatedTile(tile);

   490

				}

   491

				SetIndustryAnimationLoop(tile, n);

   492

			}

   493

			_m[tile].m3 = m;

   494

			MarkTileDirtyByTile(tile);