1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.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(uint tile)

    17

{

    18

	int type;

    19

    20

	if (!EnsureNoVehicle(tile))

    21

		return;

    22

    23

	type = _map_type_and_height[tile] >> 4;

    24

    25

	if (type == MP_RAILWAY) {

    26

		if (IS_HUMAN_PLAYER(_map_owner[tile]))

    27

			DoClearSquare(tile);

    28

	} else if (type == MP_HOUSE) {

    29

		byte p = _current_player;

    30

		_current_player = OWNER_NONE;

    31

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

    32

		_current_player = p;

    33

	} else if (type == MP_TREES || type == MP_CLEAR) {

    34

		DoClearSquare(tile);

    35

	}

    36

}

    37

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

    48

static const SpriteID * const _disaster_images[] = {

    49

	_disaster_images_1,_disaster_images_1,

    50

	_disaster_images_2,_disaster_images_2,

    51

	_disaster_images_3,_disaster_images_3,

    52

	_disaster_images_8,_disaster_images_8,_disaster_images_9,

    53

	_disaster_images_6,_disaster_images_6,

    54

	_disaster_images_7,_disaster_images_7,

    55

	_disaster_images_4,_disaster_images_5,

    56

};

    57

    58

static void DisasterVehicleUpdateImage(Vehicle *v)

    59

{

    60

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

    61

	if (img == 0)

    62

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

    63

	v->cur_image = img;

    64

}

    65

    66

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

    67

{

    68

	v->type = VEH_Disaster;

    69

	v->x_pos = x;

    70

	v->y_pos = y;

    71

	v->z_pos = z;

    72

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

    73

	v->direction = direction;

    74

	v->subtype = subtype;

    75

	v->x_offs = -1;

    76

	v->y_offs = -1;

    77

	v->sprite_width = 2;

    78

	v->sprite_height = 2;

    79

	v->z_height = 5;

    80

	v->owner = OWNER_NONE;

    81

	v->vehstatus = VS_UNCLICKABLE;

    82

	v->u.disaster.image_override = 0;

    83

	v->current_order.type = OT_NOTHING;

    84

	v->current_order.flags = 0;

    85

	v->current_order.station = 0;

    86

    87

	DisasterVehicleUpdateImage(v);

    88

	VehiclePositionChanged(v);

    89

	BeginVehicleMove(v);

    90

	EndVehicleMove(v);

    91

}

    92

    93

static void DeleteDisasterVeh(Vehicle *v)

    94

{

    95

	DeleteVehicleChain(v);

    96

}

    97

    98

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

    99

{

   100

	Vehicle *u;

   101

	int yt;

   102

   103

	BeginVehicleMove(v);

   104

	v->x_pos = x;

   105

	v->y_pos = y;

   106

	v->z_pos = z;

   107

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

   108

   109

	DisasterVehicleUpdateImage(v);

   110

	VehiclePositionChanged(v);

   111

	EndVehicleMove(v);

   112

   113

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

   114

		BeginVehicleMove(u);

   115

   116

		u->x_pos = x;

   117

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

   118

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

   119

		u->direction = v->direction;

   120

   121

		DisasterVehicleUpdateImage(u);

   122

		VehiclePositionChanged(u);

   123

		EndVehicleMove(u);

   124

   125

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

   126

			BeginVehicleMove(u);

   127

			u->x_pos = x;

   128

			u->y_pos = y;

   129

			u->z_pos = z + 5;

   130

			VehiclePositionChanged(u);

   131

			EndVehicleMove(u);

   132

		}

   133

	}

   134

}

   135

   136

   137

static void DisasterTick_Zeppeliner(Vehicle *v)

   138

{

   139

	GetNewVehiclePosResult gp;

   140

	Station *st;

   141

	int x,y;

   142

	byte z;

   143

	uint tile;

   144

   145

	++v->tick_counter;

   146

   147

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

   148

		if (v->tick_counter&1)

   149

			return;

   150

   151

		GetNewVehiclePos(v, &gp);

   152

   153

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

   154

   155

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

   156

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

   157

				v->current_order.station = 2;

   158

				v->age = 0;

   159

			}

   160

   161

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

   162

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

   163

			}

   164

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

   165

			tile = v->tile; /**/

   166

   167

			if (IS_TILETYPE(tile, MP_STATION) &&

   168

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

   169

				IS_HUMAN_PLAYER(_map_owner[tile])) {

   170

   171

				v->current_order.station = 1;

   172

				v->age = 0;

   173

   174

				SetDParam(0, _map2[tile]);

   175

				AddNewsItem(STR_B000_ZEPPELIN_DISASTER_AT,

   176

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

   177

					v->index,

   178

					0);

   179

			}

   180

		}

   181

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

   182

			DeleteDisasterVeh(v);

   183

		return;

   184

	}

   185

   186

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

   187

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

   188

			return;

   189

   190

		tile = v->tile; /**/

   191

   192

		if (IS_TILETYPE(tile, MP_STATION) &&

   193

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

   194

			IS_HUMAN_PLAYER(_map_owner[tile])) {

   195

   196

			st = DEREF_STATION(_map2[tile]);

   197

			CLRBITS(st->airport_flags, RUNWAY_IN_block);

   198

		}

   199

   200

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

   201

		DeleteDisasterVeh(v);

   202

		return;

   203

	}

   204

   205

	x = v->x_pos;

   206

	y = v->y_pos;

   207

	z = GetSlopeZ(x,y);

   208

	if (z < v->z_pos)

   209

		z = v->z_pos - 1;

   210

	SetDisasterVehiclePos(v, x, y, z);

   211

   212

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

   213

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

   214

		SndPlayVehicleFx(SND_12_EXPLOSION, v);

   215

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

   216

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

   217

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

   218

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

   219

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

   220

			uint32 r = Random();

   221

   222

			CreateEffectVehicleRel(v,

   223

				-7 + (r&0xF),

   224

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

   225

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

   226

				EV_DEMOLISH);

   227

		}

   228

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

   229

		v->current_order.station = 3;

   230

		v->age = 0;

   231

	}

   232

   233

	tile = v->tile;/**/

   234

	if (IS_TILETYPE(tile, MP_STATION) &&

   235

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

   236

		IS_HUMAN_PLAYER(_map_owner[tile])) {

   237

   238

		st = DEREF_STATION(_map2[tile]);

   239

		SETBITS(st->airport_flags, RUNWAY_IN_block);

   240

	}

   241

}

   242

   243

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

   244

// a road vehicle which it targets.

   245

static void DisasterTick_UFO(Vehicle *v)

   246

{

   247

	GetNewVehiclePosResult gp;

   248

	Vehicle *u;

   249

	uint dist;

   250

	byte z;

   251

   252

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

   253

   254

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

   255

// fly around randomly

   256

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

   257

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

   258

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

   259

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

   260

			GetNewVehiclePos(v, &gp);

   261

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

   262

			return;

   263

		}

   264

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

   265

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

   266

			return;

   267

		}

   268

		v->current_order.station = 1;

   269

   270

		FOR_ALL_VEHICLES(u) {

   271

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

   272

				v->dest_tile = u->index;

   273

				v->age = 0;

   274

				return;

   275

			}

   276

		}

   277

   278

		DeleteDisasterVeh(v);

   279

	} else {

   280

// target a vehicle

   281

		u = &_vehicles[v->dest_tile];

   282

		if (u->type != VEH_Road) {

   283

			DeleteDisasterVeh(v);

   284

			return;

   285

		}

   286

   287

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

   288

   289

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

   290

			u->breakdown_ctr = 3;

   291

			u->breakdown_delay = 140;

   292

		}

   293

   294

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

   295

		GetNewVehiclePos(v, &gp);

   296

   297

		z = v->z_pos;

   298

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

   299

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

   300

   301

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

   302

			v->age++;

   303

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

   304

				u->u.road.crashed_ctr++;

   305

				u->vehstatus |= VS_CRASHED;

   306

   307

				AddNewsItem(STR_B001_ROAD_VEHICLE_DESTROYED,

   308

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

   309

					u->index,

   310

					0);

   311

			}

   312

		}

   313

   314

// destroy?

   315

		if (v->age > 50) {

   316

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

   317

			SndPlayVehicleFx(SND_12_EXPLOSION, v);

   318

			DeleteDisasterVeh(v);

   319

		}

   320

	}

   321

}

   322

   323

static void DestructIndustry(Industry *i)

   324

{

   325

	uint tile;

   326

	byte index = i - _industries;

   327

   328

	for(tile=0; tile != TILES_X*TILES_Y; tile++) {

   329

		if (IS_TILETYPE(tile, MP_INDUSTRY) &&	_map2[tile] == index) {

   330

			_map_owner[tile] = 0;

   331

			MarkTileDirtyByTile(tile);

   332

		}

   333

	}

   334

}

   335

   336

// Airplane which destroys an oil refinery

   337

static void DisasterTick_2(Vehicle *v)

   338

{

   339

	GetNewVehiclePosResult gp;

   340

   341

	v->tick_counter++;

   342

	v->u.disaster.image_override =

   343

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

   344

   345

	GetNewVehiclePos(v, &gp);

   346

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

   347

   348

	if (gp.x < -160) {

   349

		DeleteDisasterVeh(v);

   350

		return;

   351

	}

   352

   353

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

   354

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

   355

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

   356

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

   357

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

   358

			uint32 r = Random();

   359

   360

			CreateEffectVehicleAbove(

   361

				x + (r & 0x3F),

   362

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

   363

				(r >> 12 & 0xF),

   364

				EV_DEMOLISH);

   365

   366

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

   367

				v->current_order.station = 3;

   368

		}

   369

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

   370

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

   371

			Industry *i;

   372

   373

			v->current_order.station = 2;

   374

			v->age = 0;

   375

   376

			i = DEREF_INDUSTRY(v->dest_tile);

   377

			DestructIndustry(i);

   378

   379

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

   380

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

   381

			SndPlayTileFx(SND_12_EXPLOSION, i->xy);

   382

		}

   383

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

   384

		int x,y;

   385

		uint tile;

   386

		int ind;

   387

   388

		x = v->x_pos - 15*16;

   389

		y = v->y_pos;

   390

   391

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

   392

			return;

   393

   394

		tile = TILE_FROM_XY(x,y);

   395

		if (!IS_TILETYPE(tile, MP_INDUSTRY))

   396

			return;

   397

   398

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

   399

   400

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

   401

			v->current_order.station = 1;

   402

			v->age = 0;

   403

		}

   404

	}

   405

}

   406

   407

// Helicopter which destroys a factory

   408

static void DisasterTick_3(Vehicle *v)

   409

{

   410

	GetNewVehiclePosResult gp;

   411

   412

	v->tick_counter++;

   413

	v->u.disaster.image_override =

   414

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

   415

   416

	GetNewVehiclePos(v, &gp);

   417

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

   418

   419

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

   420

		DeleteDisasterVeh(v);

   421

		return;

   422

	}

   423

   424

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

   425

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

   426

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

   427

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

   428

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

   429

			uint32 r = Random();

   430

   431

			CreateEffectVehicleAbove(

   432

				x + (r & 0x3F),

   433

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

   434

				(r >> 12 & 0xF),

   435

				EV_DEMOLISH);

   436

   437

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

   438

				v->current_order.station = 3;

   439

		}

   440

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

   441

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

   442

			Industry *i;

   443

   444

			v->current_order.station = 2;

   445

			v->age = 0;

   446

   447

			i = DEREF_INDUSTRY(v->dest_tile);

   448

			DestructIndustry(i);

   449

   450

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

   451

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

   452

			SndPlayTileFx(SND_12_EXPLOSION, i->xy);

   453

		}

   454

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

   455

		int x,y;

   456

		uint tile;

   457

		int ind;

   458

   459

		x = v->x_pos - 15*16;

   460

		y = v->y_pos;

   461

   462

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

   463

			return;

   464

   465

		tile = TILE_FROM_XY(x,y);

   466

		if (!IS_TILETYPE(tile, MP_INDUSTRY))

   467

			return;

   468

   469

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

   470

   471

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

   472

			v->current_order.station = 1;

   473

			v->age = 0;

   474

		}

   475

	}

   476

}

   477

   478

// Helicopter rotor blades

   479

static void DisasterTick_3b(Vehicle *v)

   480

{

   481

	if (++v->tick_counter & 1)

   482

		return;

   483

   484

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

   485

		v->cur_image = 0xF3E;

   486

   487

	VehiclePositionChanged(v);

   488

	BeginVehicleMove(v);

   489

	EndVehicleMove(v);

   490

}

   491

   492

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

   493

// Will be shot down by a plane

   494

static void DisasterTick_4(Vehicle *v)

   495

{

   496

	GetNewVehiclePosResult gp;

   497

	byte z;

   498

	Vehicle *u,*w;

   499

	Town *t;

   500

	uint tile,tile_org;

   501

   502

	v->tick_counter++;

   503

   504

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

   505

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

   506

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

   507

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

   508

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

   509

   510

			GetNewVehiclePos(v, &gp);

   511

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

   512

			return;

   513

		}

   514

   515

		z = GetSlopeZ(v->x_pos, v->y_pos);

   516

		if (z < v->z_pos) {

   517

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

   518

			return;

   519

		}

   520