1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "vehicle.h"

     5

#include "gfx.h"

     6

//#include "station.h"

     7

#include "viewport.h"

     8

#include "news.h"

     9

#include "command.h"

    10

#include "saveload.h"

    11

#include "player.h"

    12

#include "engine.h"

    13

#include "sound.h"

    14

    15

#define INVALID_COORD (-0x8000)

    16

#define GEN_HASH(x,y) (((x & 0x1F80)>>7) + ((y & 0xFC0)))

    17

    18

    19

void VehicleInTheWayErrMsg(Vehicle *v)

    20

{

    21

	StringID id;

    22

    23

	(id = STR_8803_TRAIN_IN_THE_WAY,v->type == VEH_Train) ||

    24

	(id = STR_9000_ROAD_VEHICLE_IN_THE_WAY,v->type == VEH_Road) ||

    25

	(id = STR_A015_AIRCRAFT_IN_THE_WAY,v->type == VEH_Aircraft) ||

    26

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    27

    28

	_error_message = id;

    29

}

    30

    31

static void *EnsureNoVehicleProc(Vehicle *v, void *data)

    32

{

    33

	if (v->tile != *(const TileIndex*)data || v->type == VEH_Disaster)

    34

		return NULL;

    35

    36

	VehicleInTheWayErrMsg(v);

    37

	return v;

    38

}

    39

    40

bool EnsureNoVehicle(TileIndex tile)

    41

{

    42

	return VehicleFromPos(tile, &tile, EnsureNoVehicleProc) == NULL;

    43

}

    44

    45

static void *EnsureNoVehicleProcZ(Vehicle *v, void *data)

    46

{

    47

	const TileInfo *ti = data;

    48

    49

	if (v->tile != ti->tile || v->z_pos != ti->z || v->type == VEH_Disaster)

    50

		return NULL;

    51

    52

	VehicleInTheWayErrMsg(v);

    53

	return v;

    54

}

    55

    56

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    57

{

    58

	TileInfo ti;

    59

    60

	FindLandscapeHeightByTile(&ti, tile);

    61

	// needs z correction for slope-type graphics that have the NORTHERN tile lowered

    62

	// 1, 2, 3, 4, 5, 6 and 7

    63

	if (CORRECT_Z(ti.tileh))

    64

		z += 8;

    65

    66

	ti.z = z;

    67

    68

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ) == NULL;

    69

}

    70

    71

Vehicle *FindVehicleBetween(TileIndex from, TileIndex to, byte z)

    72

{

    73

	int x1 = GET_TILE_X(from);

    74

	int y1 = GET_TILE_Y(from);

    75

	int x2 = GET_TILE_X(to);

    76

	int y2 = GET_TILE_Y(to);

    77

	Vehicle *veh;

    78

	uint count;

    79

    80

	/* Make sure x1 < x2 or y1 < y2 */

    81

	if (x1 > x2 || y1 > y2) {

    82

		intswap(x1,x2);

    83

		intswap(y1,y2);

    84

	}

    85

	for(veh = _vehicles, count=lengthof(_vehicles); count != 0; count--, veh++) {

    86

		if ((veh->type == VEH_Train || veh->type == VEH_Road) && (z==0xFF || veh->z_pos == z)) {

    87

			if ((veh->x_pos>>4) >= x1 && (veh->x_pos>>4) <= x2 &&

    88

					(veh->y_pos>>4) >= y1 && (veh->y_pos>>4) <= y2) {

    89

				return veh;

    90

			}

    91

		}

    92

	}

    93

	return NULL;

    94

}

    95

    96

void VehiclePositionChanged(Vehicle *v)

    97

{

    98

	int img = v->cur_image;

    99

	const SpriteDimension *sd;

   100

	Point pt = RemapCoords(v->x_pos + v->x_offs, v->y_pos + v->y_offs, v->z_pos);

   101

   102

	sd = GetSpriteDimension(img);

   103

   104

	pt.x += sd->xoffs;

   105

	pt.y += sd->yoffs;

   106

   107

	UpdateVehiclePosHash(v, pt.x, pt.y);

   108

   109

	v->left_coord = pt.x;

   110

	v->top_coord = pt.y;

   111

	v->right_coord = pt.x + sd->xsize + 2;

   112

	v->bottom_coord = pt.y + sd->ysize + 2;

   113

}

   114

   115

void UpdateWaypointSign(Waypoint *cp)

   116

{

   117

	Point pt = RemapCoords2(GET_TILE_X(cp->xy)*16, GET_TILE_Y(cp->xy)*16);

   118

	SetDParam(0, cp - _waypoints);

   119

	UpdateViewportSignPos(&cp->sign, pt.x, pt.y - 0x20, STR_WAYPOINT_VIEWPORT);

   120

}

   121

   122

void RedrawWaypointSign(Waypoint *cp)

   123

{

   124

	MarkAllViewportsDirty(

   125

		cp->sign.left - 6,

   126

		cp->sign.top,

   127

		cp->sign.left + (cp->sign.width_1 << 2) + 12,

   128

		cp->sign.top + 48);

   129

}

   130

   131

// Called after load to update coordinates

   132

void AfterLoadVehicles()

   133

{

   134

	Vehicle *v;

   135

	Waypoint *cp;

   136

   137

	FOR_ALL_VEHICLES(v) {

   138

		if (v->type != 0) {

   139

			v->left_coord = INVALID_COORD;

   140

			VehiclePositionChanged(v);

   141

   142

			if (v->type == VEH_Train) {

   143

				if (v->subtype == 0)

   144

					UpdateTrainAcceleration(v);

   145

			}

   146

   147

#if defined(_DEBUG)

   148

			if (!(v->schedule_ptr == NULL || (v->schedule_ptr >= _order_array && v->schedule_ptr < _ptr_to_next_order)))

   149

				v->schedule_ptr = NULL;

   150

#endif

   151

		}

   152

	}

   153

   154

	// update waypoint signs

   155

	for(cp=_waypoints; cp != endof(_waypoints); cp++) if (cp->xy) UpdateWaypointSign(cp);

   156

}

   157

   158

   159

static Vehicle *InitializeVehicle(Vehicle *v)

   160

{

   161

	VehicleID index = v->index;

   162

	memset(v, 0, sizeof(Vehicle));

   163

	v->index = index;

   164

   165

	assert(v->schedule_ptr == NULL);

   166

   167

	v->left_coord = INVALID_COORD;

   168

	v->next = NULL;

   169

	v->next_hash = 0xffff;

   170

	v->string_id = 0;

   171

	v->random_bits = RandomRange(256);

   172

	return v;

   173

}

   174

   175

Vehicle *ForceAllocateSpecialVehicle()

   176

{

   177

	Vehicle *v;

   178

	for(v=_vehicles + NUM_NORMAL_VEHICLES;

   179

			v!=&_vehicles[NUM_NORMAL_VEHICLES+NUM_SPECIAL_VEHICLES]; v++) {

   180

		if (v->type == 0)

   181

			return InitializeVehicle(v);

   182

	}

   183

	return NULL;

   184

   185

}

   186

   187

Vehicle *ForceAllocateVehicle()

   188

{

   189

	Vehicle *v;

   190

	for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   191

		if (v->type == 0)

   192

			return InitializeVehicle(v);

   193

	}

   194

	return NULL;

   195

}

   196

   197

Vehicle *AllocateVehicle()

   198

{

   199

	Vehicle *v;

   200

	int num;

   201

   202

	if (IS_HUMAN_PLAYER(_current_player)) {

   203

		num = 0;

   204

   205

		for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   206

			if (v->type == 0)

   207

				num++;

   208

		}

   209

   210

		if (num <= 90)

   211

			return NULL;

   212

	}

   213

   214

	return ForceAllocateVehicle();

   215

}

   216

   217

void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc)

   218

{

   219

	int x,y,x2,y2;

   220

	VehicleID veh;

   221

	Point pt = RemapCoords(GET_TILE_X(tile) * 16, GET_TILE_Y(tile) * 16, 0);

   222

   223

	x2 = ((pt.x + 104) & 0x1F80) >> 7;

   224

	x  = ((pt.x - 174) & 0x1F80) >> 7;

   225

   226

	y2 = ((pt.y + 56) & 0xFC0);

   227

	y  = ((pt.y - 294) & 0xFC0);

   228

   229

	for(;;) {

   230

		int xb = x;

   231

		for(;;) {

   232

			veh = _vehicle_position_hash[ (x+y)&0xFFFF ];

   233

			while (veh != INVALID_VEHICLE) {

   234

				Vehicle *v = &_vehicles[veh];

   235

				void *a;

   236

   237

				if ((a = proc(v, data)) != NULL)

   238

					return a;

   239

				veh = v->next_hash;

   240

			}

   241

   242

			if (x == x2)

   243

				break;

   244

   245

			x = (x + 1) & 0x3F;

   246

		}

   247

		x = xb;

   248

   249

		if (y == y2)

   250

			break;

   251

   252

		y = (y + 0x40) & ((0x3F) << 6);

   253

	}

   254

	return NULL;

   255

}

   256

   257

   258

   259

void UpdateVehiclePosHash(Vehicle *v, int x, int y)

   260

{

   261

	VehicleID *old_hash, *new_hash;

   262

	int old_x = v->left_coord;

   263

	int old_y = v->top_coord;

   264

	Vehicle *u;

   265

   266

	new_hash = (x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(x,y)];

   267

	old_hash = (old_x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(old_x, old_y)];

   268

   269

	if (old_hash == new_hash)

   270

		return;

   271

   272

	/* remove from hash table? */

   273

	if (old_hash != NULL) {

   274

		Vehicle *last = NULL;

   275

		int idx = *old_hash;

   276

		while((u = &_vehicles[idx]) != v) {

   277

			idx = u->next_hash;

   278

			assert(idx != INVALID_VEHICLE);

   279

			last = u;

   280

		}

   281

   282

		if (last == NULL)

   283

			*old_hash = v->next_hash;

   284

		else

   285

			last->next_hash = v->next_hash;

   286

	}

   287

   288

	/* insert into hash table? */

   289

	if (new_hash != NULL) {

   290

		v->next_hash = *new_hash;

   291

		*new_hash = v->index;

   292

	}

   293

}

   294

   295

void InitializeVehicles()

   296

{

   297

	Vehicle *v;

   298

	int i;

   299

   300

	// clear it...

   301

	memset(&_vehicles, 0, sizeof(_vehicles));

   302

	memset(&_waypoints, 0, sizeof(_waypoints));

   303

	memset(&_depots, 0, sizeof(_depots));

   304

   305

	// setup indexes..

   306

	i = 0;

   307

	FOR_ALL_VEHICLES(v)

   308

		v->index = i++;

   309

   310

	memset(_vehicle_position_hash, -1, sizeof(_vehicle_position_hash));

   311

   312

	_ptr_to_next_order = _order_array;

   313

}

   314

   315

Vehicle *GetLastVehicleInChain(Vehicle *v)

   316

{

   317

	while (v->next != NULL) v = v->next;

   318

	return v;

   319

}

   320

   321

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   322

{

   323

	Vehicle *org = v;

   324

   325

	v = _vehicles;

   326

	while (v->type != VEH_Train || org != v->next) {

   327

		if (++v == endof(_vehicles))

   328

			return NULL;

   329

	}

   330

   331

	return v;

   332

}

   333

   334

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   335

{

   336

	for(;;) {

   337

		Vehicle *u = v;

   338

		v = _vehicles;

   339

		while (v->type != VEH_Train || u != v->next) {

   340

			if (++v == endof(_vehicles))

   341

				return u;

   342

		}

   343

	}

   344

}

   345

   346

int CountVehiclesInChain(Vehicle *v)

   347

{

   348

	int count = 0;

   349

	do count++; while ( (v=v->next) != NULL);

   350

	return count;

   351

}

   352

   353

   354

Depot *AllocateDepot()

   355

{

   356

	Depot *dep, *free_dep = NULL;

   357

	int num_free = 0;

   358

   359

	for(dep = _depots; dep != endof(_depots); dep++) {

   360

		if (dep->xy == 0) {

   361

			num_free++;

   362

			if (free_dep==NULL)

   363

				free_dep = dep;

   364

		}

   365

	}

   366

   367

	if (free_dep == NULL ||

   368

			(num_free < 30 && IS_HUMAN_PLAYER(_current_player))) {

   369

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   370

		return NULL;

   371

	}

   372

   373

	return free_dep;

   374

}

   375

   376

Waypoint *AllocateWaypoint()

   377

{

   378

	Waypoint *cp;

   379

   380

	for(cp = _waypoints; cp != endof(_waypoints); cp++) {

   381

		if (cp->xy == 0)

   382

			return cp;

   383

	}

   384

   385

	return NULL;

   386

}

   387

   388

uint GetWaypointByTile(uint tile)

   389

{

   390

	Waypoint *cp;

   391

	int i=0;

   392

	for(cp=_waypoints; cp->xy != (TileIndex)tile; cp++) { i++; }

   393

	return i;

   394

}

   395

   396

   397

Vehicle *IsScheduleShared(Vehicle *u)

   398

{

   399

	uint16 *sched = u->schedule_ptr;

   400

	Vehicle *v;

   401

   402

	FOR_ALL_VEHICLES(v) {

   403

		if (v->schedule_ptr == sched && u != v && v->type != 0)

   404

			return v;

   405

	}

   406

	return NULL;

   407

}

   408

   409

void DeleteVehicleSchedule(Vehicle *v)

   410

{

   411

	uint16 *sched, *cur;

   412

	int num;

   413

	Vehicle *u;

   414

   415

	// if the schedule is shared, don't delete it.

   416

	if ((u = IsScheduleShared(v)) != NULL) {

   417

		v->schedule_ptr = NULL;

   418

		InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   419

		return;

   420

	}

   421

   422

	sched = v->schedule_ptr;

   423

	v->schedule_ptr = NULL;

   424

   425

	num = v->num_orders + 1;

   426

   427

	_ptr_to_next_order -= num;

   428

   429

	cur = sched;

   430

	while (cur != _ptr_to_next_order) {

   431

		assert(cur < _ptr_to_next_order);

   432

		cur[0] = cur[num];

   433

		cur++;

   434

	}

   435

   436

	FOR_ALL_VEHICLES(v) {

   437

		if (v->schedule_ptr != NULL && sched < v->schedule_ptr) {

   438

			v->schedule_ptr -= num;

   439

		}

   440

	}

   441

}

   442

   443

void DeleteCommandFromVehicleSchedule(uint cmd)

   444

{

   445

	Vehicle *v;

   446

	uint16 *sched;

   447

	uint order;

   448

	bool need_invalidate;

   449

   450

	FOR_ALL_VEHICLES(v) {

   451

		if (v->type != 0 && v->schedule_ptr != NULL) {

   452

   453

			// clear last station visited

   454

			if (v->last_station_visited == (cmd>>8) && (cmd & OT_MASK) == OT_GOTO_STATION)

   455

				v->last_station_visited = 0xFF;

   456

   457

			// check the next order

   458

			if ( (uint)((v->next_order&OT_MASK) | (v->next_order_param<<8)) == cmd) {

   459

				v->next_order = OT_DUMMY;

   460

				InvalidateWindow(WC_VEHICLE_VIEW, v->index);

   461

			}

   462

   463

			// clear the order list

   464

			need_invalidate = false;

   465

			sched = v->schedule_ptr;

   466

			while ((order=*sched++) != 0) {

   467

				if ( (order & (OT_MASK|0xFF00)) == cmd) {

   468

					sched[-1] = OT_DUMMY;

   469

					need_invalidate = true;

   470

				}

   471

			}

   472

   473

			if (need_invalidate)

   474

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   475

		}

   476

	}

   477

}

   478

   479

void DoDeleteDepot(uint tile)

   480

{

   481

	byte dep_index;

   482

	Depot *d;

   483

   484

	// Clear it

   485

	DoClearSquare(tile);

   486

   487

	// Nullify the depot struct

   488

	for(d=_depots,dep_index=0; d->xy != (TileIndex)tile; d++) {dep_index++;}

   489

	d->xy = 0;

   490

   491

	DeleteCommandFromVehicleSchedule((dep_index << 8) + OT_GOTO_DEPOT);

   492

   493

	// Delete the depot

   494

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   495

}

   496

   497

void DeleteVehicle(Vehicle *v)

   498

{

   499

	DeleteName(v->string_id);

   500

	v->type = 0;

   501

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   502

	v->next_hash = 0xffff;

   503

   504

	if (v->schedule_ptr != NULL)

   505

		DeleteVehicleSchedule(v);

   506

}

   507

   508

void DeleteVehicleChain(Vehicle *v)

   509

{

   510

	do {

   511

		Vehicle *u = v;

   512

		v = v->next;

   513

		DeleteVehicle(u);

   514

	} while (v);

   515

}

   516

   517

   518

void Aircraft_Tick(Vehicle *v);

   519

void RoadVeh_Tick(Vehicle *v);

   520

void Ship_Tick(Vehicle *v);

   521

void Train_Tick(Vehicle *v);

   522

static void EffectVehicle_Tick(Vehicle *v);