1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "clear_map.h"

     6

#include "industry_map.h"

     7

#include "station_map.h"

     8

#include "table/strings.h"

     9

#include "table/sprites.h"

    10

#include "functions.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

enum {

    29

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

    30

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

    31

	INDUSTRY_POOL_MAX_BLOCKS      = 8000,

    32

};

    33

    34

/**

    35

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

    36

 */

    37

static void IndustryPoolNewBlock(uint start_item)

    38

{

    39

	Industry *i;

    40

    41

	FOR_ALL_INDUSTRIES_FROM(i, start_item) i->index = start_item++;

    42

}

    43

    44

/* Initialize the industry-pool */

    45

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

    46

    47

static byte _industry_sound_ctr;

    48

static TileIndex _industry_sound_tile;

    49

    50

void ShowIndustryViewWindow(int industry);

    51

void BuildOilRig(TileIndex tile);

    52

void DeleteOilRig(TileIndex tile);

    53

    54

static const IndustryType _industry_close_mode[IT_END] = {

    55

	/* COAL_MINE */          INDUSTRYLIFE_PRODUCTION,

    56

	/* POWER_STATION */      INDUSTRYLIFE_NOT_CLOSABLE,

    57

	/* SAWMILL */            INDUSTRYLIFE_CLOSABLE,

    58

	/* FOREST */             INDUSTRYLIFE_PRODUCTION,

    59

	/* OIL_REFINERY */       INDUSTRYLIFE_CLOSABLE,

    60

	/* OIL_RIG */            INDUSTRYLIFE_PRODUCTION,

    61

	/* FACTORY */            INDUSTRYLIFE_CLOSABLE,

    62

	/* PRINTING_WORKS */     INDUSTRYLIFE_CLOSABLE,

    63

	/* STEEL_MILL */         INDUSTRYLIFE_CLOSABLE,

    64

	/* FARM */               INDUSTRYLIFE_PRODUCTION,

    65

	/* COPPER_MINE */        INDUSTRYLIFE_PRODUCTION,

    66

	/* OIL_WELL */           INDUSTRYLIFE_PRODUCTION,

    67

	/* BANK */               INDUSTRYLIFE_NOT_CLOSABLE,

    68

	/* FOOD_PROCESS */       INDUSTRYLIFE_CLOSABLE,

    69

	/* PAPER_MILL */         INDUSTRYLIFE_CLOSABLE,

    70

	/* GOLD_MINE */          INDUSTRYLIFE_PRODUCTION,

    71

	/* BANK_2,  */           INDUSTRYLIFE_NOT_CLOSABLE,

    72

	/* DIAMOND_MINE */       INDUSTRYLIFE_PRODUCTION,

    73

	/* IRON_MINE */          INDUSTRYLIFE_PRODUCTION,

    74

	/* FRUIT_PLANTATION */   INDUSTRYLIFE_PRODUCTION,

    75

	/* RUBBER_PLANTATION */  INDUSTRYLIFE_PRODUCTION,

    76

	/* WATER_SUPPLY */       INDUSTRYLIFE_PRODUCTION,

    77

	/* WATER_TOWER */        INDUSTRYLIFE_NOT_CLOSABLE,

    78

	/* FACTORY_2 */          INDUSTRYLIFE_CLOSABLE,

    79

	/* FARM_2 */             INDUSTRYLIFE_PRODUCTION,

    80

	/* LUMBER_MILL */        INDUSTRYLIFE_CLOSABLE,

    81

	/* COTTON_CANDY */       INDUSTRYLIFE_PRODUCTION,

    82

	/* CANDY_FACTORY */      INDUSTRYLIFE_CLOSABLE,

    83

	/* BATTERY_FARM */       INDUSTRYLIFE_PRODUCTION,

    84

	/* COLA_WELLS */         INDUSTRYLIFE_PRODUCTION,

    85

	/* TOY_SHOP */           INDUSTRYLIFE_NOT_CLOSABLE,

    86

	/* TOY_FACTORY */        INDUSTRYLIFE_CLOSABLE,

    87

	/* PLASTIC_FOUNTAINS */  INDUSTRYLIFE_PRODUCTION,

    88

	/* FIZZY_DRINK_FACTORY */INDUSTRYLIFE_CLOSABLE,

    89

	/* BUBBLE_GENERATOR */   INDUSTRYLIFE_PRODUCTION,

    90

	/* TOFFEE_QUARRY */      INDUSTRYLIFE_PRODUCTION,

    91

	/* SUGAR_MINE */         INDUSTRYLIFE_PRODUCTION

    92

};

    93

    94

/**

    95

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

    96

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

    97

 * as would do GetIndustryGfx.

    98

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

    99

 * @param tile that is queried

   100

 * @pre IsTileType(tile, MP_INDUSTRY)

   101

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

   102

 **/

   103

IndustryType GetIndustryType(TileIndex tile)

   104

{

   105

	IndustryGfx this_type = GetIndustryGfx(tile);

   106

	IndustryType iloop;

   107

   108

	assert(IsTileType(tile, MP_INDUSTRY));

   109

   110

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

   111

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

   112

				industry_gfx_Solver[iloop].MaxGfx+1)) {

   113

			return iloop;

   114

		}

   115

	}

   116

   117

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

   118

}

   119

   120

/**

   121

 * Accessor for array _industry_specs.

   122

 * This will ensure at once : proper access and

   123

 * not allowing modifications of it.

   124

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

   125

 * @pre thistype < IT_END

   126

 **/

   127

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

   128

{

   129

	assert(thistype < IT_END);

   130

	return &_industry_specs[thistype];

   131

}

   132

   133

static void IndustryDrawSugarMine(const TileInfo *ti)

   134

{

   135

	const DrawIndustrySpec1Struct *d;

   136

	uint32 image;

   137

   138

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

   139

   140

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

   141

   142

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

   143

   144

	image = d->image_2;

   145

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

   146

   147

	image = d->image_3;

   148

	if (image != 0) {

   149

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1,

   150

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

   151

	}

   152

}

   153

   154

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   155

{

   156

	int x = 0;

   157

   158

	if (IsIndustryCompleted(ti->tile)) {

   159

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

   160

		if ( (byte)x == 0xFF)

   161

			x = 0;

   162

	}

   163

   164

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

   165

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, 6, 14);

   166

}

   167

   168

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   169

{

   170

	if (IsIndustryCompleted(ti->tile)) {

   171

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

   172

	} else {

   173

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, 3, 67);

   174

	}

   175

}

   176

   177

static void IndustryDrawToyFactory(const TileInfo *ti)

   178

{

   179

	const DrawIndustrySpec4Struct *d;

   180

   181

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

   182

   183

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

   184

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

   185

	}

   186

   187

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

   188

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

   189

	}

   190

   191

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

   192

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, 0, 42);

   193

}

   194

   195

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   196

{

   197

	if (IsIndustryCompleted(ti->tile)) {

   198

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

   199

   200

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

   201

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   202

				_coal_plant_sparks_x[image - 1],

   203

				_coal_plant_sparks_y[image - 1]

   204

			);

   205

		}

   206

	}

   207

}

   208

   209

typedef void IndustryDrawTileProc(const TileInfo *ti);

   210

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   211

	IndustryDrawSugarMine,

   212

	IndustryDrawToffeeQuarry,

   213

	IndustryDrawBubbleGenerator,

   214

	IndustryDrawToyFactory,

   215

	IndustryDrawCoalPlantSparks,

   216

};

   217

   218

static void DrawTile_Industry(TileInfo *ti)

   219

{

   220

	const Industry *ind;

   221

	const DrawBuildingsTileStruct *dits;

   222

	byte z;

   223

	uint32 image, ormod;

   224

   225

	/* Pointer to industry */

   226

	ind = GetIndustryByTile(ti->tile);

   227

	ormod = GENERAL_SPRITE_COLOR(ind->color_map);

   228

   229

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

   230

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

   231

   232

	image = dits->ground;

   233

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

   234

		image |= ormod;

   235

   236

	z = ti->z;

   237

	/* Add bricks below the industry? */

   238

	if (ti->tileh != SLOPE_FLAT) {

   239

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

   240

		AddChildSpriteScreen(image, 31, 1);

   241

		z += TILE_HEIGHT;

   242

	} else {

   243

		/* Else draw regular ground */

   244

		DrawGroundSprite(image);

   245

	}

   246

   247

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

   248

	image = dits->building;

   249

	if (image != 0) {

   250

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

   251

			image |= ormod;

   252

   253

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   254

   255

		AddSortableSpriteToDraw(image,

   256

			ti->x + dits->subtile_x,

   257

			ti->y + dits->subtile_y,

   258

			dits->width  + 1,

   259

			dits->height + 1,

   260

			dits->dz,

   261

			z);

   262

   263

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   264

	}

   265

   266

	{

   267

		int proc = dits->draw_proc - 1;

   268

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

   269

	}

   270

}

   271

   272

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

   273

{

   274

	return GetTileMaxZ(tile);

   275

}

   276

   277

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   278

{

   279

	return SLOPE_FLAT;

   280

}

   281

   282

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   283

{

   284

	IndustryGfx gfx = GetIndustryGfx(tile);

   285

	CargoID a;

   286

   287

	a = _industry_section_accepts_1[gfx];

   288

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

   289

   290

	a = _industry_section_accepts_2[gfx];

   291

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

   292

   293

	a = _industry_section_accepts_3[gfx];

   294

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

   295

}

   296

   297

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   298

{

   299

	const Industry *i = GetIndustryByTile(tile);

   300

   301

	td->owner = i->owner;

   302

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

   303

	if (!IsIndustryCompleted(tile)) {

   304

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

   305

		td->str = STR_2058_UNDER_CONSTRUCTION;

   306

	}

   307

}

   308

   309

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   310

{

   311

	Industry *i = GetIndustryByTile(tile);

   312

   313

	/*	* water can destroy industries

   314

			* in editor you can bulldoze industries

   315

			* with magic_bulldozer cheat you can destroy industries

   316

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

   317

	*/

   318

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

   319

			!_cheats.magic_bulldozer.value) ||

   320

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

   321

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

   322

		return_cmd_error(STR_4800_IN_THE_WAY);

   323

	}

   324

   325

	if (flags & DC_EXEC) DeleteIndustry(i);

   326

	return 0;

   327

}

   328

   329

static void TransportIndustryGoods(TileIndex tile)

   330

{

   331

	Industry *i = GetIndustryByTile(tile);

   332

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

   333

	uint cw, am;

   334

   335

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

   336

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

   337

		i->cargo_waiting[0] -= cw;

   338

   339

		/* fluctuating economy? */

   340

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

   341

   342

		i->last_mo_production[0] += cw;

   343

   344

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

   345

		i->last_mo_transported[0] += am;

   346

		if (am != 0) {

   347

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   348

   349

			if (newgfx != 0xFF) {

   350

				ResetIndustryConstructionStage(tile);

   351

				SetIndustryCompleted(tile, true);

   352

				SetIndustryGfx(tile, newgfx);

   353

				MarkTileDirtyByTile(tile);

   354

			}

   355

		}

   356

	}

   357

   358

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

   359

	if (cw > indspec->minimal_cargo) {

   360

		i->cargo_waiting[1] -= cw;

   361

   362

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

   363

   364

		i->last_mo_production[1] += cw;

   365

   366

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

   367

		i->last_mo_transported[1] += am;

   368

	}

   369

}

   370

   371

   372

static void AnimateTile_Industry(TileIndex tile)

   373

{

   374

	byte m;

   375

   376

	switch (GetIndustryGfx(tile)) {

   377

	case GFX_SUGAR_MINE_SIEVE:

   378

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

   379

			m = _m[tile].m3 + 1;

   380

   381

			switch (m & 7) {

   382

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

   383

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

   384

			}

   385

   386

			if (m >= 96) {

   387

				m = 0;

   388

				DeleteAnimatedTile(tile);

   389

			}

   390

			_m[tile].m3 = m;

   391

   392

			MarkTileDirtyByTile(tile);

   393

		}

   394

		break;

   395

   396

	case GFX_TOFFEE_QUARY:

   397

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

   398

			m = _m[tile].m3;

   399

   400

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

   401

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   402

			}

   403

   404

			if (++m >= 70) {

   405

				m = 0;

   406

				DeleteAnimatedTile(tile);

   407

			}

   408

			_m[tile].m3 = m;

   409

   410

			MarkTileDirtyByTile(tile);

   411

		}

   412

		break;

   413

   414

	case GFX_BUBBLE_CATCHER:

   415

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

   416

			m = _m[tile].m3;

   417

   418

			if (++m >= 40) {

   419

				m = 0;

   420

				DeleteAnimatedTile(tile);

   421

			}

   422

			_m[tile].m3 = m;

   423

   424

			MarkTileDirtyByTile(tile);

   425

		}

   426

		break;

   427

   428

	// Sparks on a coal plant

   429

	case GFX_POWERPLANT_SPARKS:

   430

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

   431

			m = _m[tile].m1;

   432

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

   433

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

   434

				DeleteAnimatedTile(tile);

   435

			} else {

   436

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

   437

				MarkTileDirtyByTile(tile);

   438

			}

   439

		}

   440

		break;

   441

   442

	case GFX_TOY_FACTORY:

   443

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

   444

			m = _m[tile].m3 + 1;

   445

   446

			if (m == 1) {

   447

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   448

			} else if (m == 23) {

   449

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   450

			} else if (m == 28) {

   451

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   452

			}

   453

   454

			if (m >= 50) {

   455

				int n = GetIndustryAnimationLoop(tile) + 1;

   456

				m = 0;

   457

				if (n >= 8) {

   458

					n = 0;

   459

					DeleteAnimatedTile(tile);

   460

				}

   461

				SetIndustryAnimationLoop(tile, n);

   462

			}

   463

			_m[tile].m3 = m;

   464

			MarkTileDirtyByTile(tile);

   465

		}

   466

		break;

   467

   468

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

   469

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

   470

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

   471

			IndustryGfx gfx = GetIndustryGfx(tile);

   472

   473

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

   474

			SetIndustryGfx(tile, gfx);

   475

			MarkTileDirtyByTile(tile);

   476

		}

   477

		break;

   478

   479

	case GFX_OILWELL_ANIM1:

   480

	case GFX_OILWELL_ANIM2:

   481

	case GFX_OILWELL_ANIM3:

   482

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

   483

			bool b = CHANCE16(1,7);

   484

			IndustryGfx gfx = GetIndustryGfx(tile);

   485

   486

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

   487

			if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIM3 + 1 && (gfx = GFX_OILWELL_ANIM1, b)) {

   488

				_m[tile].m1 = 0x83;

   489

				SetIndustryGfx(tile, GFX_OILWELL_BASE);

   490

				DeleteAnimatedTile(tile);

   491

			} else {

   492

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

   493

				SetIndustryGfx(tile, gfx);

   494

				MarkTileDirtyByTile(tile);