1

/* $Id$ */

     2

     3

/** @file industry_cmd.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "clear_map.h"

     8

#include "functions.h"

     9

#include "industry_map.h"

    10

#include "station_map.h"

    11

#include "table/strings.h"

    12

#include "table/sprites.h"

    13

#include "map.h"

    14

#include "tile.h"

    15

#include "landscape.h"

    16

#include "viewport.h"

    17

#include "command.h"

    18

#include "industry.h"

    19

#include "town.h"

    20

#include "vehicle.h"

    21

#include "news.h"

    22

#include "saveload.h"

    23

#include "economy.h"

    24

#include "sound.h"

    25

#include "variables.h"

    26

#include "table/industry_land.h"

    27

#include "table/build_industry.h"

    28

#include "genworld.h"

    29

#include "date.h"

    30

#include "water_map.h"

    31

#include "tree_map.h"

    32

#include "cargotype.h"

    33

    34

void ShowIndustryViewWindow(int industry);

    35

void BuildOilRig(TileIndex tile);

    36

    37

static byte _industry_sound_ctr;

    38

static TileIndex _industry_sound_tile;

    39

    40

/**

    41

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

    42

 */

    43

static void IndustryPoolNewBlock(uint start_item)

    44

{

    45

	Industry *i;

    46

    47

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

    48

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

    49

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

    50

}

    51

    52

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

    53

    54

/**

    55

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

    56

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

    57

 * as would do GetIndustryGfx.

    58

 * @param tile that is queried

    59

 * @pre IsTileType(tile, MP_INDUSTRY)

    60

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

    61

 **/

    62

IndustryType GetIndustryType(TileIndex tile)

    63

{

    64

	assert(IsTileType(tile, MP_INDUSTRY));

    65

    66

	const Industry *ind = GetIndustryByTile(tile);

    67

	return IsValidIndustry(ind) ? ind->type : (IndustryType)IT_INVALID;

    68

}

    69

    70

/**

    71

 * Accessor for array _industry_specs.

    72

 * This will ensure at once : proper access and

    73

 * not allowing modifications of it.

    74

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

    75

 * @pre thistype < NUM_INDUSTRYTYPES

    76

 * @return a pointer to the corresponding industry spec

    77

 **/

    78

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    79

{

    80

	assert(thistype < NUM_INDUSTRYTYPES);

    81

	return &_industry_specs[thistype];

    82

}

    83

    84

/**

    85

 * Accessor for array _industry_tile_specs.

    86

 * This will ensure at once : proper access and

    87

 * not allowing modifications of it.

    88

 * @param gfx of industrytile (which is the index in _industry_specs)

    89

 * @pre gfx < NUM_INDUSTRY_GFXES

    90

 * @return a pointer to the corresponding industrytile spec

    91

 **/

    92

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)

    93

{

    94

	assert(gfx < NUM_INDUSTRY_GFXES);

    95

	return &_industry_tile_specs[gfx];

    96

}

    97

    98

void DestroyIndustry(Industry *i)

    99

{

   100

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

   101

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

   102

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

   103

				DoClearSquare(tile_cur);

   104

			}

   105

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

   106

			DeleteOilRig(tile_cur);

   107

		}

   108

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

   109

   110

	if (GetIndustrySpec(i->type)->behaviour & INDUSTRYBEH_PLANT_FIELDS) {

   111

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

   112

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

   113

			tile_cur = TILE_MASK(tile_cur);

   114

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

   115

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

   116

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   117

			}

   118

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

   119

	}

   120

   121

	_industry_sort_dirty = true;

   122

	_total_industries--;

   123

	DeleteSubsidyWithIndustry(i->index);

   124

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   125

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   126

}

   127

   128

static void IndustryDrawSugarMine(const TileInfo *ti)

   129

{

   130

	const DrawIndustryAnimationStruct *d;

   131

   132

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

   133

   134

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

   135

   136

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

   137

   138

	if (d->image_2 != 0) {

   139

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_CLOUDS + d->image_2 - 1, PAL_NONE, 8, 41);

   140

	}

   141

   142

	if (d->image_3 != 0) {

   143

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + d->image_3 - 1, PAL_NONE,

   144

			_drawtile_proc1[d->image_3 - 1].x, _drawtile_proc1[d->image_3 - 1].y);

   145

	}

   146

}

   147

   148

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   149

{

   150

	uint8 x = 0;

   151

   152

	if (IsIndustryCompleted(ti->tile)) {

   153

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

   154

		if (x == 0xFF)

   155

			x = 0;

   156

	}

   157

   158

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

   159

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);

   160

}

   161

   162

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   163

{

   164

	if (IsIndustryCompleted(ti->tile)) {

   165

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

   166

	} else {

   167

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);

   168

	}

   169

}

   170

   171

static void IndustryDrawToyFactory(const TileInfo *ti)

   172

{

   173

	const DrawIndustryAnimationStruct *d;

   174

   175

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

   176

   177

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

   178

		AddChildSpriteScreen(SPR_IT_TOY_FACTORY_CLAY, PAL_NONE, d->x, 96 + d->image_1);

   179

	}

   180

   181

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

   182

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

   183

	}

   184

   185

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

   186

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);

   187

}

   188

   189

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   190

{

   191

	if (IsIndustryCompleted(ti->tile)) {

   192

		uint8 image = GetIndustryAnimationState(ti->tile);

   193

   194

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

   195

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   196

				PAL_NONE,

   197

				_coal_plant_sparks[image - 1].x,

   198

				_coal_plant_sparks[image - 1].y

   199

			);

   200

		}

   201

	}

   202

}

   203

   204

typedef void IndustryDrawTileProc(const TileInfo *ti);

   205

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   206

	IndustryDrawSugarMine,

   207

	IndustryDrawToffeeQuarry,

   208

	IndustryDrawBubbleGenerator,

   209

	IndustryDrawToyFactory,

   210

	IndustryDrawCoalPlantSparks,

   211

};

   212

   213

static void DrawTile_Industry(TileInfo *ti)

   214

{

   215

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

   216

	const Industry *ind;

   217

	const DrawBuildingsTileStruct *dits;

   218

	byte z;

   219

	SpriteID image;

   220

	SpriteID pal;

   221

   222

	/* Pointer to industry */

   223

	ind = GetIndustryByTile(ti->tile);

   224

   225

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

   226

	dits = &_industry_draw_tile_data[gfx << 2 | (GetIndustryTileSpec(gfx)->anim_state ?

   227

			GetIndustryAnimationState(ti->tile) & 3 :

   228

			GetIndustryConstructionStage(ti->tile))];

   229

   230

	image = dits->ground.sprite;

   231

	if (HASBIT(image, PALETTE_MODIFIER_COLOR) && dits->ground.pal == PAL_NONE) {

   232

		pal = GENERAL_SPRITE_COLOR(ind->random_color);

   233

	} else {

   234

		pal = dits->ground.pal;

   235

	}

   236

   237

	z = ti->z;

   238

	/* Add bricks below the industry? */

   239

	if (ti->tileh != SLOPE_FLAT) {

   240

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

   241

		AddChildSpriteScreen(image, pal, 31, 1);

   242

		z += TILE_HEIGHT;

   243

	} else {

   244

		/* Else draw regular ground */

   245

		DrawGroundSprite(image, pal);

   246

	}

   247

   248

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

   249

	image = dits->building.sprite;

   250

	if (image != 0) {

   251

		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) {

   252

			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   253

			pal = PALETTE_TO_TRANSPARENT;

   254

		} else {

   255

			pal = dits->building.pal;

   256

		}

   257

   258

		AddSortableSpriteToDraw(image, pal,

   259

			ti->x + dits->subtile_x,

   260

			ti->y + dits->subtile_y,

   261

			dits->width  + 1,

   262

			dits->height + 1,

   263

			dits->dz,

   264

			z);

   265

   266

		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) return;

   267

	}

   268

   269

	{

   270

		int proc = dits->draw_proc - 1;

   271

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

   272

	}

   273

}

   274

   275

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

   276

{

   277

	return GetTileMaxZ(tile);

   278

}

   279

   280

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   281

{

   282

	return SLOPE_FLAT;

   283

}

   284

   285

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   286

{

   287

	const IndustryTileSpec *itspec = GetIndustryTileSpec(GetIndustryGfx(tile));

   288

	CargoID a;

   289

   290

	a = itspec->accepts_cargo[0];

   291

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

   292

   293

	a = itspec->accepts_cargo[1];

   294

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

   295

   296

	a = itspec->accepts_cargo[2];

   297

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

   298

}

   299

   300

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   301

{

   302

	const Industry *i = GetIndustryByTile(tile);

   303

   304

	td->owner = i->owner;

   305

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

   306

	if (!IsIndustryCompleted(tile)) {

   307

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

   308

		td->str = STR_2058_UNDER_CONSTRUCTION;

   309

	}

   310

}

   311

   312

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   313

{

   314

	Industry *i = GetIndustryByTile(tile);

   315

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

   316

   317

	/* water can destroy industries

   318

	 * in editor you can bulldoze industries

   319

	 * with magic_bulldozer cheat you can destroy industries

   320

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

   321

	 */

   322

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

   323

			!_cheats.magic_bulldozer.value) ||

   324

			(_current_player == OWNER_WATER && (indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER))) {

   325

		SetDParam(0, indspec->name);

   326

		return_cmd_error(STR_4800_IN_THE_WAY);

   327

	}

   328

   329

	if (flags & DC_EXEC) DeleteIndustry(i);

   330

	return 0;

   331

}

   332

   333

static void TransportIndustryGoods(TileIndex tile)

   334

{

   335

	Industry *i = GetIndustryByTile(tile);

   336

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

   337

	uint cw, am;

   338

   339

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

   340

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

   341

		i->cargo_waiting[0] -= cw;

   342

   343

		/* fluctuating economy? */

   344

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

   345

   346

		i->last_mo_production[0] += cw;

   347

   348

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

   349

		i->last_mo_transported[0] += am;

   350

		if (am != 0) {

   351

			uint newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_production;

   352

   353

			if (newgfx != INDUTILE_NOANIM) {

   354

				ResetIndustryConstructionStage(tile);

   355

				SetIndustryCompleted(tile, true);

   356

				SetIndustryGfx(tile, newgfx);

   357

				MarkTileDirtyByTile(tile);

   358

			}

   359

		}

   360

	}

   361

   362

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

   363

	if (cw > indspec->minimal_cargo) {

   364

		i->cargo_waiting[1] -= cw;

   365

   366

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

   367

   368

		i->last_mo_production[1] += cw;

   369

   370

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

   371

		i->last_mo_transported[1] += am;

   372

	}

   373

}

   374

   375

   376

static void AnimateTile_Industry(TileIndex tile)

   377

{

   378

	byte m;

   379

   380

	switch (GetIndustryGfx(tile)) {

   381

	case GFX_SUGAR_MINE_SIEVE:

   382

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

   383

			m = GetIndustryAnimationState(tile) + 1;

   384

   385

			switch (m & 7) {

   386

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

   387

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

   388

			}

   389

   390

			if (m >= 96) {

   391

				m = 0;

   392

				DeleteAnimatedTile(tile);

   393

			}

   394

			SetIndustryAnimationState(tile, m);

   395

   396

			MarkTileDirtyByTile(tile);

   397

		}

   398

		break;

   399

   400

	case GFX_TOFFEE_QUARY:

   401

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

   402

			m = GetIndustryAnimationState(tile);

   403

   404

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

   405

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   406

			}

   407

   408

			if (++m >= 70) {

   409

				m = 0;

   410

				DeleteAnimatedTile(tile);

   411

			}

   412

			SetIndustryAnimationState(tile, m);

   413

   414

			MarkTileDirtyByTile(tile);

   415

		}

   416

		break;

   417

   418

	case GFX_BUBBLE_CATCHER:

   419

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

   420

			m = GetIndustryAnimationState(tile);

   421

   422

			if (++m >= 40) {

   423

				m = 0;

   424

				DeleteAnimatedTile(tile);

   425

			}

   426

			SetIndustryAnimationState(tile, m);

   427

   428

			MarkTileDirtyByTile(tile);

   429

		}

   430

		break;

   431

   432

	/* Sparks on a coal plant */

   433

	case GFX_POWERPLANT_SPARKS:

   434

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

   435

			m = GetIndustryAnimationState(tile);

   436

			if (m == 6) {

   437

				SetIndustryAnimationState(tile, 0);

   438

				DeleteAnimatedTile(tile);

   439

			} else {

   440

				SetIndustryAnimationState(tile, m + 1);

   441

				MarkTileDirtyByTile(tile);

   442

			}

   443

		}

   444

		break;

   445

   446

	case GFX_TOY_FACTORY:

   447

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

   448

			m = GetIndustryAnimationState(tile) + 1;

   449

   450

			switch (m) {

   451

				case  1: SndPlayTileFx(SND_2C_MACHINERY, tile); break;

   452

				case 23: SndPlayTileFx(SND_2B_COMEDY_HIT, tile); break;

   453

				case 28: SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile); break;

   454

				default:

   455

					if (m >= 50) {

   456

						int n = GetIndustryAnimationLoop(tile) + 1;

   457

						m = 0;

   458

						if (n >= 8) {

   459

							n = 0;

   460

							DeleteAnimatedTile(tile);

   461

						}

   462

						SetIndustryAnimationLoop(tile, n);

   463

					}

   464

			}

   465

   466

			SetIndustryAnimationState(tile, m);

   467

			MarkTileDirtyByTile(tile);

   468

		}

   469

		break;

   470

   471

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:

   472

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:

   473

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:

   474

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:

   475

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

   476

			IndustryGfx gfx = GetIndustryGfx(tile);

   477

   478

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

   479

			SetIndustryGfx(tile, gfx);

   480

			MarkTileDirtyByTile(tile);

   481

		}

   482

		break;

   483

   484

	case GFX_OILWELL_ANIMATED_1:

   485

	case GFX_OILWELL_ANIMATED_2:

   486

	case GFX_OILWELL_ANIMATED_3:

   487

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

   488

			bool b = CHANCE16(1, 7);

   489

			IndustryGfx gfx = GetIndustryGfx(tile);

   490

   491

			m = GetIndustryAnimationState(tile) + 1;