1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "gfx.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

enum {

    19

	VEHICLES_MIN_FREE_FOR_AI = 90

    20

};

    21

    22

void VehicleServiceInDepot(Vehicle *v)

    23

{

    24

	v->date_of_last_service = _date;

    25

	v->breakdowns_since_last_service = 0;

    26

	v->reliability = _engines[v->engine_type].reliability;

    27

}

    28

    29

bool VehicleNeedsService(const Vehicle *v)

    30

{

    31

	if (_patches.no_servicing_if_no_breakdowns && _opt.diff.vehicle_breakdowns == 0)

    32

		return false;

    33

    34

	return _patches.servint_ispercent ?

    35

		(v->reliability < _engines[v->engine_type].reliability * (100 - v->service_interval) / 100) :

    36

		(v->date_of_last_service + v->service_interval < _date);

    37

}

    38

    39

void VehicleInTheWayErrMsg(Vehicle *v)

    40

{

    41

	StringID id;

    42

    43

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

    44

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

    45

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

    46

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    47

    48

	_error_message = id;

    49

}

    50

    51

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

    52

{

    53

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

    54

		return NULL;

    55

    56

	VehicleInTheWayErrMsg(v);

    57

	return v;

    58

}

    59

    60

bool EnsureNoVehicle(TileIndex tile)

    61

{

    62

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

    63

}

    64

    65

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

    66

{

    67

	const TileInfo *ti = data;

    68

    69

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

    70

		return NULL;

    71

    72

	VehicleInTheWayErrMsg(v);

    73

	return v;

    74

}

    75

    76

static inline uint Correct_Z(uint tileh)

    77

{

    78

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

    79

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

    80

	return (CORRECT_Z(tileh)) ? 8 : 0;

    81

}

    82

    83

uint GetCorrectTileHeight(TileIndex tile)

    84

{

    86

}

    87

    88

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    89

{

    90

	TileInfo ti;

    91

    92

	FindLandscapeHeightByTile(&ti, tile);

    93

	ti.z = z + Correct_Z(ti.tileh);

    94

    95

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

    96

}

    97

    98

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

    99

{

   100

	int x1 = TileX(from);

   101

	int y1 = TileY(from);

   102

	int x2 = TileX(to);

   103

	int y2 = TileY(to);

   104

	Vehicle *veh;

   105

   106

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

   107

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

   108

		intswap(x1,x2);

   109

		intswap(y1,y2);

   110

	}

   111

	FOR_ALL_VEHICLES(veh) {

   112

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

   113

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

   114

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

   115

				return veh;

   116

			}

   117

		}

   118

	}

   119

	return NULL;

   120

}

   121

   122

void VehiclePositionChanged(Vehicle *v)

   123

{

   124

	int img = v->cur_image;

   125

	const SpriteDimension *sd;

   126

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

   127

   128

	sd = GetSpriteDimension(img);

   129

   130

	pt.x += sd->xoffs;

   131

	pt.y += sd->yoffs;

   132

   133

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

   134

   135

	v->left_coord = pt.x;

   136

	v->top_coord = pt.y;

   137

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

   138

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

   139

}

   140

   141

void UpdateWaypointSign(Waypoint *cp)

   142

{

   143

	Point pt = RemapCoords2(TileX(cp->xy) * 16, TileY(cp->xy) * 16);

   144

	SetDParam(0, cp - _waypoints);

   145

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

   146

}

   147

   148

void RedrawWaypointSign(Waypoint *cp)

   149

{

   150

	MarkAllViewportsDirty(

   151

		cp->sign.left - 6,

   152

		cp->sign.top,

   153

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

   154

		cp->sign.top + 48);

   155

}

   156

   157

// Called after load to update coordinates

   158

void AfterLoadVehicles(void)

   159

{

   160

	Vehicle *v;

   161

	Waypoint *cp;

   162

   163

	FOR_ALL_VEHICLES(v) {

   164

		if (v->type != 0) {

   165

			v->left_coord = INVALID_COORD;

   166

			VehiclePositionChanged(v);

   167

   168

			if (v->type == VEH_Train) {

   169

				if (v->subtype == TS_Front_Engine)

   170

					UpdateTrainAcceleration(v);

   171

			}

   172

		}

   173

	}

   174

   175

	// update waypoint signs

   176

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

   177

}

   178

   179

   180

static Vehicle *InitializeVehicle(Vehicle *v)

   181

{

   182

	VehicleID index = v->index;

   183

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

   184

	v->index = index;

   185

   186

	assert(v->orders == NULL);

   187

   188

	v->left_coord = INVALID_COORD;

   189

	v->next = NULL;

   190

	v->next_hash = 0xffff;

   191

	v->string_id = 0;

   192

	v->next_shared = NULL;

   193

	v->prev_shared = NULL;

   194

	v->set_for_replacement = false;

   195

	/* random_bits is used to pick out a random sprite for vehicles

   196

	    which are technical the same (newgrf stuff).

   197

	   Because RandomRange() results in desyncs, and because it does

   198

	    not really matter that one client has other visual vehicles than

   199

	    the other, it can be InteractiveRandomRange() without any problem

   200

	*/

   201

	v->random_bits = InteractiveRandomRange(256);

   202

	return v;

   203

}

   204

   205

Vehicle *ForceAllocateSpecialVehicle(void)

   206

{

   207

	Vehicle *v;

   208

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   209

		if (v->type == 0)

   210

			return InitializeVehicle(v);

   211

	}

   212

	return NULL;

   213

   214

}

   215

   216

Vehicle *ForceAllocateVehicle(void)

   217

{

   218

	Vehicle *v;

   219

	FOR_ALL_VEHICLES(v) {

   220

		if (v->index >= NUM_NORMAL_VEHICLES)

   221

			return NULL;

   222

   223

		if (v->type == 0)

   224

			return InitializeVehicle(v);

   225

	}

   226

	return NULL;

   227

}

   228

   229

Vehicle *AllocateVehicle(void)

   230

{

   231

	Vehicle *v;

   232

	int num;

   233

   234

	if (IS_HUMAN_PLAYER(_current_player)) {

   235

		num = 0;

   236

   237

		FOR_ALL_VEHICLES(v) {

   238

			if (v->index >= NUM_NORMAL_VEHICLES)

   239

				break;

   240

   241

			if (v->type == 0)

   242

				num++;

   243

		}

   244

   245

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   246

			return NULL;

   247

	}

   248

   249

	return ForceAllocateVehicle();

   250

}

   251

   252

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

   253

{

   254

	int x,y,x2,y2;

   255

	VehicleID veh;

   256

	Point pt = RemapCoords(TileX(tile) * 16, TileY(tile) * 16, 0);

   257

   258

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

   259

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

   260

   261

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

   262

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

   263

   264

	for(;;) {

   265

		int xb = x;

   266

		for(;;) {

   267

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

   268

			while (veh != INVALID_VEHICLE) {

   269

				Vehicle *v = GetVehicle(veh);

   270

				void *a;

   271

   272

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

   273

					return a;

   274

				veh = v->next_hash;

   275

			}

   276

   277

			if (x == x2)

   278

				break;

   279

   280

			x = (x + 1) & 0x3F;

   281

		}

   282

		x = xb;

   283

   284

		if (y == y2)

   285

			break;

   286

   287

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

   288

	}

   289

	return NULL;

   290

}

   291

   292

   293

   294

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

   295

{

   296

	VehicleID *old_hash, *new_hash;

   297

	int old_x = v->left_coord;

   298

	int old_y = v->top_coord;

   299

	Vehicle *u;

   300

   301

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

   302

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

   303

   304

	if (old_hash == new_hash)

   305

		return;

   306

   307

	/* remove from hash table? */

   308

	if (old_hash != NULL) {

   309

		Vehicle *last = NULL;

   310

		int idx = *old_hash;

   311

		while ((u = GetVehicle(idx)) != v) {

   312

			idx = u->next_hash;

   313

			assert(idx != INVALID_VEHICLE);

   314

			last = u;

   315

		}

   316

   317

		if (last == NULL)

   318

			*old_hash = v->next_hash;

   319

		else

   320

			last->next_hash = v->next_hash;

   321

	}

   322

   323

	/* insert into hash table? */

   324

	if (new_hash != NULL) {

   325

		v->next_hash = *new_hash;

   326

		*new_hash = v->index;

   327

	}

   328

}

   329

   330

void InitializeVehicles(void)

   331

{

   332

	Vehicle *v;

   333

	int i;

   334

   335

	// clear it...

   336

	memset(&_vehicles, 0, sizeof(_vehicles[0]) * _vehicles_size);

   337

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

   338

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

   339

   340

	// setup indexes..

   341

	i = 0;

   342

	FOR_ALL_VEHICLES(v)

   343

		v->index = i++;

   344

   345

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

   346

}

   347

   348

Vehicle *GetLastVehicleInChain(Vehicle *v)

   349

{

   350

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

   351

	return v;

   352

}

   353

   354

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   355

{

   356

	Vehicle *org = v;

   357

   358

	FOR_ALL_VEHICLES(v) {

   359

		if (v->type == VEH_Train && org == v->next)

   360

			return v;

   361

	}

   362

   363

	return NULL;

   364

}

   365

   366

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   367

{

   368

	Vehicle *u;

   369

   370

	while (true) {

   371

		u = v;

   372

		v = GetPrevVehicleInChain(v);

   373

		/* If there is no such vehicle,

   374

		    'v' == NULL and so 'u' is the first vehicle in chain */

   375

		if (v == NULL)

   376

			return u;

   377

	}

   378

}

   379

   380

int CountVehiclesInChain(Vehicle *v)

   381

{

   382

	int count = 0;

   383

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

   384

	return count;

   385

}

   386

   387

   388

Depot *AllocateDepot(void)

   389

{

   390

	Depot *dep, *free_dep = NULL;

   391

	int num_free = 0;

   392

   393

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

   394

		if (dep->xy == 0) {

   395

			num_free++;

   396

			if (free_dep==NULL)

   397

				free_dep = dep;

   398

		}

   399

	}

   400

   401

	if (free_dep == NULL ||

   402

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

   403

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   404

		return NULL;

   405

	}

   406

   407

	return free_dep;

   408

}

   409

   410

Waypoint *AllocateWaypoint(void)

   411

{

   412

	Waypoint *cp;

   413

   414

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

   415

		if (cp->xy == 0)

   416

			return cp;

   417

	}

   418

   419

	return NULL;

   420

}

   421

   422

uint GetWaypointByTile(uint tile)

   423

{

   424

	Waypoint *cp;

   425

	int i=0;

   426

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

   427

	return i;

   428

}

   429

   430

void DoDeleteDepot(uint tile)

   431

{

   432

	Order order;

   433

	byte dep_index;

   434

	Depot *d;

   435

   436

	// Clear it

   437

	DoClearSquare(tile);

   438

   439

	// Nullify the depot struct

   440

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

   441

	d->xy = 0;

   442

   443

	order.type = OT_GOTO_DEPOT;

   444

	order.station = dep_index;

   445

	DeleteDestinationFromVehicleOrder(order);

   446

   447

	// Delete the depot

   448

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   449

}

   450

   451

void DeleteVehicle(Vehicle *v)

   452

{

   453

	DeleteName(v->string_id);

   454

	v->type = 0;

   455

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   456

	v->next_hash = 0xffff;

   457

   458

	if (v->orders != NULL)

   459

		DeleteVehicleOrders(v);

   460

}

   461

   462

void DeleteVehicleChain(Vehicle *v)

   463

{

   464

	do {

   465

		Vehicle *u = v;

   466

		v = v->next;

   467

		DeleteVehicle(u);

   468

	} while (v);

   469

}

   470

   471

   472

void Aircraft_Tick(Vehicle *v);

   473

void RoadVeh_Tick(Vehicle *v);

   474

void Ship_Tick(Vehicle *v);

   475

void Train_Tick(Vehicle *v);

   476

static void EffectVehicle_Tick(Vehicle *v);

   477

void DisasterVehicle_Tick(Vehicle *v);

   478

   479

VehicleTickProc *_vehicle_tick_procs[] = {

   480

	Train_Tick,

   481

	RoadVeh_Tick,

   482

	Ship_Tick,

   483

	Aircraft_Tick,

   484

	EffectVehicle_Tick,

   485

	DisasterVehicle_Tick,

   486

};

   487

   488

void CallVehicleTicks(void)

   489

{

   490

	Vehicle *v;

   491

   492

	FOR_ALL_VEHICLES(v) {

   493

		if (v->type != 0)

   494

			_vehicle_tick_procs[v->type - 0x10](v);

   495

	}

   496

}

   497

   498

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   499

{

   500

	uint32 full = 0, not_full = 0;

   501

   502

	//special handling of aircraft

   503

   504

	//if the aircraft carries passengers and is NOT full, then

   505

	//continue loading, no matter how much mail is in

   506

	if ((v->type == VEH_Aircraft) && (v->cargo_type == CT_PASSENGERS) && (v->cargo_cap != v->cargo_count)) {

   507

		return true;

   508

	}

   509

   510

	// patch should return "true" to continue loading, i.e. when there is no cargo type that is fully loaded.

   511

	do {