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

#include "tree_map.h"

    29

#include "cargotype.h"

    30

    31

void ShowIndustryViewWindow(int industry);

    32

void BuildOilRig(TileIndex tile);

    33

    34

static byte _industry_sound_ctr;

    35

static TileIndex _industry_sound_tile;

    36

    37

/**

    38

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

    39

 */

    40

static void IndustryPoolNewBlock(uint start_item)

    41

{

    42

	Industry *i;

    43

    44

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

    45

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

    46

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

    47

}

    48

    49

DEFINE_OLD_POOL(Industry, Industry, IndustryPoolNewBlock, NULL)

    50

    51

/**

    52

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

    53

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

    54

 * as would do GetIndustryGfx.

    55

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

    56

 * @param tile that is queried

    57

 * @pre IsTileType(tile, MP_INDUSTRY)

    58

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

    59

 **/

    60

IndustryType GetIndustryType(TileIndex tile)

    61

{

    62

	IndustryGfx this_type = GetIndustryGfx(tile);

    63

	IndustryType iloop;

    64

    65

	assert(IsTileType(tile, MP_INDUSTRY));

    66

    67

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

    68

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

    69

				industry_gfx_Solver[iloop].MaxGfx+1)) {

    70

			return iloop;

    71

		}

    72

	}

    73

    74

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

    75

}

    76

    77

/**

    78

 * Accessor for array _industry_specs.

    79

 * This will ensure at once : proper access and

    80

 * not allowing modifications of it.

    81

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

    82

 * @pre thistype < IT_END

    83

 **/

    84

const IndustrySpec *GetIndustrySpec(IndustryType thistype)

    85

{

    86

	assert(thistype < IT_END);

    87

	return &_industry_specs[thistype];

    88

}

    89

    96

void DestroyIndustry(Industry *i)

    97

{

    98

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

    99

		if (IsTileType(tile_cur, MP_INDUSTRY)) {

   100

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

   101

				DoClearSquare(tile_cur);

   102

			}

   103

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

   104

			DeleteOilRig(tile_cur);

   105

		}

   106

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

   107

   108

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

   109

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

   110

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

   111

			tile_cur = TILE_MASK(tile_cur);

   112

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

   113

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

   114

				SetIndustryIndexOfField(tile_cur, INVALID_INDUSTRY);

   115

			}

   116

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

   117

	}

   118

   119

	_industry_sort_dirty = true;

   120

	_total_industries--;

   121

	DeleteSubsidyWithIndustry(i->index);

   122

	DeleteWindowById(WC_INDUSTRY_VIEW, i->index);

   123

	InvalidateWindow(WC_INDUSTRY_DIRECTORY, 0);

   124

}

   125

   126

static void IndustryDrawSugarMine(const TileInfo *ti)

   127

{

   128

	const DrawIndustrySpec1Struct *d;

   129

	uint32 image;

   130

   131

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

   132

   133

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

   134

   135

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

   136

   137

	image = d->image_2;

   138

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

   139

   140

	image = d->image_3;

   141

	if (image != 0) {

   142

		AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + image - 1, PAL_NONE,

   143

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

   144

	}

   145

}

   146

   147

static void IndustryDrawToffeeQuarry(const TileInfo *ti)

   148

{

   149

	int x = 0;

   150

   151

	if (IsIndustryCompleted(ti->tile)) {

   152

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

   153

		if ( (byte)x == 0xFF)

   154

			x = 0;

   155

	}

   156

   157

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

   158

	AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);

   159

}

   160

   161

static void IndustryDrawBubbleGenerator( const TileInfo *ti)

   162

{

   163

	if (IsIndustryCompleted(ti->tile)) {

   164

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

   165

	} else {

   166

		AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);

   167

	}

   168

}

   169

   170

static void IndustryDrawToyFactory(const TileInfo *ti)

   171

{

   172

	const DrawIndustrySpec4Struct *d;

   173

   174

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

   175

   176

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

   177

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

   178

	}

   179

   180

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

   181

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

   182

	}

   183

   184

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

   185

	AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);

   186

}

   187

   188

static void IndustryDrawCoalPlantSparks(const TileInfo *ti)

   189

{

   190

	if (IsIndustryCompleted(ti->tile)) {

   191

		uint image = GetIndustryAnimationState(ti->tile);

   192

   193

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

   194

			AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,

   195

				PAL_NONE,

   196

				_coal_plant_sparks_x[image - 1],

   197

				_coal_plant_sparks_y[image - 1]

   198

			);

   199

		}

   200

	}

   201

}

   202

   203

typedef void IndustryDrawTileProc(const TileInfo *ti);

   204

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   205

	IndustryDrawSugarMine,

   206

	IndustryDrawToffeeQuarry,

   207

	IndustryDrawBubbleGenerator,

   208

	IndustryDrawToyFactory,

   209

	IndustryDrawCoalPlantSparks,

   210

};

   211

   212

static void DrawTile_Industry(TileInfo *ti)

   213

{

   214

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

   215

	const Industry *ind;

   216

	const DrawBuildingsTileStruct *dits;

   217

	byte z;

   218

	SpriteID image;

   219

	SpriteID pal;

   220

   221

	/* Pointer to industry */

   222

	ind = GetIndustryByTile(ti->tile);

   223

   224

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

   225

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

   226

			GetIndustryAnimationState(ti->tile) & 3 :

   227

			GetIndustryConstructionStage(ti->tile))];

   228

   229

	image = dits->ground.sprite;

   230

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

   231

		pal = GENERAL_SPRITE_COLOR(ind->random_color);

   232

	} else {

   233

		pal = dits->ground.pal;

   234

	}

   235

   236

	z = ti->z;

   237

	/* Add bricks below the industry? */

   238

	if (ti->tileh != SLOPE_FLAT) {

   239

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

   240

		AddChildSpriteScreen(image, pal, 31, 1);

   241

		z += TILE_HEIGHT;

   242

	} else {

   243

		/* Else draw regular ground */

   244

		DrawGroundSprite(image, pal);

   245

	}

   246

   247

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

   248

	image = dits->building.sprite;

   249

	if (image != 0) {

   250

		if (_display_opt & DO_TRANS_BUILDINGS) {

   251

			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);

   252

			pal = PALETTE_TO_TRANSPARENT;

   253

		} else {

   254

			pal = dits->building.pal;

   255

		}

   256

   257

		AddSortableSpriteToDraw(image, pal,

   258

			ti->x + dits->subtile_x,

   259

			ti->y + dits->subtile_y,

   260

			dits->width  + 1,

   261

			dits->height + 1,

   262

			dits->dz,

   263

			z);

   264

   265

		if (_display_opt & DO_TRANS_BUILDINGS) return;

   266

	}

   267

   268

	{

   269

		int proc = dits->draw_proc - 1;

   270

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

   271

	}

   272

}

   273

   274

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

   275

{

   276

	return GetTileMaxZ(tile);

   277

}

   278

   279

static Slope GetSlopeTileh_Industry(TileIndex tile, Slope tileh)

   280

{

   281

	return SLOPE_FLAT;

   282

}

   283

   284

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   285

{

   287

	CargoID a;

   288

   291

   293

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

   294

   296

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

   297

}

   298

   299

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   300

{

   301

	const Industry *i = GetIndustryByTile(tile);

   302

   303

	td->owner = i->owner;

   304

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

   305

	if (!IsIndustryCompleted(tile)) {

   306

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

   307

		td->str = STR_2058_UNDER_CONSTRUCTION;

   308

	}

   309

}

   310

   311

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   312

{

   313

	Industry *i = GetIndustryByTile(tile);

   314

   315

	/* water can destroy industries

   316

	 * in editor you can bulldoze industries

   317

	 * with magic_bulldozer cheat you can destroy industries

   318

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

   319

	 */

   320

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

   321

			!_cheats.magic_bulldozer.value) ||

   322

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

   323

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

   324

		return_cmd_error(STR_4800_IN_THE_WAY);

   325

	}

   326

   327

	if (flags & DC_EXEC) DeleteIndustry(i);

   328

	return 0;

   329

}

   330

   331

static void TransportIndustryGoods(TileIndex tile)

   332

{

   333

	Industry *i = GetIndustryByTile(tile);

   334

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

   335

	uint cw, am;

   336

   337

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

   338

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

   339

		i->cargo_waiting[0] -= cw;

   340

   341

		/* fluctuating economy? */

   342

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

   343

   344

		i->last_mo_production[0] += cw;

   345

   346

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

   347

		i->last_mo_transported[0] += am;

   348

		if (am != 0) {

   349

			uint newgfx = _industry_produce_section[GetIndustryGfx(tile)];

   350

   351

			if (newgfx != 0xFF) {

   352

				ResetIndustryConstructionStage(tile);

   353

				SetIndustryCompleted(tile, true);

   354

				SetIndustryGfx(tile, newgfx);

   355

				MarkTileDirtyByTile(tile);

   356

			}

   357

		}

   358

	}

   359

   360

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

   361

	if (cw > indspec->minimal_cargo) {

   362

		i->cargo_waiting[1] -= cw;

   363

   364

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

   365

   366

		i->last_mo_production[1] += cw;

   367

   368

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

   369

		i->last_mo_transported[1] += am;

   370

	}

   371

}

   372

   373

   374

static void AnimateTile_Industry(TileIndex tile)

   375

{

   376

	byte m;

   377

   378

	switch (GetIndustryGfx(tile)) {

   379

	case GFX_SUGAR_MINE_SIEVE:

   380

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

   381

			m = GetIndustryAnimationState(tile) + 1;

   382

   383

			switch (m & 7) {

   384

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

   385

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

   386

			}

   387

   388

			if (m >= 96) {

   389

				m = 0;

   390

				DeleteAnimatedTile(tile);

   391

			}

   392

			SetIndustryAnimationState(tile, m);

   393

   394

			MarkTileDirtyByTile(tile);

   395

		}

   396

		break;

   397

   398

	case GFX_TOFFEE_QUARY:

   399

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

   400

			m = GetIndustryAnimationState(tile);

   401

   402

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

   403

				SndPlayTileFx(SND_30_CARTOON_SOUND, tile);

   404

			}

   405

   406

			if (++m >= 70) {

   407

				m = 0;

   408

				DeleteAnimatedTile(tile);

   409

			}

   410

			SetIndustryAnimationState(tile, m);

   411

   412

			MarkTileDirtyByTile(tile);

   413

		}

   414

		break;

   415

   416

	case GFX_BUBBLE_CATCHER:

   417

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

   418

			m = GetIndustryAnimationState(tile);

   419

   420

			if (++m >= 40) {

   421

				m = 0;

   422

				DeleteAnimatedTile(tile);

   423

			}

   424

			SetIndustryAnimationState(tile, m);

   425

   426

			MarkTileDirtyByTile(tile);

   427

		}

   428

		break;

   429

   430

	// Sparks on a coal plant

   431

	case GFX_POWERPLANT_SPARKS:

   432

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

   433

			m = GetIndustryAnimationState(tile);

   434

			if (m == 6) {

   435

				SetIndustryAnimationState(tile, 0);

   436

				DeleteAnimatedTile(tile);

   437

			} else {

   438

				SetIndustryAnimationState(tile, m + 1);

   439

				MarkTileDirtyByTile(tile);

   440

			}

   441

		}

   442

		break;

   443

   444

	case GFX_TOY_FACTORY:

   445

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

   446

			m = GetIndustryAnimationState(tile) + 1;

   447

   448

			if (m == 1) {

   449

				SndPlayTileFx(SND_2C_MACHINERY, tile);

   450

			} else if (m == 23) {

   451

				SndPlayTileFx(SND_2B_COMEDY_HIT, tile);

   452

			} else if (m == 28) {

   453

				SndPlayTileFx(SND_2A_EXTRACT_AND_POP, tile);

   454

			}

   455

   456

			if (m >= 50) {

   457

				int n = GetIndustryAnimationLoop(tile) + 1;

   458

				m = 0;

   459

				if (n >= 8) {

   460

					n = 0;

   461

					DeleteAnimatedTile(tile);

   462

				}

   463

				SetIndustryAnimationLoop(tile, n);

   464

			}

   465

			SetIndustryAnimationState(tile, m);

   466

			MarkTileDirtyByTile(tile);

   467

		}

   468

		break;

   469

   470

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:

   471

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:

   472

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:

   473

	case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:

   474

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

   475

			IndustryGfx gfx = GetIndustryGfx(tile);

   476

   477

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

   478

			SetIndustryGfx(tile, gfx);

   479

			MarkTileDirtyByTile(tile);

   480

		}

   481

		break;

   482

   483

	case GFX_OILWELL_ANIMATED_1:

   484

	case GFX_OILWELL_ANIMATED_2:

   485

	case GFX_OILWELL_ANIMATED_3:

   486

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

   487

			bool b = CHANCE16(1,7);

   488

			IndustryGfx gfx = GetIndustryGfx(tile);

   489

   490

			m = GetIndustryAnimationState(tile) + 1;

   491

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

   492

				SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);