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

#include "water_map.h"

    28

    29

void ShowIndustryViewWindow(int industry);

    30

void BuildOilRig(TileIndex tile);

    31

void DeleteOilRig(TileIndex tile);

    32

    33

static byte _industry_sound_ctr;

    34

static TileIndex _industry_sound_tile;

    35

    36

/**

    37

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

    38

 */

    39

static void IndustryPoolNewBlock(uint start_item)

    40

{

    41

	Industry *i;

    42

    43

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

    44

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

    45

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

    46

}

    47

    48

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

    49

    50

/**

    51

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

    52

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

    53

 * as would do GetIndustryGfx.

    54

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

    55

 * @param tile that is queried

    56

 * @pre IsTileType(tile, MP_INDUSTRY)

    57

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

    58

 **/

    59

IndustryType GetIndustryType(TileIndex tile)

    60

{

    61

	IndustryGfx this_type = GetIndustryGfx(tile);

    62

	IndustryType iloop;

    63

    64

	assert(IsTileType(tile, MP_INDUSTRY));

    65

    66

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

    67

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

    68

				industry_gfx_Solver[iloop].MaxGfx+1)) {

    69

			return iloop;

    70

		}

    71

	}

    72

    73

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

    74

}

    75

    76

/**

    77

 * Accessor for array _industry_specs.

    78

 * This will ensure at once : proper access and

    79

 * not allowing modifications of it.

    80

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

    81

 * @pre thistype < IT_END

    82

 **/

    83

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    84

{

    85

	assert(thistype < IT_END);

    86

	return &_industry_specs[thistype];

    87

}

    88

    89

void DestroyIndustry(Industry *i)

    90

{

    91

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

    92

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

    93

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

    94

				DoClearSquare(tile_cur);

    95

			}

    96

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

    97

			DeleteOilRig(tile_cur);

    98

		}

    99

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

   100

   101

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

   102

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

   103

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

   104

			tile_cur = TILE_MASK(tile_cur);

   105

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

   106

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

   107

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   108

			}

   109

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

   110

	}

   111

   112

	_industry_sort_dirty = true;

   113

	_total_industries--;

   114

	DeleteSubsidyWithIndustry(i->index);

   115

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   116

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   117

}

   118

   119

static void IndustryDrawSugarMine(const TileInfo *ti)

   120

{

   121

	const DrawIndustrySpec1Struct *d;

   122

	uint32 image;

   123

   124

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

   125

   126

	d = &_draw_industry_spec1[GetIndustryAnimationState(ti->tile)];

   127

   128

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

   129

   130

	image = d->image_2;

   131

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

   132

   133

	image = d->image_3;

   134

	if (image != 0) {

   135

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1,

   136

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

   137

	}

   138

}

   139

   140

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   141

{

   142

	int x = 0;

   143

   144

	if (IsIndustryCompleted(ti->tile)) {

   145

		x = _industry_anim_offs[GetIndustryAnimationState(ti->tile)];

   146

		if ( (byte)x == 0xFF)

   147

			x = 0;

   148

	}

   149

   150

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

   151

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, 6, 14);

   152

}

   153

   154

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   155

{

   156

	if (IsIndustryCompleted(ti->tile)) {

   157

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_BUBBLE, 5, _industry_anim_offs_2[GetIndustryAnimationState(ti->tile)]);

   158

	} else {

   159

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, 3, 67);

   160

	}

   161

}

   162

   163

static void IndustryDrawToyFactory(const TileInfo *ti)

   164

{

   165

	const DrawIndustrySpec4Struct *d;

   166

   167

	d = &_industry_anim_offs_3[GetIndustryAnimationState(ti->tile)];

   168

   169

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

   170

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

   171

	}

   172

   173

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

   174

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

   175

	}

   176

   177

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

   178

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, 0, 42);

   179

}

   180

   181

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   182

{

   183

	if (IsIndustryCompleted(ti->tile)) {

   184

		uint image = GetIndustryAnimationState(ti->tile);

   185

   186

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

   187

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   188

				_coal_plant_sparks_x[image - 1],

   189

				_coal_plant_sparks_y[image - 1]

   190

			);

   191

		}

   192

	}

   193

}

   194

   195

typedef void IndustryDrawTileProc(const TileInfo *ti);

   196

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   197

	IndustryDrawSugarMine,

   198

	IndustryDrawToffeeQuarry,

   199

	IndustryDrawBubbleGenerator,

   200

	IndustryDrawToyFactory,

   201

	IndustryDrawCoalPlantSparks,

   202

};

   203

   204

static void DrawTile_Industry(TileInfo *ti)

   205

{

   206

	const IndustryGfx gfx = GetIndustryGfx(ti->tile);

   207

	const Industry *ind;

   208

	const DrawBuildingsTileStruct *dits;

   209

	byte z;

   210

	uint32 image, ormod;

   211

   212

	/* Pointer to industry */

   213

	ind = GetIndustryByTile(ti->tile);

   214

	ormod = GENERAL_SPRITE_COLOR(ind->random_color);

   215

   216

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

   217

	dits = &_industry_draw_tile_data[gfx << 2 | (_industry_section_draw_animation_state[gfx] ?

   218

			GetIndustryAnimationState(ti->tile) & 3 :

   219

			GetIndustryConstructionStage(ti->tile))];

   220

   221

	image = dits->ground;

   222

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

   223

		image |= ormod;

   224

   225

	z = ti->z;

   226

	/* Add bricks below the industry? */

   227

	if (ti->tileh != SLOPE_FLAT) {

   228

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

   229

		AddChildSpriteScreen(image, 31, 1);

   230

		z += TILE_HEIGHT;

   231

	} else {

   232

		/* Else draw regular ground */

   233

		DrawGroundSprite(image);

   234

	}

   235

   236

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

   237

	image = dits->building;

   238

	if (image != 0) {

   239

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

   240

			image |= ormod;

   241

   242

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

   243

   244

		AddSortableSpriteToDraw(image,

   245

			ti->x + dits->subtile_x,

   246

			ti->y + dits->subtile_y,

   247

			dits->width  + 1,

   248

			dits->height + 1,

   249

			dits->dz,

   250

			z);

   251

   252

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   253

	}

   254

   255

	{

   256

		int proc = dits->draw_proc - 1;

   257

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

   258

	}

   259

}

   260

   261

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

   262

{

   263

	return GetTileMaxZ(tile);

   264

}

   265

   266

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   267

{

   268

	return SLOPE_FLAT;

   269

}

   270

   271

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   272

{

   273

	IndustryGfx gfx = GetIndustryGfx(tile);

   274

	CargoID a;

   275

   276

	a = _industry_section_accepts_1[gfx];

   277

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

   278

   279

	a = _industry_section_accepts_2[gfx];

   280

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

   281

   282

	a = _industry_section_accepts_3[gfx];

   283

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

   284

}

   285

   286

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   287

{

   288

	const Industry *i = GetIndustryByTile(tile);

   289

   290

	td->owner = i->owner;

   291

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

   292

	if (!IsIndustryCompleted(tile)) {

   293

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

   294

		td->str = STR_2058_UNDER_CONSTRUCTION;

   295

	}

   296

}

   297

   298

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   299

{

   300

	Industry *i = GetIndustryByTile(tile);

   301

   302

	/* water can destroy industries

   303

	 * in editor you can bulldoze industries

   304

	 * with magic_bulldozer cheat you can destroy industries

   305

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

   306

	 */

   307

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

   308

			!_cheats.magic_bulldozer.value) ||

   309

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

   310

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

   311

		return_cmd_error(STR_4800_IN_THE_WAY);

   312

	}

   313

   314

	if (flags & DC_EXEC) DeleteIndustry(i);

   315

	return 0;

   316

}

   317

   318

static void TransportIndustryGoods(TileIndex tile)

   319

{

   320

	Industry *i = GetIndustryByTile(tile);

   321

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

   322

	uint cw, am;

   323

   324

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

   325

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

   326

		i->cargo_waiting[0] -= cw;

   327

   328

		/* fluctuating economy? */

   329

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

   330

   331

		i->last_mo_production[0] += cw;

   332

   333

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

   334

		i->last_mo_transported[0] += am;

   335

		if (am != 0) {

   336

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   337

   338

			if (newgfx != 0xFF) {

   339

				ResetIndustryConstructionStage(tile);

   340

				SetIndustryCompleted(tile, true);

   341

				SetIndustryGfx(tile, newgfx);

   342

				MarkTileDirtyByTile(tile);

   343

			}

   344

		}

   345

	}

   346

   347

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

   348

	if (cw > indspec->minimal_cargo) {

   349

		i->cargo_waiting[1] -= cw;

   350

   351

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

   352

   353

		i->last_mo_production[1] += cw;

   354

   355

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

   356

		i->last_mo_transported[1] += am;

   357

	}

   358

}

   359

   360

   361

static void AnimateTile_Industry(TileIndex tile)

   362

{

   363

	byte m;

   364

   365

	switch (GetIndustryGfx(tile)) {

   366

	case GFX_SUGAR_MINE_SIEVE:

   367

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

   368

			m = GetIndustryAnimationState(tile) + 1;

   369

   370

			switch (m & 7) {

   371

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

   372

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

   373

			}

   374

   375

			if (m >= 96) {

   376

				m = 0;

   377

				DeleteAnimatedTile(tile);

   378

			}

   379

			SetIndustryAnimationState(tile, m);

   380

   381

			MarkTileDirtyByTile(tile);

   382

		}

   383

		break;

   384

   385

	case GFX_TOFFEE_QUARY:

   386

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

   387

			m = GetIndustryAnimationState(tile);

   388

   389

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

   390

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   391

			}

   392

   393

			if (++m >= 70) {

   394

				m = 0;

   395

				DeleteAnimatedTile(tile);

   396

			}

   397

			SetIndustryAnimationState(tile, m);

   398

   399

			MarkTileDirtyByTile(tile);

   400

		}

   401

		break;

   402

   403

	case GFX_BUBBLE_CATCHER:

   404

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

   405

			m = GetIndustryAnimationState(tile);

   406

   407

			if (++m >= 40) {

   408

				m = 0;

   409

				DeleteAnimatedTile(tile);

   410

			}

   411

			SetIndustryAnimationState(tile, m);

   412

   413

			MarkTileDirtyByTile(tile);

   414

		}

   415

		break;

   416

   417

	// Sparks on a coal plant

   418

	case GFX_POWERPLANT_SPARKS:

   419

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

   420

			m = GetIndustryAnimationState(tile);

   421

			if (m == 6) {

   422

				SetIndustryAnimationState(tile, 0);

   423

				DeleteAnimatedTile(tile);

   424

			} else {

   425

				SetIndustryAnimationState(tile, m + 1);

   426

				MarkTileDirtyByTile(tile);

   427

			}

   428

		}

   429

		break;

   430

   431

	case GFX_TOY_FACTORY:

   432

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

   433

			m = GetIndustryAnimationState(tile) + 1;

   434

   435

			if (m == 1) {

   436

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   437

			} else if (m == 23) {

   438

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   439

			} else if (m == 28) {

   440

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   441

			}

   442

   443

			if (m >= 50) {

   444

				int n = GetIndustryAnimationLoop(tile) + 1;

   445

				m = 0;

   446

				if (n >= 8) {

   447

					n = 0;

   448

					DeleteAnimatedTile(tile);

   449

				}

   450

				SetIndustryAnimationLoop(tile, n);

   451

			}

   452

			SetIndustryAnimationState(tile, m);

   453

			MarkTileDirtyByTile(tile);

   454

		}

   455

		break;

   456

   457

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:

   458

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:

   459

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:

   460

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:

   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 = GetIndustryAnimationState(tile) + 1;

   478

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

   479

				SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);

   480

				SetIndustryConstructionStage(tile, 3);

   481

				DeleteAnimatedTile(tile);

   482

			} else {

   483

				SetIndustryAnimationState(tile, 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;