1

#include "stdafx.h"

     2

#include "ttd.h"

     4

#include "vehicle.h"

     5

#include "command.h"

     6

#include "news.h"

     7

#include "gfx.h"

     8

#include "station.h"

     9

#include "town.h"

    10

#include "industry.h"

    11

#include "player.h"

    12

#include "airport_movement.h"

    13

#include "sound.h"

    14

    15

static void DisasterClearSquare(uint tile)

    16

{

    17

	int type;

    18

    19

	if (!EnsureNoVehicle(tile))

    20

		return;

    21

    22

	type = _map_type_and_height[tile] >> 4;

    23

    24

	if (type == MP_RAILWAY) {

    25

		if (IS_HUMAN_PLAYER(_map_owner[tile]))

    26

			DoClearSquare(tile);

    27

	} else if (type == MP_HOUSE) {

    28

		byte p = _current_player;

    29

		_current_player = OWNER_NONE;

    30

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

    31

		_current_player = p;

    32

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

    33

		DoClearSquare(tile);

    34

	}

    35

}

    36

    37

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

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

    47

static const SpriteID * const _disaster_images[] = {

    48

	_disaster_images_1,_disaster_images_1,

    49

	_disaster_images_2,_disaster_images_2,

    50

	_disaster_images_3,_disaster_images_3,

    51

	_disaster_images_8,_disaster_images_8,_disaster_images_9,

    52

	_disaster_images_6,_disaster_images_6,

    53

	_disaster_images_7,_disaster_images_7,

    54

	_disaster_images_4,_disaster_images_5,

    55

};

    56

    57

static void DisasterVehicleUpdateImage(Vehicle *v)

    58

{

    59

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

    60

	if (img == 0)

    61

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

    62

	v->cur_image = img;

    63

}

    64

    65

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

    66

{

    67

	v->type = VEH_Disaster;

    68

	v->x_pos = x;

    69

	v->y_pos = y;

    70

	v->z_pos = z;

    71

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

    72

	v->direction = direction;

    73

	v->subtype = subtype;

    74

	v->x_offs = -1;

    75

	v->y_offs = -1;

    76

	v->sprite_width = 2;

    77

	v->sprite_height = 2;

    78

	v->z_height = 5;

    79

	v->owner = OWNER_NONE;

    80

	v->vehstatus = VS_UNCLICKABLE;

    81

	v->u.disaster.image_override = 0;

    82

	v->next_order = 0;

    83

    84

	DisasterVehicleUpdateImage(v);

    85

	VehiclePositionChanged(v);

    86

	BeginVehicleMove(v);

    87

	EndVehicleMove(v);

    88

}

    89

    90

static void DeleteDisasterVeh(Vehicle *v)

    91

{

    92

	DeleteVehicleChain(v);

    93

}

    94

    95

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

    96

{

    97

	Vehicle *u;

    98

	int yt;

    99

   100

	BeginVehicleMove(v);

   101

	v->x_pos = x;

   102

	v->y_pos = y;

   103

	v->z_pos = z;

   104

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

   105

   106

	DisasterVehicleUpdateImage(v);

   107

	VehiclePositionChanged(v);

   108

	EndVehicleMove(v);

   109

   110

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

   111

		BeginVehicleMove(u);

   112

   113

		u->x_pos = x;

   114

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

   115

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

   116

		u->direction = v->direction;

   117

   118

		DisasterVehicleUpdateImage(u);

   119

		VehiclePositionChanged(u);

   120

		EndVehicleMove(u);

   121

   122

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

   123

			BeginVehicleMove(u);

   124

			u->x_pos = x;

   125

			u->y_pos = y;

   126

			u->z_pos = z + 5;

   127

			VehiclePositionChanged(u);

   128

			EndVehicleMove(u);

   129

		}

   130

	}

   131

}

   132

   133

   134

static void DisasterTick_Zeppeliner(Vehicle *v)

   135

{

   136

	GetNewVehiclePosResult gp;

   137

	Station *st;

   138

	int x,y;

   139

	byte z;

   140

	uint tile;

   141

   142

	++v->tick_counter;

   143

   144

	if (v->next_order < 2) {

   145

		if (v->tick_counter&1)

   146

			return;

   147

   148

		GetNewVehiclePos(v, &gp);

   149

   150

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

   151

   152

		if (v->next_order == 1) {

   153

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

   154

				v->next_order = 2;

   155

				v->age = 0;

   156

			}

   157

   158

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

   159

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

   160

			}

   161

		} else if (v->next_order == 0) {

   162

			tile = v->tile; /**/

   163

   164

			if (IS_TILETYPE(tile, MP_STATION) &&

   165

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

   166

				IS_HUMAN_PLAYER(_map_owner[tile])) {

   167

   168

				v->next_order = 1;

   169

				v->age = 0;

   170

   171

				SET_DPARAM16(0, _map2[tile]);

   172

				AddNewsItem(STR_B000_ZEPPELIN_DISASTER_AT,

   173

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

   174

					v->index,

   175

					0);

   176

			}

   177

		}

   178

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

   179

			DeleteDisasterVeh(v);

   180

		return;

   181

	}

   182

   183

	if (v->next_order > 2) {

   184

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

   185

			return;

   186

   187

		tile = v->tile; /**/

   188

   189

		if (IS_TILETYPE(tile, MP_STATION) &&

   190

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

   191

			IS_HUMAN_PLAYER(_map_owner[tile])) {

   192

   193

			st = DEREF_STATION(_map2[tile]);

   194

			CLRBITS(st->airport_flags, RUNWAY_IN_block);

   195

		}

   196

   197

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

   198

		DeleteDisasterVeh(v);

   199

		return;

   200

	}

   201

   202

	x = v->x_pos;

   203

	y = v->y_pos;

   204

	z = GetSlopeZ(x,y);

   205

	if (z < v->z_pos)

   206

		z = v->z_pos - 1;

   207

	SetDisasterVehiclePos(v, x, y, z);

   208

   209

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

   210

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

   211

		SndPlayVehicleFx(0x10, v);

   212

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

   213

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

   214

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

   215

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

   216

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

   217

			uint32 r = Random();

   218

   219

			CreateEffectVehicleRel(v,

   220

				-7 + (r&0xF),

   221

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

   222

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

   223

				EV_DEMOLISH);

   224

		}

   225

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

   226

		v->next_order = 3;

   227

		v->age = 0;

   228

	}

   229

   230

	tile = v->tile;/**/

   231

	if (IS_TILETYPE(tile, MP_STATION) &&

   232

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

   233

		IS_HUMAN_PLAYER(_map_owner[tile])) {

   234

   235

		st = DEREF_STATION(_map2[tile]);

   236

		SETBITS(st->airport_flags, RUNWAY_IN_block);

   237

	}

   238

}

   239

   240

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

   241

// a road vehicle which it targets.

   242

static void DisasterTick_UFO(Vehicle *v)

   243

{

   244

	GetNewVehiclePosResult gp;

   245

	Vehicle *u;

   246

	uint dist;

   247

	byte z;

   248

   249

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

   250

   251

	if (v->next_order == 0) {

   252

// fly around randomly

   253

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

   254

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

   255

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

   256

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

   257

			GetNewVehiclePos(v, &gp);

   258

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

   259

			return;

   260

		}

   261

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

   262

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

   263

			return;

   264

		}

   265

		v->next_order = 1;

   266

   267

		FOR_ALL_VEHICLES(u) {

   268

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

   269

				v->dest_tile = u->index;

   270

				v->age = 0;

   271

				return;

   272

			}

   273

		}

   274

   275

		DeleteDisasterVeh(v);

   276

	} else {

   277

// target a vehicle

   278

		u = &_vehicles[v->dest_tile];

   279

		if (u->type != VEH_Road) {

   280

			DeleteDisasterVeh(v);

   281

			return;

   282

		}

   283

   284

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

   285

   286

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

   287

			u->breakdown_ctr = 3;

   288

			u->breakdown_delay = 140;

   289

		}

   290

   291

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

   292

		GetNewVehiclePos(v, &gp);

   293

   294

		z = v->z_pos;

   295

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

   296

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

   297

   298

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

   299

			v->age++;

   300

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

   301

				u->u.road.crashed_ctr++;

   302

				u->vehstatus |= VS_CRASHED;

   303

   304

				AddNewsItem(STR_B001_ROAD_VEHICLE_DESTROYED,

   305

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

   306

					u->index,

   307

					0);

   308

			}

   309

		}

   310

   311

// destroy?

   312

		if (v->age > 50) {

   313

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

   314

			SndPlayVehicleFx(0x10, v);

   315

			DeleteDisasterVeh(v);

   316

		}

   317

	}

   318

}

   319

   320

static void DestructIndustry(Industry *i)

   321

{

   322

	uint tile;

   323

	byte index = i - _industries;

   324

   325

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

   326

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

   327

			_map_owner[tile] = 0;

   328

			MarkTileDirtyByTile(tile);

   329

		}

   330

	}

   331

}

   332

   333

// Airplane which destroys an oil refinery

   334

static void DisasterTick_2(Vehicle *v)

   335

{

   336

	GetNewVehiclePosResult gp;

   337

   338

	v->tick_counter++;

   339

	v->u.disaster.image_override = (v->next_order == 1 && v->tick_counter&4) ? 0xF4F : 0;

   340

   341

	GetNewVehiclePos(v, &gp);

   342

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

   343

   344

	if (gp.x < -160) {

   345

		DeleteDisasterVeh(v);

   346

		return;

   347

	}

   348

   349

	if (v->next_order == 2) {

   350

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

   351

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

   352

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

   353

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

   354

			uint32 r = Random();

   355

   356

			CreateEffectVehicleAbove(

   357

				x + (r & 0x3F),

   358

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

   359

				(r >> 12 & 0xF),

   360

				EV_DEMOLISH);

   361

   362

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

   363

				v->next_order = 3;

   364

		}

   365

	} else if (v->next_order == 1) {

   366

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

   367

			Industry *i;

   368

   369

			v->next_order = 2;

   370

			v->age = 0;

   371

   372

			i = DEREF_INDUSTRY(v->dest_tile);

   373

			DestructIndustry(i);

   374

   375

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

   376

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

   377

			SndPlayTileFx(0x10, i->xy);

   378

		}

   379

	} else if (v->next_order == 0) {

   380

		int x,y;

   381

		uint tile;

   382

		int ind;

   383

   384

		x = v->x_pos - 15*16;

   385

		y = v->y_pos;

   386

   387

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

   388

			return;

   389

   390

		tile = TILE_FROM_XY(x,y);

   391

		if (!IS_TILETYPE(tile, MP_INDUSTRY))

   392

			return;

   393

   394

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

   395

   396

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

   397

			v->next_order = 1;

   398

			v->age = 0;

   399

		}

   400

	}

   401

}

   402

   403

// Helicopter which destroys a factory

   404

static void DisasterTick_3(Vehicle *v)

   405

{

   406

	GetNewVehiclePosResult gp;

   407

   408

	v->tick_counter++;

   409

	v->u.disaster.image_override = (v->next_order == 1 && v->tick_counter&4) ? 0xF53 : 0;

   410

   411

	GetNewVehiclePos(v, &gp);

   412

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

   413

   414

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

   415

		DeleteDisasterVeh(v);

   416

		return;

   417

	}

   418

   419

	if (v->next_order == 2) {

   420

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

   421

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

   422

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

   423

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

   424

			uint32 r = Random();

   425

   426

			CreateEffectVehicleAbove(

   427

				x + (r & 0x3F),

   428

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

   429

				(r >> 12 & 0xF),

   430

				EV_DEMOLISH);

   431

   432

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

   433

				v->next_order = 3;

   434

		}

   435

	} else if (v->next_order == 1) {

   436

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

   437

			Industry *i;

   438

   439

			v->next_order = 2;

   440

			v->age = 0;

   441

   442

			i = DEREF_INDUSTRY(v->dest_tile);

   443

			DestructIndustry(i);

   444

   445

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

   446

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

   447

			SndPlayTileFx(0x10, i->xy);

   448

		}

   449

	} else if (v->next_order == 0) {

   450

		int x,y;

   451

		uint tile;

   452

		int ind;

   453

   454

		x = v->x_pos - 15*16;

   455

		y = v->y_pos;

   456

   457

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

   458

			return;

   459

   460

		tile = TILE_FROM_XY(x,y);

   461

		if (!IS_TILETYPE(tile, MP_INDUSTRY))

   462

			return;

   463

   464

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

   465

   466

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

   467

			v->next_order = 1;

   468

			v->age = 0;

   469

		}

   470

	}

   471

}

   472

   473

// Helicopter rotor blades

   474

static void DisasterTick_3b(Vehicle *v)

   475

{

   476

	if (++v->tick_counter & 1)

   477

		return;

   478

   479

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

   480

		v->cur_image = 0xF3E;

   481

   482

	VehiclePositionChanged(v);

   483

	BeginVehicleMove(v);

   484

	EndVehicleMove(v);

   485

}

   486

   487

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

   488

// Will be shot down by a plane

   489

static void DisasterTick_4(Vehicle *v)

   490

{

   491

	GetNewVehiclePosResult gp;

   492

	byte z;

   493

	Vehicle *u,*w;

   494

	Town *t;

   495

	uint tile,tile_org;

   496

   497

	v->tick_counter++;

   498

   499

	if (v->next_order == 1) {

   500

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

   501

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

   502

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

   503

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

   504

   505

			GetNewVehiclePos(v, &gp);

   506

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

   507

			return;

   508

		}

   509

   510

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

   511

		if (z < v->z_pos) {

   512

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

   513

			return;

   514

		}

   515

   516

		v->next_order = 2;

   517

   518

		FOR_ALL_VEHICLES(u) {

   519

			if (u->type == VEH_Train || u->type == VEH_Road) {

   520

				if (abs(u->x_pos - v->x_pos) + abs(u->y_pos - v->y_pos) <= 12*16) {

   521

					u->breakdown_ctr = 5;

   522

					u->breakdown_delay = 0xF0;

   523

				}

   524

			}

   525

		}

   526