1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "viewport.h"

     7

#include "command.h"

     8

#include "industry.h"

     9

#include "town.h"

    10

#include "vehicle.h"

    11

#include "news.h"

    12

#include "saveload.h"

    13

#include "economy.h"

    14

#include "sound.h"

    15

    16

enum {

    17

	/* Max industries: 64000 (8 * 8000) */

    18

	INDUSTRY_POOL_BLOCK_SIZE_BITS = 3,       /* In bits, so (1 << 3) == 8 */

    19

	INDUSTRY_POOL_MAX_BLOCKS      = 8000,

    20

};

    21

    22

/**

    23

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

    24

 */

    25

void IndustryPoolNewBlock(uint start_item)

    26

{

    27

	Industry *i;

    28

    29

	FOR_ALL_INDUSTRIES_FROM(i, start_item)

    30

		i->index = start_item++;

    31

}

    32

    33

/* Initialize the industry-pool */

    34

MemoryPool _industry_pool = { "Industry", INDUSTRY_POOL_MAX_BLOCKS, INDUSTRY_POOL_BLOCK_SIZE_BITS, sizeof(Industry), &IndustryPoolNewBlock, 0, 0, NULL };

    35

    36

byte _industry_sound_ctr;

    37

TileIndex _industry_sound_tile;

    38

    39

void ShowIndustryViewWindow(int industry);

    40

void BuildOilRig(TileIndex tile);

    41

void DeleteOilRig(TileIndex tile);

    42

    43

typedef struct DrawIndustryTileStruct {

    44

	uint32 sprite_1;

    45

	uint32 sprite_2;

    46

    47

	byte subtile_xy;

    48

	byte width_height;

    49

	byte dz;

    50

	byte proc;

    51

} DrawIndustryTileStruct;

    52

    53

    54

typedef struct DrawIndustrySpec1Struct {

    55

	byte x;

    56

	byte image_1;

    57

	byte image_2;

    58

	byte image_3;

    59

} DrawIndustrySpec1Struct;

    60

    61

typedef struct DrawIndustrySpec4Struct {

    62

	byte image_1;

    63

	byte image_2;

    64

	byte image_3;

    65

} DrawIndustrySpec4Struct;

    66

    67

typedef struct IndustryTileTable {

    68

	TileIndexDiffC ti;

    69

	byte map5;

    70

} IndustryTileTable;

    71

    72

typedef struct IndustrySpec {

    73

	const IndustryTileTable *const *table;

    74

	byte num_table;

    75

	byte a,b,c;

    76

	byte produced_cargo[2];

    77

	byte production_rate[2];

    78

	byte accepts_cargo[3];

    79

	byte check_proc;

    80

} IndustrySpec;

    81

    82

#include "table/industry_land.h"

    83

#include "table/build_industry.h"

    84

    85

typedef enum IndustryType {

    86

	INDUSTRY_NOT_CLOSABLE,     //! Industry can never close

    87

	INDUSTRY_PRODUCTION,       //! Industry can close and change of production

    88

	INDUSTRY_CLOSABLE,         //! Industry can only close (no production change)

    89

} IndustryType;

    90

    91

    92

static const IndustryType _industry_close_mode[37] = {

    93

	/* COAL_MINE */         INDUSTRY_PRODUCTION,

    94

	/* POWER_STATION */     INDUSTRY_NOT_CLOSABLE,

    95

	/* SAWMILL */           INDUSTRY_CLOSABLE,

    96

	/* FOREST */            INDUSTRY_PRODUCTION,

    97

	/* OIL_REFINERY */      INDUSTRY_CLOSABLE,

    98

	/* OIL_RIG */           INDUSTRY_PRODUCTION,

    99

	/* FACTORY */           INDUSTRY_CLOSABLE,

   100

	/* PRINTING_WORKS */    INDUSTRY_CLOSABLE,

   101

	/* STEEL_MILL */        INDUSTRY_CLOSABLE,

   102

	/* FARM */              INDUSTRY_PRODUCTION,

   103

	/* COPPER_MINE */       INDUSTRY_PRODUCTION,

   104

	/* OIL_WELL */          INDUSTRY_PRODUCTION,

   105

	/* BANK */              INDUSTRY_NOT_CLOSABLE,

   106

	/* FOOD_PROCESS */      INDUSTRY_CLOSABLE,

   107

	/* PAPER_MILL */        INDUSTRY_CLOSABLE,

   108

	/* GOLD_MINE */         INDUSTRY_PRODUCTION,

   109

	/* BANK_2,  */          INDUSTRY_NOT_CLOSABLE,

   110

	/* DIAMOND_MINE */      INDUSTRY_PRODUCTION,

   111

	/* IRON_MINE */         INDUSTRY_PRODUCTION,

   112

	/* FRUIT_PLANTATION */  INDUSTRY_PRODUCTION,

   113

	/* RUBBER_PLANTATION */ INDUSTRY_PRODUCTION,

   114

	/* WATER_SUPPLY */      INDUSTRY_PRODUCTION,

   115

	/* WATER_TOWER */       INDUSTRY_NOT_CLOSABLE,

   116

	/* FACTORY_2 */         INDUSTRY_CLOSABLE,

   117

	/* FARM_2 */            INDUSTRY_PRODUCTION,

   118

	/* LUMBER_MILL */       INDUSTRY_CLOSABLE,

   119

	/* COTTON_CANDY */      INDUSTRY_PRODUCTION,

   120

	/* CANDY_FACTORY */     INDUSTRY_CLOSABLE,

   121

	/* BATTERY_FARM */      INDUSTRY_PRODUCTION,

   122

	/* COLA_WELLS */        INDUSTRY_PRODUCTION,

   123

	/* TOY_SHOP */          INDUSTRY_NOT_CLOSABLE,

   124

	/* TOY_FACTORY */       INDUSTRY_CLOSABLE,

   125

	/* PLASTIC_FOUNTAINS */ INDUSTRY_PRODUCTION,

   126

	/* FIZZY_DRINK_FACTORY */INDUSTRY_CLOSABLE,

   127

	/* BUBBLE_GENERATOR */  INDUSTRY_PRODUCTION,

   128

	/* TOFFEE_QUARRY */     INDUSTRY_PRODUCTION,

   129

	/* SUGAR_MINE */        INDUSTRY_PRODUCTION

   130

};

   131

   132

static const StringID _industry_prod_up_strings[] = {

   133

	STR_4836_NEW_COAL_SEAM_FOUND_AT,

   134

	STR_4835_INCREASES_PRODUCTION,

   135

	STR_4835_INCREASES_PRODUCTION,

   136

	STR_4835_INCREASES_PRODUCTION,

   137

	STR_4835_INCREASES_PRODUCTION,

   138

	STR_4837_NEW_OIL_RESERVES_FOUND,

   139

	STR_4835_INCREASES_PRODUCTION,

   140

	STR_4835_INCREASES_PRODUCTION,

   141

	STR_4835_INCREASES_PRODUCTION,

   142

	STR_4838_IMPROVED_FARMING_METHODS,

   143

	STR_4835_INCREASES_PRODUCTION,

   144

	STR_4837_NEW_OIL_RESERVES_FOUND,

   145

	STR_4835_INCREASES_PRODUCTION,

   146

	STR_4835_INCREASES_PRODUCTION,

   147

	STR_4835_INCREASES_PRODUCTION,

   148

	STR_4835_INCREASES_PRODUCTION,

   149

	STR_4835_INCREASES_PRODUCTION,

   150

	STR_4835_INCREASES_PRODUCTION,

   151

	STR_4835_INCREASES_PRODUCTION,

   152

	STR_4838_IMPROVED_FARMING_METHODS,

   153

	STR_4838_IMPROVED_FARMING_METHODS,

   154

	STR_4835_INCREASES_PRODUCTION,

   155

	STR_4835_INCREASES_PRODUCTION,

   156

	STR_4835_INCREASES_PRODUCTION,

   157

	STR_4838_IMPROVED_FARMING_METHODS,

   158

	STR_4835_INCREASES_PRODUCTION,

   159

	STR_4838_IMPROVED_FARMING_METHODS,

   160

	STR_4835_INCREASES_PRODUCTION,

   161

	STR_4838_IMPROVED_FARMING_METHODS,

   162

	STR_4835_INCREASES_PRODUCTION,

   163

	STR_4835_INCREASES_PRODUCTION,

   164

	STR_4835_INCREASES_PRODUCTION,

   165

	STR_4835_INCREASES_PRODUCTION,

   166

	STR_4835_INCREASES_PRODUCTION,

   167

	STR_4835_INCREASES_PRODUCTION,

   168

	STR_4835_INCREASES_PRODUCTION,

   169

	STR_4835_INCREASES_PRODUCTION,

   170

};

   171

   172

static const StringID _industry_prod_down_strings[] = {

   173

	STR_4839_PRODUCTION_DOWN_BY_50,

   174

	STR_4839_PRODUCTION_DOWN_BY_50,

   175

	STR_4839_PRODUCTION_DOWN_BY_50,

   176

	STR_483A_INSECT_INFESTATION_CAUSES,

   177

	STR_4839_PRODUCTION_DOWN_BY_50,

   178

	STR_4839_PRODUCTION_DOWN_BY_50,

   179

	STR_4839_PRODUCTION_DOWN_BY_50,

   180

	STR_4839_PRODUCTION_DOWN_BY_50,

   181

	STR_4839_PRODUCTION_DOWN_BY_50,

   182

	STR_483A_INSECT_INFESTATION_CAUSES,

   183

	STR_4839_PRODUCTION_DOWN_BY_50,

   184

	STR_4839_PRODUCTION_DOWN_BY_50,

   185

	STR_4839_PRODUCTION_DOWN_BY_50,

   186

	STR_4839_PRODUCTION_DOWN_BY_50,

   187

	STR_4839_PRODUCTION_DOWN_BY_50,

   188

	STR_4839_PRODUCTION_DOWN_BY_50,

   189

	STR_4839_PRODUCTION_DOWN_BY_50,

   190

	STR_4839_PRODUCTION_DOWN_BY_50,

   191

	STR_4839_PRODUCTION_DOWN_BY_50,

   192

	STR_483A_INSECT_INFESTATION_CAUSES,

   193

	STR_483A_INSECT_INFESTATION_CAUSES,

   194

	STR_4839_PRODUCTION_DOWN_BY_50,

   195

	STR_4839_PRODUCTION_DOWN_BY_50,

   196

	STR_4839_PRODUCTION_DOWN_BY_50,

   197

	STR_483A_INSECT_INFESTATION_CAUSES,

   198

	STR_4839_PRODUCTION_DOWN_BY_50,

   199

	STR_4839_PRODUCTION_DOWN_BY_50,

   200

	STR_4839_PRODUCTION_DOWN_BY_50,

   201

	STR_483A_INSECT_INFESTATION_CAUSES,

   202

	STR_4839_PRODUCTION_DOWN_BY_50,

   203

	STR_4839_PRODUCTION_DOWN_BY_50,

   204

	STR_4839_PRODUCTION_DOWN_BY_50,

   205

	STR_4839_PRODUCTION_DOWN_BY_50,

   206

	STR_4839_PRODUCTION_DOWN_BY_50,

   207

	STR_4839_PRODUCTION_DOWN_BY_50,

   208

	STR_4839_PRODUCTION_DOWN_BY_50,

   209

	STR_4839_PRODUCTION_DOWN_BY_50,

   210

};

   211

   212

static const StringID _industry_close_strings[] = {

   213

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   214

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   215

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   216

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   217

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   218

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   219

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   220

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   221

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   222

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   223

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   224

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   225

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   226

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   227

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   228

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   229

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   230

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   231

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   232

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   233

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   234

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   235

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   236

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   237

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   238

	STR_4834_LACK_OF_NEARBY_TREES_CAUSES,

   239

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   240

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   241

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   242

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   243

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   244

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   245

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   246

	STR_4833_SUPPLY_PROBLEMS_CAUSE_TO,

   247

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   248

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE,

   249

	STR_4832_ANNOUNCES_IMMINENT_CLOSURE	,

   250

};

   251

   252

   253

static void IndustryDrawTileProc1(TileInfo *ti)

   254

{

   255

	const DrawIndustrySpec1Struct *d;

   256

	uint32 image;

   257

   258

	if (!(_map_owner[ti->tile] & 0x80))

   259

		return;

   260

   261

	d = &_draw_industry_spec1[_map3_lo[ti->tile]];

   262

   263

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

   264

   265

	if ( (image = d->image_2) != 0)

   266

		AddChildSpriteScreen(0x12B0 + image - 1, 8, 41);

   267

   268

	if ( (image = d->image_3) != 0)

   269

		AddChildSpriteScreen(0x12AC + image - 1,

   270

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

   271

}

   272

   273

static void IndustryDrawTileProc2(TileInfo *ti)

   274

{

   275

	int x = 0;

   276

   277

	if (_map_owner[ti->tile] & 0x80) {

   278

		x = _industry_anim_offs[_map3_lo[ti->tile]];

   279

		if ( (byte)x == 0xFF)

   280

			x = 0;

   281

	}

   282

   283

	AddChildSpriteScreen(0x129F, 22-x, x+24);

   284

	AddChildSpriteScreen(0x129E, 6, 0xE);

   285

}

   286

   287

static void IndustryDrawTileProc3(TileInfo *ti)

   288

{

   289

	if (_map_owner[ti->tile] & 0x80) {

   290

		AddChildSpriteScreen(0x128B, 5,

   291

			_industry_anim_offs_2[_map3_lo[ti->tile]]);

   292

	}

   293

	AddChildSpriteScreen(4746, 3, 67);

   294

}

   295

   296

static void IndustryDrawTileProc4(TileInfo *ti)

   297

{

   298

	const DrawIndustrySpec4Struct *d;

   299

   300

	d = &_industry_anim_offs_3[_map3_lo[ti->tile]];

   301

   302

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

   303

		AddChildSpriteScreen(0x126F, 0x32 - d->image_1 * 2, 0x60 + d->image_1);

   304

	}

   305

   306

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

   307

		AddChildSpriteScreen(0x1270, 0x10 - d->image_2*2, 100 + d->image_2);

   308

	}

   309

   310

	AddChildSpriteScreen(0x126E, 7, d->image_3);

   311

	AddChildSpriteScreen(0x126D, 0, 42);

   312

}

   313

   314

static void DrawCoalPlantSparkles(TileInfo *ti)

   315

{

   316

	int image = _map_owner[ti->tile];

   317

	if (image & 0x80) {

   318

		image = (image >> 2) & 0x1F;

   319

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

   320

			AddChildSpriteScreen(image + 0x806,

   321

				_coal_plant_sparkles_x[image-1],

   322

				_coal_plant_sparkles_y[image-1]

   323

			);

   324

		}

   325

	}

   326

}

   327

   328

typedef void IndustryDrawTileProc(TileInfo *ti);

   329

static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {

   330

	IndustryDrawTileProc1,

   331

	IndustryDrawTileProc2,

   332

	IndustryDrawTileProc3,

   333

	IndustryDrawTileProc4,

   334

	DrawCoalPlantSparkles,

   335

};

   336

   337

static void DrawTile_Industry(TileInfo *ti)

   338

{

   339

	Industry *ind;

   340

	const DrawIndustryTileStruct *dits;

   341

	byte z;

   342

	uint32 image, ormod;

   343

   344

	/* Pointer to industry */

   345

	ind = GetIndustry(_map2[ti->tile]);

   346

	ormod = (ind->color_map+0x307)<<16;

   347

   348

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

   349

	dits = &_industry_draw_tile_data[(ti->map5<<2) | (_map_owner[ti->tile]&3)];

   350

   351

	image = dits->sprite_1;

   352

	if (image&0x8000 && (image & 0xFFFF0000) == 0)

   353

		image |= ormod;

   354

   355

	z = ti->z;

   356

	/* Add bricks below the industry? */

   357

	if (ti->tileh & 0xF) {

   358

		AddSortableSpriteToDraw((ti->tileh & 0xF) + 0x3DD, ti->x, ti->y, 16, 16, 7, z);

   359

		AddChildSpriteScreen(image, 0x1F, 1);

   360

		z += 8;

   361

	} else {

   362

		/* Else draw regular ground */

   363

		DrawGroundSprite(image);

   364

	}

   365

   366

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

   367

	if ((image = dits->sprite_2) != 0) {

   368

   369

		if (image&0x8000 && (image & 0xFFFF0000) == 0)

   370

			image |= ormod;

   371

   372

		if (_display_opt & DO_TRANS_BUILDINGS)

   373

			image = (image & 0x3FFF) | 0x3224000;

   374

   375

		AddSortableSpriteToDraw(image,

   376

			ti->x | (dits->subtile_xy>>4),

   377

			ti->y | (dits->subtile_xy&0xF),

   378

			(dits->width_height>>4)+1,

   379

			(dits->width_height&0xF)+1,

   380

			dits->dz,

   381

			z);

   382

   383

		if (_display_opt & DO_TRANS_BUILDINGS)

   384

			return;

   385

	}

   386

   387

	/* TTDBUG: strange code here, return if AddSortableSpriteToDraw failed?  */

   388

		{

   389

		int proc;

   390

		if ((proc=dits->proc-1) >= 0 )

   391

			_industry_draw_tile_procs[proc](ti);

   392

	}

   393

}

   394

   395

   396

static uint GetSlopeZ_Industry(TileInfo *ti) {

   397

	return GetPartialZ(ti->x&0xF, ti->y&0xF, ti->tileh) + ti->z;

   398

}

   399

   400

static uint GetSlopeTileh_Industry(TileInfo *ti) {

   401

	return 0;

   402

}

   403

   404

static void GetAcceptedCargo_Industry(TileIndex tile, AcceptedCargo ac)

   405

{

   406

	int m5 = _map5[tile];

   407

	int a;

   408

   409

	a = _industry_map5_accepts_1[m5];

   410

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

   411

   412

	a = _industry_map5_accepts_2[m5];

   413

	if (a >= 0) ac[a] = 8;

   414

   415

	a = _industry_map5_accepts_3[m5];

   416

	if (a >= 0) ac[a] = 8;

   417

}

   418

   419

static void GetTileDesc_Industry(TileIndex tile, TileDesc *td)

   420

{

   421

	Industry *i = GetIndustry(_map2[tile]);

   422

   423

	td->owner = i->owner;

   424

	td->str = STR_4802_COAL_MINE + i->type;

   425

	if ((_map_owner[tile] & 0x80) == 0) {

   426

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

   427

		td->str = STR_2058_UNDER_CONSTRUCTION;

   428

	}

   429

}

   430

   431

static int32 ClearTile_Industry(TileIndex tile, byte flags)

   432

{

   433

	Industry *i = GetIndustry(_map2[tile]);

   434

   435

	/*	* water can destroy industries

   436

			* in editor you can bulldoze industries

   437

			* with magic_bulldozer cheat you can destroy industries

   438

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

   439

	*/

   440

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

   441

			!_cheats.magic_bulldozer.value) ||

   442

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

   443

 		SetDParam(0, STR_4802_COAL_MINE + i->type);

   444

		return_cmd_error(STR_4800_IN_THE_WAY);

   445

	}

   446

   447

	if (flags & DC_EXEC) {

   448

 		DeleteIndustry(i);

   449

	}

   450

	return 0;

   451

}

   452

   453

   454

static const byte _industry_min_cargo[] = {

   455

	5, 5, 5, 30, 5, 5, 5, 5,

   456

	5, 5, 5, 5, 2, 5, 5, 5,

   457

	5, 5, 5, 15, 15, 5, 5, 5,

   458

	5, 5, 30, 5, 30, 5, 5, 5,

   459

	5, 5, 5, 5, 5,

   460

};

   461

   462

static void TransportIndustryGoods(TileIndex tile)

   463

{

   464

	Industry *i;

   465

	int type;

   466

	uint cw, am;

   467

	byte m5;

   468

   469

	i = GetIndustry(_map2[tile]);

   470

   471

	type = i->type;

   472

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

   473

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

   474

		i->cargo_waiting[0] -= cw;

   475

   476

		/* fluctuating economy? */

   477

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

   478

   479

		i->last_mo_production[0] += cw;

   480

   481

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

   482

		i->last_mo_transported[0] += am;

   483

		if (am != 0 && (m5 = _industry_produce_map5[_map5[tile]]) != 0xFF) {

   484

			_map5[tile] = m5;

   485

			_map_owner[tile] = 0x80;

   486

			MarkTileDirtyByTile(tile);

   487

		}

   488

	}

   489

   490

	type = i->type;

   491

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

   492

	if (cw > _industry_min_cargo[type]) {

   493

		i->cargo_waiting[1] -= cw;

   494

   495

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

   496

   497

		i->last_mo_production[1] += cw;

   498

   499

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

   500

		i->last_mo_transported[1] += am;

   501

	}

   502

}

   503

   504

   505

static void AnimateTile_Industry(TileIndex tile)

   506

{

   507

	byte m,n;

   508

   509

	switch(_map5[tile]) {

   510

	case 174:

   511

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

   512

			m = _map3_lo[tile] + 1;

   513

   514

			switch(m & 7) {

   515

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

   516

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