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

int _total_industries;                      //general counter

    41

uint16 _industry_counts[NUM_INDUSTRYTYPES]; // Number of industries per type ingame

    42

    43

const Industry **_industry_sort;

    44

bool _industry_sort_dirty;

    45

    46

IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];

    47

IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];

    48

    49

/** This function initialize the spec arrays of both

    50

 * industry and industry tiles.

    51

 * It adjusts the enabling of the industry too, based on climate availability.

    52

 * This will allow for clearer testings */

    53

void ResetIndustries()

    54

{

    55

	memset(&_industry_specs, 0, sizeof(_industry_specs));

    56

	memcpy(&_industry_specs, &_origin_industry_specs, sizeof(_origin_industry_specs));

    57

    58

	/* once performed, enable only the current climate industries */

    59

	for (IndustryType i = 0; i < NUM_INDUSTRYTYPES; i++) {

    60

		_industry_specs[i].enabled = HASBIT(_origin_industry_specs[i].climate_availability, _opt.landscape);

    61

	}

    62

    63

    64

	memset(&_industry_tile_specs, 0, sizeof(_industry_tile_specs));

    65

	memcpy(&_industry_tile_specs, &_origin_industry_tile_specs, sizeof(_origin_industry_tile_specs));

    66

}

    67

    68

/**

    69

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

    70

 */

    71

static void IndustryPoolNewBlock(uint start_item)

    72

{

    73

	Industry *i;

    74

    75

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

    76

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

    77

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

    78

}

    79

    80

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

    81

    82

/**

    83

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

    84

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

    85

 * as would do GetIndustryGfx.

    86

 * @param tile that is queried

    87

 * @pre IsTileType(tile, MP_INDUSTRY)

    88

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

    89

 **/

    90

IndustryType GetIndustryType(TileIndex tile)

    91

{

    92

	assert(IsTileType(tile, MP_INDUSTRY));

    93

    94

	const Industry *ind = GetIndustryByTile(tile);

    95

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

    96

}

    97

    98

/**

    99

 * Accessor for array _industry_specs.

   100

 * This will ensure at once : proper access and

   101

 * not allowing modifications of it.

   102

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

   103

 * @pre thistype < NUM_INDUSTRYTYPES

   104

 * @return a pointer to the corresponding industry spec

   105

 **/

   106

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

   107

{

   108

	assert(thistype < NUM_INDUSTRYTYPES);

   109

	return &_industry_specs[thistype];

   110

}

   111

   112

/**

   113

 * Accessor for array _industry_tile_specs.

   114

 * This will ensure at once : proper access and

   115

 * not allowing modifications of it.

   116

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

   117

 * @pre gfx < INVALID_INDUSTRYTILE

   118

 * @return a pointer to the corresponding industrytile spec

   119

 **/

   120

const IndustryTileSpec *GetIndustryTileSpec(IndustryGfx gfx)

   121

{

   122

	assert(gfx < INVALID_INDUSTRYTILE);

   123

	return &_industry_tile_specs[gfx];

   124

}

   125

   126

void DestroyIndustry(Industry *i)

   127

{

   128

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

   129

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

   130

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

   131

				DoClearSquare(tile_cur);

   132

			}

   133

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

   134

			DeleteOilRig(tile_cur);

   135

		}

   136

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

   137

   138

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

   139

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

   140

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

   141

			tile_cur = TILE_MASK(tile_cur);

   142

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

   143

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

   144

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   145

			}

   146

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

   147

	}

   148

   149

	_industry_sort_dirty = true;

   150

	DecIndustryTypeCount(i->type);

   151

   152

	DeleteSubsidyWithIndustry(i->index);

   153

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   154

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   155

}

   156

   157

static void IndustryDrawSugarMine(const TileInfo *ti)

   158

{

   159

	const DrawIndustryAnimationStruct *d;

   160

   161

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

   162

   163

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

   164

   165

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

   166

   167

	if (d->image_2 != 0) {

   168

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

   169

	}

   170

   171

	if (d->image_3 != 0) {

   172

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

   173

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

   174

	}

   175

}

   176

   177

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   178

{

   179

	uint8 x = 0;

   180

   181

	if (IsIndustryCompleted(ti->tile)) {

   182

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

   183

		if (x == 0xFF)

   184

			x = 0;

   185

	}

   186

   187

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

   188

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);

   189

}

   190

   191

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   192

{

   193

	if (IsIndustryCompleted(ti->tile)) {

   194

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

   195

	} else {

   196

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);

   197

	}

   198

}

   199

   200

static void IndustryDrawToyFactory(const TileInfo *ti)

   201

{

   202

	const DrawIndustryAnimationStruct *d;

   203

   204

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

   205

   206

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

   207

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

   208

	}

   209

   210

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

   211

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

   212

	}

   213

   214

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

   215

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);

   216

}

   217

   218

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   219

{

   220

	if (IsIndustryCompleted(ti->tile)) {

   221

		uint8 image = GetIndustryAnimationState(ti->tile);

   222

   223

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

   224

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   225

				PAL_NONE,

   226

				_coal_plant_sparks[image - 1].x,

   227

				_coal_plant_sparks[image - 1].y

   228

			);

   229

		}

   230

	}

   231

}

   232

   233

typedef void IndustryDrawTileProc(const TileInfo *ti);

   234

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   235

	IndustryDrawSugarMine,

   236

	IndustryDrawToffeeQuarry,

   237

	IndustryDrawBubbleGenerator,

   238

	IndustryDrawToyFactory,

   239

	IndustryDrawCoalPlantSparks,

   240

};

   241

   242

static void DrawTile_Industry(TileInfo *ti)

   243

{

   244

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

   245

	const Industry *ind;

   246

	const DrawBuildingsTileStruct *dits;

   247

	byte z;

   248

	SpriteID image;

   249

	SpriteID pal;

   250

   251

	/* Pointer to industry */

   252

	ind = GetIndustryByTile(ti->tile);

   253

   254

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

   255

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

   256

			GetIndustryAnimationState(ti->tile) & 3 :

   257

			GetIndustryConstructionStage(ti->tile))];

   258

   259

	image = dits->ground.sprite;

   260

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

   261

		pal = GENERAL_SPRITE_COLOR(ind->random_color);

   262

	} else {

   263

		pal = dits->ground.pal;

   264

	}

   265

   266

	z = ti->z;

   267

	/* Add bricks below the industry? */

   268

	if (ti->tileh != SLOPE_FLAT) {

   269

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

   270

		AddChildSpriteScreen(image, pal, 31, 1);

   271

		z += TILE_HEIGHT;

   272

	} else {

   273

		/* Else draw regular ground */

   274

		DrawGroundSprite(image, pal);

   275

	}

   276

   277

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

   278

	image = dits->building.sprite;

   279

	if (image != 0) {

   280

		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) {

   281

			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   282

			pal = PALETTE_TO_TRANSPARENT;

   283

		} else {

   284

			pal = dits->building.pal;

   285

		}

   286

   287

		AddSortableSpriteToDraw(image, pal,

   288

			ti->x + dits->subtile_x,

   289

			ti->y + dits->subtile_y,

   290

			dits->width  + 1,

   291

			dits->height + 1,

   292

			dits->dz,

   293

			z);

   294

   295

		if (HASBIT(_transparent_opt, TO_INDUSTRIES)) return;

   296

	}

   297

   298

	{

   299

		int proc = dits->draw_proc - 1;

   300

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

   301

	}

   302

}

   303

   304

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

   305

{

   306

	return GetTileMaxZ(tile);

   307

}

   308

   309

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   310

{

   311

	return SLOPE_FLAT;

   312

}

   313

   314

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   315

{

   316

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

   317

	CargoID a;

   318

   319

	for (byte i = 0; i < lengthof(itspec->accepts_cargo); i++) {

   320

		a = itspec->accepts_cargo[i];

   321

		if (a != CT_INVALID) ac[a] = itspec->acceptance[i];

   322

	}

   323

}

   324

   325

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   326

{

   327

	const Industry *i = GetIndustryByTile(tile);

   328

   329

	td->owner = i->owner;

   330

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

   331

	if (!IsIndustryCompleted(tile)) {

   332

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

   333

		td->str = STR_2058_UNDER_CONSTRUCTION;

   334

	}

   335

}

   336

   337

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   338

{

   339

	Industry *i = GetIndustryByTile(tile);

   340

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

   341

   342

	/* water can destroy industries

   343

	 * in editor you can bulldoze industries

   344

	 * with magic_bulldozer cheat you can destroy industries

   345

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

   346

	 */

   347

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

   348

			!_cheats.magic_bulldozer.value) ||

   349

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

   350

		SetDParam(0, indspec->name);

   351

		return_cmd_error(STR_4800_IN_THE_WAY);

   352

	}

   353

   354

	if (flags & DC_EXEC) DeleteIndustry(i);

   355

	return 0;

   356

}

   357

   358

static void TransportIndustryGoods(TileIndex tile)

   359

{

   360

	Industry *i = GetIndustryByTile(tile);

   361

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

   362

	uint cw, am;

   363

   364

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

   365

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

   366

		i->cargo_waiting[0] -= cw;

   367

   368

		/* fluctuating economy? */

   369

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

   370

   371

		i->this_month_production[0] += cw;

   372

   373

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

   374

		i->this_month_transported[0] += am;

   375

		if (am != 0) {

   376

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

   377

   378

			if (newgfx != INDUSTRYTILE_NOANIM) {

   379

				ResetIndustryConstructionStage(tile);

   380

				SetIndustryCompleted(tile, true);

   381

				SetIndustryGfx(tile, newgfx);

   382

				MarkTileDirtyByTile(tile);

   383

			}

   384

		}

   385

	}

   386

   387

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

   388

	if (cw > indspec->minimal_cargo) {

   389

		i->cargo_waiting[1] -= cw;

   390

   391

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

   392

   393

		i->this_month_production[1] += cw;

   394

   395

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

   396

		i->this_month_transported[1] += am;

   397

	}

   398

}

   399

   400

   401

static void AnimateTile_Industry(TileIndex tile)

   402

{

   403

	byte m;

   404

   405

	switch (GetIndustryGfx(tile)) {

   406

	case GFX_SUGAR_MINE_SIEVE:

   407

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

   408

			m = GetIndustryAnimationState(tile) + 1;

   409

   410

			switch (m & 7) {

   411

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

   412

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

   413

			}

   414

   415

			if (m >= 96) {

   416

				m = 0;

   417

				DeleteAnimatedTile(tile);

   418

			}

   419

			SetIndustryAnimationState(tile, m);

   420

   421

			MarkTileDirtyByTile(tile);

   422

		}

   423

		break;

   424

   425

	case GFX_TOFFEE_QUARY:

   426

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

   427

			m = GetIndustryAnimationState(tile);

   428

   429

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

   430

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   431

			}

   432

   433

			if (++m >= 70) {

   434

				m = 0;

   435

				DeleteAnimatedTile(tile);

   436

			}

   437

			SetIndustryAnimationState(tile, m);

   438

   439

			MarkTileDirtyByTile(tile);

   440

		}

   441

		break;

   442

   443

	case GFX_BUBBLE_CATCHER:

   444

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

   445

			m = GetIndustryAnimationState(tile);

   446

   447

			if (++m >= 40) {

   448

				m = 0;

   449

				DeleteAnimatedTile(tile);

   450

			}

   451

			SetIndustryAnimationState(tile, m);

   452

   453

			MarkTileDirtyByTile(tile);

   454

		}

   455

		break;

   456

   457

	/* Sparks on a coal plant */

   458

	case GFX_POWERPLANT_SPARKS:

   459

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

   460

			m = GetIndustryAnimationState(tile);

   461

			if (m == 6) {

   462

				SetIndustryAnimationState(tile, 0);

   463

				DeleteAnimatedTile(tile);

   464

			} else {

   465

				SetIndustryAnimationState(tile, m + 1);

   466

				MarkTileDirtyByTile(tile);

   467

			}

   468

		}

   469

		break;

   470

   471

	case GFX_TOY_FACTORY:

   472

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

   473

			m = GetIndustryAnimationState(tile) + 1;

   474

   475

			switch (m) {

   476

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

   477

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

   478

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

   479

				default:

   480

					if (m >= 50) {

   481

						int n = GetIndustryAnimationLoop(tile) + 1;

   482

						m = 0;

   483

						if (n >= 8) {

   484

							n = 0;

   485

							DeleteAnimatedTile(tile);

   486

						}

   487

						SetIndustryAnimationLoop(tile, n);

   488

					}

   489

			}

   490