1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "command.h"

     7

#include "news.h"

     8

#include "gfx.h"

     9

#include "station.h"

    10

#include "town.h"

    11

#include "industry.h"

    12

#include "player.h"

    13

#include "airport_movement.h"

    14

#include "sound.h"

    15

    16

static void DisasterClearSquare(TileIndex tile)

    17

{

    18

	if (!EnsureNoVehicle(tile))

    19

		return;

    20

    21

	switch (TileType(tile)) {

    22

		case MP_RAILWAY:

    23

			if (IS_HUMAN_PLAYER(_map_owner[tile])) DoClearSquare(tile);

    24

			break;

    25

    26

		case MP_HOUSE: {

    27

			byte p = _current_player;

    28

			_current_player = OWNER_NONE;

    29

			DoCommandByTile(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

    30

			_current_player = p;

    31

			break;

    32

		}

    33

    34

		case MP_TREES:

    35

		case MP_CLEAR:

    36

			DoClearSquare(tile);

    37

			break;

    38

    39

		default:

    40

			break;

    41

	}

    42

}

    43

    44

static const SpriteID _disaster_images_1[] = {0xF41,0xF41,0xF41,0xF41,0xF41,0xF41,0xF41,0xF41};

    45

static const SpriteID _disaster_images_2[] = {0xF44,0xF44,0xF44,0xF44,0xF44,0xF44,0xF44,0xF44};

    46

static const SpriteID _disaster_images_3[] = {0xF4E,0xF4E,0xF4E,0xF4E,0xF4E,0xF4E,0xF4E,0xF4E};

    47

static const SpriteID _disaster_images_4[] = {0xF46,0xF46,0xF47,0xF47,0xF48,0xF48,0xF49,0xF49};

    48

static const SpriteID _disaster_images_5[] = {0xF4A,0xF4A,0xF4B,0xF4B,0xF4C,0xF4C,0xF4D,0xF4D};

    49

static const SpriteID _disaster_images_6[] = {0xF50,0xF50,0xF50,0xF50,0xF50,0xF50,0xF50,0xF50};

    50

static const SpriteID _disaster_images_7[] = {0xF51,0xF51,0xF51,0xF51,0xF51,0xF51,0xF51,0xF51};

    51

static const SpriteID _disaster_images_8[] = {0xF52,0xF52,0xF52,0xF52,0xF52,0xF52,0xF52,0xF52};

    52

static const SpriteID _disaster_images_9[] = {0xF3E,0xF3E,0xF3E,0xF3E,0xF3E,0xF3E,0xF3E,0xF3E};

    53

    54

static const SpriteID * const _disaster_images[] = {

    55

	_disaster_images_1,_disaster_images_1,

    56

	_disaster_images_2,_disaster_images_2,

    57

	_disaster_images_3,_disaster_images_3,

    58

	_disaster_images_8,_disaster_images_8,_disaster_images_9,

    59

	_disaster_images_6,_disaster_images_6,

    60

	_disaster_images_7,_disaster_images_7,

    61

	_disaster_images_4,_disaster_images_5,

    62

};

    63

    64

static void DisasterVehicleUpdateImage(Vehicle *v)

    65

{

    66

	int img = v->u.disaster.image_override;

    67

	if (img == 0)

    68

		img = _disaster_images[v->subtype][v->direction];

    69

	v->cur_image = img;

    70

}

    71

    72

static void InitializeDisasterVehicle(Vehicle *v, int x, int y, byte z, byte direction, byte subtype)

    73

{

    74

	v->type = VEH_Disaster;

    75

	v->x_pos = x;

    76

	v->y_pos = y;

    77

	v->z_pos = z;

    78

	v->tile = TILE_FROM_XY(x,y);

    79

	v->direction = direction;

    80

	v->subtype = subtype;

    81

	v->x_offs = -1;

    82

	v->y_offs = -1;

    83

	v->sprite_width = 2;

    84

	v->sprite_height = 2;

    85

	v->z_height = 5;

    86

	v->owner = OWNER_NONE;

    87

	v->vehstatus = VS_UNCLICKABLE;

    88

	v->u.disaster.image_override = 0;

    89

	v->current_order.type = OT_NOTHING;

    90

	v->current_order.flags = 0;

    91

	v->current_order.station = 0;

    92

    93

	DisasterVehicleUpdateImage(v);

    94

	VehiclePositionChanged(v);

    95

	BeginVehicleMove(v);

    96

	EndVehicleMove(v);

    97

}

    98

    99

static void DeleteDisasterVeh(Vehicle *v)

   100

{

   101

	DeleteVehicleChain(v);

   102

}

   103

   104

static void SetDisasterVehiclePos(Vehicle *v, int x, int y, byte z)

   105

{

   106

	Vehicle *u;

   107

	int yt;

   108

   109

	BeginVehicleMove(v);

   110

	v->x_pos = x;

   111

	v->y_pos = y;

   112

	v->z_pos = z;

   113

	v->tile = TILE_FROM_XY(x,y);

   114

   115

	DisasterVehicleUpdateImage(v);

   116

	VehiclePositionChanged(v);

   117

	EndVehicleMove(v);

   118

   119

	if ( (u=v->next) != NULL) {

   120

		BeginVehicleMove(u);

   121

   122

		u->x_pos = x;

   123

		u->y_pos = yt = y - 1 - (max(z - GetSlopeZ(x, y-1), 0) >> 3);

   124

		u->z_pos = GetSlopeZ(x,yt);

   125

		u->direction = v->direction;

   126

   127

		DisasterVehicleUpdateImage(u);

   128

		VehiclePositionChanged(u);

   129

		EndVehicleMove(u);

   130

   131

		if ( (u=u->next) != NULL) {

   132

			BeginVehicleMove(u);

   133

			u->x_pos = x;

   134

			u->y_pos = y;

   135

			u->z_pos = z + 5;

   136

			VehiclePositionChanged(u);

   137

			EndVehicleMove(u);

   138

		}

   139

	}

   140

}

   141

   142

   143

static void DisasterTick_Zeppeliner(Vehicle *v)

   144

{

   145

	GetNewVehiclePosResult gp;

   146

	Station *st;

   147

	int x,y;

   148

	byte z;

   149

	uint tile;

   150

   151

	++v->tick_counter;

   152

   153

	if (v->current_order.station < 2) {

   154

		if (v->tick_counter&1)

   155

			return;

   156

   157

		GetNewVehiclePos(v, &gp);

   158

   159

		SetDisasterVehiclePos(v, gp.x, gp.y, v->z_pos);

   160

   161

		if (v->current_order.station == 1) {

   162

			if (++v->age == 38) {

   163

				v->current_order.station = 2;

   164

				v->age = 0;

   165

			}

   166

   167

			if ((v->tick_counter&7)==0) {

   168

				CreateEffectVehicleRel(v, 0, -17, 2, EV_SMOKE_3);

   169

			}

   170

		} else if (v->current_order.station == 0) {

   171

			tile = v->tile; /**/

   172

   173

			if (IsTileType(tile, MP_STATION) &&

   174

				IS_BYTE_INSIDE(_map5[tile], 8, 0x43) &&

   175

				IS_HUMAN_PLAYER(_map_owner[tile])) {

   176

   177

				v->current_order.station = 1;

   178

				v->age = 0;

   179

   180

				SetDParam(0, _map2[tile]);

   181

				AddNewsItem(STR_B000_ZEPPELIN_DISASTER_AT,

   182

					NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),

   183

					v->index,

   184

					0);

   185

			}

   186

		}

   187

		if (v->y_pos >= ((int)MapSizeY() + 9) * 16 - 1)

   188

			DeleteDisasterVeh(v);

   189

		return;

   190

	}

   191

   192

	if (v->current_order.station > 2) {

   193

		if (++v->age <= 13320)

   194

			return;

   195

   196

		tile = v->tile; /**/

   197

   198

		if (IsTileType(tile, MP_STATION) &&

   199

			IS_BYTE_INSIDE(_map5[tile], 8, 0x43) &&

   200

			IS_HUMAN_PLAYER(_map_owner[tile])) {

   201

   202

			st = GetStation(_map2[tile]);

   203

			CLRBITS(st->airport_flags, RUNWAY_IN_block);

   204

		}

   205

   206

		SetDisasterVehiclePos(v, v->x_pos, v->y_pos, v->z_pos);

   207

		DeleteDisasterVeh(v);

   208

		return;

   209

	}

   210

   211

	x = v->x_pos;

   212

	y = v->y_pos;

   213

	z = GetSlopeZ(x,y);

   214

	if (z < v->z_pos)

   215

		z = v->z_pos - 1;

   216

	SetDisasterVehiclePos(v, x, y, z);

   217

   218

	if (++v->age == 1) {

   219

		CreateEffectVehicleRel(v, 0, 7, 8, EV_CRASHED_SMOKE);

   220

		SndPlayVehicleFx(SND_12_EXPLOSION, v);

   221

		v->u.disaster.image_override = 0xF42;

   222

	} else if (v->age == 70) {

   223

		v->u.disaster.image_override = 0xF43;

   224

	} else if (v->age <= 300) {

   225

		if (!(v->tick_counter&7)) {

   226

			uint32 r = Random();

   227

   228

			CreateEffectVehicleRel(v,

   229

				-7 + (r&0xF),

   230

				-7 + (r>>4&0xF),

   231

				5 + (r>>8&0x7),

   232

				EV_DEMOLISH);

   233

		}

   234

	} else if (v->age == 350) {

   235

		v->current_order.station = 3;

   236

		v->age = 0;

   237

	}

   238

   239

	tile = v->tile;/**/

   240

	if (IsTileType(tile, MP_STATION) &&

   241

		IS_BYTE_INSIDE(_map5[tile], 8, 0x43) &&

   242

		IS_HUMAN_PLAYER(_map_owner[tile])) {

   243

   244

		st = GetStation(_map2[tile]);

   245

		SETBITS(st->airport_flags, RUNWAY_IN_block);

   246

	}

   247

}

   248

   249

// UFO starts in the middle, and flies around a bit until it locates

   250

// a road vehicle which it targets.

   251

static void DisasterTick_UFO(Vehicle *v)

   252

{

   253

	GetNewVehiclePosResult gp;

   254

	Vehicle *u;

   255

	uint dist;

   256

	byte z;

   257

   258

	v->u.disaster.image_override = (++v->tick_counter & 8) ? 0xF45 : 0xF44;

   259

   260

	if (v->current_order.station == 0) {

   261

// fly around randomly

   262

		int x = TileX(v->dest_tile) * 16;

   263

		int y = TileY(v->dest_tile) * 16;

   264

		if (abs(x - v->x_pos) +	abs(y - v->y_pos) >= 16) {

   265

			v->direction = GetDirectionTowards(v, x, y);

   266

			GetNewVehiclePos(v, &gp);

   267

			SetDisasterVehiclePos(v, gp.x, gp.y, v->z_pos);

   268

			return;

   269

		}

   270

		if (++v->age < 6) {

   271

			v->dest_tile = TILE_MASK(Random());

   272

			return;

   273

		}

   274

		v->current_order.station = 1;

   275

   276

		FOR_ALL_VEHICLES(u) {

   277

			if (u->type == VEH_Road && IS_HUMAN_PLAYER(u->owner)) {

   278

				v->dest_tile = u->index;

   279

				v->age = 0;

   280

				return;

   281

			}

   282

		}

   283

   284

		DeleteDisasterVeh(v);

   285

	} else {

   286

// target a vehicle

   287

		u = GetVehicle(v->dest_tile);

   288

		if (u->type != VEH_Road) {

   289

			DeleteDisasterVeh(v);

   290

			return;

   291

		}

   292

   293

		dist = abs(v->x_pos - u->x_pos) + abs(v->y_pos - u->y_pos);

   294

   295

		if (dist < 16 && !(u->vehstatus&VS_HIDDEN) && u->breakdown_ctr==0) {

   296

			u->breakdown_ctr = 3;

   297

			u->breakdown_delay = 140;

   298

		}

   299

   300

		v->direction = GetDirectionTowards(v, u->x_pos, u->y_pos);

   301

		GetNewVehiclePos(v, &gp);

   302

   303

		z = v->z_pos;

   304

		if (dist <= 16 && z > u->z_pos) z--;

   305

		SetDisasterVehiclePos(v, gp.x, gp.y, z);

   306

   307

		if (z <= u->z_pos && (u->vehstatus&VS_HIDDEN)==0) {

   308

			v->age++;

   309

			if (u->u.road.crashed_ctr == 0) {

   310

				u->u.road.crashed_ctr++;

   311

				u->vehstatus |= VS_CRASHED;

   312

   313

				AddNewsItem(STR_B001_ROAD_VEHICLE_DESTROYED,

   314

					NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),

   315

					u->index,

   316

					0);

   317

			}

   318

		}

   319

   320

// destroy?

   321

		if (v->age > 50) {

   322

			CreateEffectVehicleRel(v, 0, 7, 8, EV_CRASHED_SMOKE);

   323

			SndPlayVehicleFx(SND_12_EXPLOSION, v);

   324

			DeleteDisasterVeh(v);

   325

		}

   326

	}

   327

}

   328

   329

static void DestructIndustry(Industry *i)

   330

{

   331

	uint tile;

   332

   333

	for(tile=0; tile != MapSize(); tile++) {

   334

		if (IsTileType(tile, MP_INDUSTRY) &&	_map2[tile] == i->index) {

   335

			_map_owner[tile] = 0;

   336

			MarkTileDirtyByTile(tile);

   337

		}

   338

	}

   339

}

   340

   341

// Airplane which destroys an oil refinery

   342

static void DisasterTick_2(Vehicle *v)

   343

{

   344

	GetNewVehiclePosResult gp;

   345

   346

	v->tick_counter++;

   347

	v->u.disaster.image_override =

   348

		(v->current_order.station == 1 && v->tick_counter&4) ? 0xF4F : 0;

   349

   350

	GetNewVehiclePos(v, &gp);

   351

	SetDisasterVehiclePos(v, gp.x, gp.y, v->z_pos);

   352

   353

	if (gp.x < -160) {

   354

		DeleteDisasterVeh(v);

   355

		return;

   356

	}

   357

   358

	if (v->current_order.station == 2) {

   359

		if (!(v->tick_counter&3)) {

   360

			Industry *i = GetIndustry(v->dest_tile);

   361

			int x = TileX(i->xy) * 16;

   362

			int y = TileY(i->xy) * 16;

   363

			uint32 r = Random();

   364

   365

			CreateEffectVehicleAbove(

   366

				x + (r & 0x3F),

   367

				y + (r >> 6 & 0x3F),

   368

				(r >> 12 & 0xF),

   369

				EV_DEMOLISH);

   370

   371

			if (++v->age >= 55)

   372

				v->current_order.station = 3;

   373

		}

   374

	} else if (v->current_order.station == 1) {

   375

		if (++v->age == 112) {

   376

			Industry *i;

   377

   378

			v->current_order.station = 2;

   379

			v->age = 0;

   380

   381

			i = GetIndustry(v->dest_tile);

   382

			DestructIndustry(i);

   383

   384

			SetDParam(0, i->town->index);

   385

			AddNewsItem(STR_B002_OIL_REFINERY_EXPLOSION, NEWS_FLAGS(NM_THIN,NF_VIEWPORT|NF_TILE,NT_ACCIDENT,0), i->xy, 0);

   386

			SndPlayTileFx(SND_12_EXPLOSION, i->xy);

   387

		}

   388

	} else if (v->current_order.station == 0) {

   389

		int x,y;

   390

		uint tile;

   391

		int ind;

   392

   393

		x = v->x_pos - 15*16;

   394

		y = v->y_pos;

   395

   396

		if ( (uint)x > MapMaxX() * 16-1)

   397

			return;

   398

   399

		tile = TILE_FROM_XY(x,y);

   400

		if (!IsTileType(tile, MP_INDUSTRY))

   401

			return;

   402

   403

		v->dest_tile = ind = _map2[tile];

   404

   405

		if (GetIndustry(ind)->type == IT_OIL_REFINERY) {

   406

			v->current_order.station = 1;

   407

			v->age = 0;

   408

		}

   409

	}

   410

}

   411

   412

// Helicopter which destroys a factory

   413

static void DisasterTick_3(Vehicle *v)

   414

{

   415

	GetNewVehiclePosResult gp;

   416

   417

	v->tick_counter++;

   418

	v->u.disaster.image_override =

   419

		(v->current_order.station == 1 && v->tick_counter&4) ? 0xF53 : 0;

   420

   421

	GetNewVehiclePos(v, &gp);

   422

	SetDisasterVehiclePos(v, gp.x, gp.y, v->z_pos);

   423

   424

	if (gp.x > (int)MapSizeX() * 16 + 9*16 - 1) {

   425

		DeleteDisasterVeh(v);

   426

		return;

   427

	}

   428

   429

	if (v->current_order.station == 2) {

   430

		if (!(v->tick_counter&3)) {

   431

			Industry *i = GetIndustry(v->dest_tile);

   432

			int x = TileX(i->xy) * 16;

   433

			int y = TileY(i->xy) * 16;

   434

			uint32 r = Random();

   435

   436

			CreateEffectVehicleAbove(

   437

				x + (r & 0x3F),

   438

				y + (r >> 6 & 0x3F),

   439

				(r >> 12 & 0xF),

   440

				EV_DEMOLISH);

   441

   442

			if (++v->age >= 55)

   443

				v->current_order.station = 3;

   444

		}

   445

	} else if (v->current_order.station == 1) {

   446

		if (++v->age == 112) {

   447

			Industry *i;

   448

   449

			v->current_order.station = 2;

   450

			v->age = 0;

   451

   452

			i = GetIndustry(v->dest_tile);

   453

			DestructIndustry(i);

   454

   455

			SetDParam(0, i->town->index);

   456

			AddNewsItem(STR_B003_FACTORY_DESTROYED_IN_SUSPICIOUS, NEWS_FLAGS(NM_THIN,NF_VIEWPORT|NF_TILE,NT_ACCIDENT,0), i->xy, 0);

   457

			SndPlayTileFx(SND_12_EXPLOSION, i->xy);

   458

		}

   459

	} else if (v->current_order.station == 0) {

   460

		int x,y;

   461

		uint tile;

   462

		int ind;

   463

   464

		x = v->x_pos - 15*16;

   465

		y = v->y_pos;

   466

   467

		if ( (uint)x > MapMaxX() * 16-1)

   468

			return;

   469

   470

		tile = TILE_FROM_XY(x,y);

   471

		if (!IsTileType(tile, MP_INDUSTRY))

   472

			return;

   473

   474

		v->dest_tile = ind = _map2[tile];

   475

   476

		if (GetIndustry(ind)->type == IT_FACTORY) {

   477

			v->current_order.station = 1;

   478

			v->age = 0;

   479

		}

   480

	}

   481

}

   482

   483

// Helicopter rotor blades

   484

static void DisasterTick_3b(Vehicle *v)

   485

{

   486

	if (++v->tick_counter & 1)

   487

		return;

   488

   489

	if (++v->cur_image == 0xF40 + 1)

   490

		v->cur_image = 0xF3E;

   491

   492

	VehiclePositionChanged(v);

   493

	BeginVehicleMove(v);

   494

	EndVehicleMove(v);

   495

}

   496

   497

// Big UFO which lands on a piece of rail.

   498

// Will be shot down by a plane

   499

static void DisasterTick_4(Vehicle *v)

   500

{

   501

	GetNewVehiclePosResult gp;

   502

	byte z;

   503

	Vehicle *u,*w;

   504

	Town *t;

   505

	uint tile,tile_org;

   506

   507

	v->tick_counter++;

   508

   509

	if (v->current_order.station == 1) {

   510

		int x = TileX(v->dest_tile) * 16 + 8;

   511

		int y = TileY(v->dest_tile) * 16 + 8;

   512

		if (abs(v->x_pos - x) + abs(v->y_pos - y) >= 8) {

   513

			v->direction = GetDirectionTowards(v, x, y);

   514