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 "viewport.h"

    16

#include "command.h"

    17

#include "industry.h"

    18

#include "town.h"

    19

#include "vehicle.h"

    20

#include "news.h"

    21

#include "saveload.h"

    22

#include "economy.h"

    23

#include "sound.h"

    24

#include "variables.h"

    25

#include "table/industry_land.h"

    26

#include "table/build_industry.h"

    27

#include "genworld.h"

    28

#include "date.h"

    29

#include "water_map.h"

    30

#include "tree_map.h"

    31

#include "cargotype.h"

    32

    33

void ShowIndustryViewWindow(int industry);

    34

void BuildOilRig(TileIndex tile);

    35

    36

static byte _industry_sound_ctr;

    37

static TileIndex _industry_sound_tile;

    38

    39

/**

    40

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

    41

 */

    42

static void IndustryPoolNewBlock(uint start_item)

    43

{

    44

	Industry *i;

    45

    46

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

    47

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

    48

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

    49

}

    50

    51

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

    52

    53

/**

    54

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

    55

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

    56

 * as would do GetIndustryGfx.

    57

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

    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

	IndustryGfx this_type = GetIndustryGfx(tile);

    65

	IndustryType iloop;

    66

    67

	assert(IsTileType(tile, MP_INDUSTRY));

    68

    69

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

    70

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

    71

				industry_gfx_Solver[iloop].MaxGfx+1)) {

    72

			return iloop;

    73

		}

    74

	}

    75

    76

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

    77

}

    78

    79

/**

    80

 * Accessor for array _industry_specs.

    81

 * This will ensure at once : proper access and

    82

 * not allowing modifications of it.

    83

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

    84

 * @pre thistype < IT_END

    85

 * @return a pointer to the corresponding industry spec

    86

 **/

    87

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    88

{

    89

	assert(thistype < IT_END);

    90

	return &_industry_specs[thistype];

    91

}

    92

    93

/**

    94

 * Accessor for array _industry_tile_specs.

    95

 * This will ensure at once : proper access and

    96

 * not allowing modifications of it.

    97

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

    98

 * @pre gfx < NUM_INDUSTRY_GFXES

    99

 * @return a pointer to the corresponding industrytile spec

   100

 **/

   101

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)

   102

{

   103

	assert(gfx < NUM_INDUSTRY_GFXES);

   104

	return &_industry_tile_specs[gfx];

   105

}

   106

   107

void DestroyIndustry(Industry *i)

   108

{

   109

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

   110

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

   111

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

   112

				DoClearSquare(tile_cur);

   113

			}

   114

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

   115

			DeleteOilRig(tile_cur);

   116

		}

   117

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

   118

   119

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

   120

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

   121

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

   122

			tile_cur = TILE_MASK(tile_cur);

   123

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

   124

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

   125

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   126

			}

   127

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

   128

	}

   129

   130

	_industry_sort_dirty = true;

   131

	_total_industries--;

   132

	DeleteSubsidyWithIndustry(i->index);

   133

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   134

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   135

}

   136

   137

static void IndustryDrawSugarMine(const TileInfo *ti)

   138

{

   139

	const DrawIndustrySpec1Struct *d;

   140

	uint32 image;

   141

   142

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

   143

   144

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

   145

   146

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

   147

   148

	image = d->image_2;

   149

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

   150

   151

	image = d->image_3;

   152

	if (image != 0) {

   153

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1, PAL_NONE,

   154

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

   155

	}

   156

}

   157

   158

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   159

{

   160

	int x = 0;

   161

   162

	if (IsIndustryCompleted(ti->tile)) {

   163

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

   164

		if ( (byte)x == 0xFF)

   165

			x = 0;

   166

	}

   167

   168

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

   169

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);

   170

}

   171

   172

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   173

{

   174

	if (IsIndustryCompleted(ti->tile)) {

   175

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

   176

	} else {

   177

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);

   178

	}

   179

}

   180

   181

static void IndustryDrawToyFactory(const TileInfo *ti)

   182

{

   183

	const DrawIndustrySpec4Struct *d;

   184

   185

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

   186

   187

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

   188

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

   189

	}

   190

   191

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

   192

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

   193

	}

   194

   195

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

   196

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);

   197

}

   198

   199

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   200

{

   201

	if (IsIndustryCompleted(ti->tile)) {

   202

		uint image = GetIndustryAnimationState(ti->tile);

   203

   204

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

   205

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   206

				PAL_NONE,

   207

				_coal_plant_sparks_x[image - 1],

   208

				_coal_plant_sparks_y[image - 1]

   209

			);

   210

		}

   211

	}

   212

}

   213

   214

typedef void IndustryDrawTileProc(const TileInfo *ti);

   215

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   216

	IndustryDrawSugarMine,

   217

	IndustryDrawToffeeQuarry,

   218

	IndustryDrawBubbleGenerator,

   219

	IndustryDrawToyFactory,

   220

	IndustryDrawCoalPlantSparks,

   221

};

   222

   223

static void DrawTile_Industry(TileInfo *ti)

   224

{

   225

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

   226

	const Industry *ind;

   227

	const DrawBuildingsTileStruct *dits;

   228

	byte z;

   229

	SpriteID image;

   230

	SpriteID pal;

   231

   232

	/* Pointer to industry */

   233

	ind = GetIndustryByTile(ti->tile);

   234

   235

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

   237

			GetIndustryAnimationState(ti->tile) & 3 :

   238

			GetIndustryConstructionStage(ti->tile))];

   239

   240

	image = dits->ground.sprite;

   241

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

   242

		pal = GENERAL_SPRITE_COLOR(ind->random_color);

   243

	} else {

   244

		pal = dits->ground.pal;

   245

	}

   246

   247

	z = ti->z;

   248

	/* Add bricks below the industry? */

   249

	if (ti->tileh != SLOPE_FLAT) {

   250

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

   251

		AddChildSpriteScreen(image, pal, 31, 1);

   252

		z += TILE_HEIGHT;

   253

	} else {

   254

		/* Else draw regular ground */

   255

		DrawGroundSprite(image, pal);

   256

	}

   257

   258

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

   259

	image = dits->building.sprite;

   260

	if (image != 0) {

   261

		if (_display_opt & DO_TRANS_BUILDINGS) {

   262

			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   263

			pal = PALETTE_TO_TRANSPARENT;

   264

		} else {

   265

			pal = dits->building.pal;

   266

		}

   267

   268

		AddSortableSpriteToDraw(image, pal,

   269

			ti->x + dits->subtile_x,

   270

			ti->y + dits->subtile_y,

   271

			dits->width  + 1,

   272

			dits->height + 1,

   273

			dits->dz,

   274

			z);

   275

   276

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   277

	}

   278

   279

	{

   280

		int proc = dits->draw_proc - 1;

   281

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

   282

	}

   283

}

   284

   285

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

   286

{

   287

	return GetTileMaxZ(tile);

   288

}

   289

   290

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   291

{

   292

	return SLOPE_FLAT;

   293

}

   294

   295

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   296

{

   297

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

   298

	CargoID a;

   299

   300

	a = itspec->accepts_cargo[0];

   301

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

   302

   303

	a = itspec->accepts_cargo[1];

   304

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

   305

   306

	a = itspec->accepts_cargo[2];

   307

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

   308

}

   309

   310

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   311

{

   312

	const Industry *i = GetIndustryByTile(tile);

   313

   314

	td->owner = i->owner;

   315

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

   316

	if (!IsIndustryCompleted(tile)) {

   317

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

   318

		td->str = STR_2058_UNDER_CONSTRUCTION;

   319

	}

   320

}

   321

   322

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   323

{

   324

	Industry *i = GetIndustryByTile(tile);

   325

   326

	/* water can destroy industries

   327

	 * in editor you can bulldoze industries

   328

	 * with magic_bulldozer cheat you can destroy industries

   329

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

   330

	 */

   331

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

   332

			!_cheats.magic_bulldozer.value) ||

   333

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

   334

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

   335

		return_cmd_error(STR_4800_IN_THE_WAY);

   336

	}

   337

   338

	if (flags & DC_EXEC) DeleteIndustry(i);

   339

	return 0;

   340

}

   341

   342

static void TransportIndustryGoods(TileIndex tile)

   343

{

   344

	Industry *i = GetIndustryByTile(tile);

   345

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

   346

	uint cw, am;

   347

   348

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

   349

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

   350

		i->cargo_waiting[0] -= cw;

   351

   352

		/* fluctuating economy? */

   353

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

   354

   355

		i->last_mo_production[0] += cw;

   356

   357

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

   358

		i->last_mo_transported[0] += am;

   359

		if (am != 0) {

   361

   363

				ResetIndustryConstructionStage(tile);

   364

				SetIndustryCompleted(tile, true);

   365

				SetIndustryGfx(tile, newgfx);

   366

				MarkTileDirtyByTile(tile);

   367

			}

   368

		}

   369

	}

   370

   371

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

   372

	if (cw > indspec->minimal_cargo) {

   373

		i->cargo_waiting[1] -= cw;

   374

   375

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

   376

   377

		i->last_mo_production[1] += cw;

   378

   379

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

   380

		i->last_mo_transported[1] += am;

   381

	}

   382

}

   383

   384

   385

static void AnimateTile_Industry(TileIndex tile)

   386

{

   387

	byte m;

   388

   389

	switch (GetIndustryGfx(tile)) {

   390

	case GFX_SUGAR_MINE_SIEVE:

   391

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

   392

			m = GetIndustryAnimationState(tile) + 1;

   393

   394

			switch (m & 7) {

   395

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

   396

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

   397

			}

   398

   399

			if (m >= 96) {

   400

				m = 0;

   401

				DeleteAnimatedTile(tile);

   402

			}

   403

			SetIndustryAnimationState(tile, m);

   404

   405

			MarkTileDirtyByTile(tile);

   406

		}

   407

		break;

   408

   409

	case GFX_TOFFEE_QUARY:

   410

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

   411

			m = GetIndustryAnimationState(tile);

   412

   413

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

   414

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   415

			}

   416

   417

			if (++m >= 70) {

   418

				m = 0;

   419

				DeleteAnimatedTile(tile);

   420

			}

   421

			SetIndustryAnimationState(tile, m);

   422

   423

			MarkTileDirtyByTile(tile);

   424

		}

   425

		break;

   426

   427

	case GFX_BUBBLE_CATCHER:

   428

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

   429

			m = GetIndustryAnimationState(tile);

   430

   431

			if (++m >= 40) {

   432

				m = 0;

   433

				DeleteAnimatedTile(tile);

   434

			}

   435

			SetIndustryAnimationState(tile, m);

   436

   437

			MarkTileDirtyByTile(tile);

   438

		}

   439

		break;

   440

   441

	/* Sparks on a coal plant */

   442

	case GFX_POWERPLANT_SPARKS:

   443

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

   444

			m = GetIndustryAnimationState(tile);

   445

			if (m == 6) {

   446

				SetIndustryAnimationState(tile, 0);

   447

				DeleteAnimatedTile(tile);

   448

			} else {

   449

				SetIndustryAnimationState(tile, m + 1);

   450

				MarkTileDirtyByTile(tile);

   451

			}

   452

		}

   453

		break;

   454

   455

	case GFX_TOY_FACTORY:

   456

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

   457

			m = GetIndustryAnimationState(tile) + 1;

   458

   459

			if (m == 1) {

   460

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   461

			} else if (m == 23) {

   462

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   463

			} else if (m == 28) {

   464

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   465

			}

   466

   467

			if (m >= 50) {

   468

				int n = GetIndustryAnimationLoop(tile) + 1;

   469

				m = 0;

   470

				if (n >= 8) {

   471

					n = 0;

   472

					DeleteAnimatedTile(tile);

   473

				}

   474

				SetIndustryAnimationLoop(tile, n);

   475

			}

   476

			SetIndustryAnimationState(tile, m);

   477

			MarkTileDirtyByTile(tile);

   478

		}

   479

		break;

   480

   481

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:

   482

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:

   483

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:

   484

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:

   485

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

   486

			IndustryGfx gfx = GetIndustryGfx(tile);

   487

   488

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

   489

			SetIndustryGfx(tile, gfx);

   490

			MarkTileDirtyByTile(tile);

   491

		}

   492

		break;