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

    91

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    92

{

    93

	TileInfo ti;

    94

    95

	FindLandscapeHeightByTile(&ti, tile);

    97

    98

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

    99

}

   100

   101

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

   102

{

   103

	int x1 = TileX(from);

   104

	int y1 = TileY(from);

   105

	int x2 = TileX(to);

   106

	int y2 = TileY(to);

   107

	Vehicle *veh;

   108

   109

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

   110

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

   111

		intswap(x1,x2);

   112

		intswap(y1,y2);

   113

	}

   114

	FOR_ALL_VEHICLES(veh) {

   115

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

   116

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

   117

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

   118

				return veh;

   119

			}

   120

		}

   121

	}

   122

	return NULL;

   123

}

   124

   125

void VehiclePositionChanged(Vehicle *v)

   126

{

   127

	int img = v->cur_image;

   128

	const SpriteDimension *sd;

   129

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

   130

   131

	sd = GetSpriteDimension(img);

   132

   133

	pt.x += sd->xoffs;

   134

	pt.y += sd->yoffs;

   135

   136

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

   137

   138

	v->left_coord = pt.x;

   139

	v->top_coord = pt.y;

   140

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

   141

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

   142

}

   143

   144

void UpdateWaypointSign(Waypoint *cp)

   145

{

   146

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

   147

	SetDParam(0, cp - _waypoints);

   148

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

   149

}

   150

   151

void RedrawWaypointSign(Waypoint *cp)

   152

{

   153

	MarkAllViewportsDirty(

   154

		cp->sign.left - 6,

   155

		cp->sign.top,

   156

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

   157

		cp->sign.top + 48);

   158

}

   159

   160

// Called after load to update coordinates

   161

void AfterLoadVehicles()

   162

{

   163

	Vehicle *v;

   164

	Waypoint *cp;

   165

   166

	FOR_ALL_VEHICLES(v) {

   167

		if (v->type != 0) {

   168

			v->left_coord = INVALID_COORD;

   169

			VehiclePositionChanged(v);

   170

   171

			if (v->type == VEH_Train) {

   172

				if (v->subtype == TS_Front_Engine)

   173

					UpdateTrainAcceleration(v);

   174

			}

   175

		}

   176

	}

   177

   178

	// update waypoint signs

   179

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

   180

}

   181

   182

   183

static Vehicle *InitializeVehicle(Vehicle *v)

   184

{

   185

	VehicleID index = v->index;

   186

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

   187

	v->index = index;

   188

   189

	assert(v->orders == NULL);

   190

   191

	v->left_coord = INVALID_COORD;

   192

	v->next = NULL;

   193

	v->next_hash = 0xffff;

   194

	v->string_id = 0;

   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()

   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()

   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()

   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()

   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()

   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()

   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()

   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 {

   512

		//Should never happen, but just in case future additions change this

   513

		assert(v->cargo_type<32);