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

{

    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

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    77

{

    78

	TileInfo ti;

    79

    80

	FindLandscapeHeightByTile(&ti, tile);

    81

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

    82

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

    83

	if (CORRECT_Z(ti.tileh))

    84

		z += 8;

    85

    86

	ti.z = z;

    87

    88

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

    89

}

    90

    91

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

    92

{

    93

	int x1 = TileX(from);

    94

	int y1 = TileY(from);

    95

	int x2 = TileX(to);

    96

	int y2 = TileY(to);

    97

	Vehicle *veh;

    98

    99

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

   100

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

   101

		intswap(x1,x2);

   102

		intswap(y1,y2);

   103

	}

   104

	FOR_ALL_VEHICLES(veh) {

   105

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

   106

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

   107

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

   108

				return veh;

   109

			}

   110

		}

   111

	}

   112

	return NULL;

   113

}

   114

   115

void VehiclePositionChanged(Vehicle *v)

   116

{

   117

	int img = v->cur_image;

   118

	const SpriteDimension *sd;

   119

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

   120

   121

	sd = GetSpriteDimension(img);

   122

   123

	pt.x += sd->xoffs;

   124

	pt.y += sd->yoffs;

   125

   126

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

   127

   128

	v->left_coord = pt.x;

   129

	v->top_coord = pt.y;

   130

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

   131

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

   132

}

   133

   134

void UpdateWaypointSign(Waypoint *cp)

   135

{

   136

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

   137

	SetDParam(0, cp - _waypoints);

   138

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

   139

}

   140

   141

void RedrawWaypointSign(Waypoint *cp)

   142

{

   143

	MarkAllViewportsDirty(

   144

		cp->sign.left - 6,

   145

		cp->sign.top,

   146

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

   147

		cp->sign.top + 48);

   148

}

   149

   150

// Called after load to update coordinates

   151

void AfterLoadVehicles()

   152

{

   153

	Vehicle *v;

   154

	Waypoint *cp;

   155

   156

	FOR_ALL_VEHICLES(v) {

   157

		if (v->type != 0) {

   158

			v->left_coord = INVALID_COORD;

   159

			VehiclePositionChanged(v);

   160

   161

			if (v->type == VEH_Train) {

   162

				if (v->subtype == 0)

   163

					UpdateTrainAcceleration(v);

   164

			}

   165

		}

   166

	}

   167

   168

	// update waypoint signs

   169

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

   170

}

   171

   172

   173

static Vehicle *InitializeVehicle(Vehicle *v)

   174

{

   175

	VehicleID index = v->index;

   176

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

   177

	v->index = index;

   178

   179

	assert(v->orders == NULL);

   180

   181

	v->left_coord = INVALID_COORD;

   182

	v->next = NULL;

   183

	v->next_hash = 0xffff;

   184

	v->string_id = 0;

   185

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

   186

	    which are technical the same (newgrf stuff).

   187

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

   188

	    not really matter that one client has other visual vehicles than

   189

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

   190

	*/

   191

	v->random_bits = InteractiveRandomRange(256);

   192

	return v;

   193

}

   194

   195

Vehicle *ForceAllocateSpecialVehicle()

   196

{

   197

	Vehicle *v;

   198

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   199

		if (v->type == 0)

   200

			return InitializeVehicle(v);

   201

	}

   202

	return NULL;

   203

   204

}

   205

   206

Vehicle *ForceAllocateVehicle()

   207

{

   208

	Vehicle *v;

   209

	FOR_ALL_VEHICLES(v) {

   210

		if (v->index >= NUM_NORMAL_VEHICLES)

   211

			return NULL;

   212

   213

		if (v->type == 0)

   214

			return InitializeVehicle(v);

   215

	}

   216

	return NULL;

   217

}

   218

   219

Vehicle *AllocateVehicle()

   220

{

   221

	Vehicle *v;

   222

	int num;

   223

   224

	if (IS_HUMAN_PLAYER(_current_player)) {

   225

		num = 0;

   226

   227

		FOR_ALL_VEHICLES(v) {

   228

			if (v->index >= NUM_NORMAL_VEHICLES)

   229

				break;

   230

   231

			if (v->type == 0)

   232

				num++;

   233

		}

   234

   235

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   236

			return NULL;

   237

	}

   238

   239

	return ForceAllocateVehicle();

   240

}

   241

   242

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

   243

{

   244

	int x,y,x2,y2;

   245

	VehicleID veh;

   246

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

   247

   248

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

   249

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

   250

   251

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

   252

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

   253

   254

	for(;;) {

   255

		int xb = x;

   256

		for(;;) {

   257

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

   258

			while (veh != INVALID_VEHICLE) {

   259

				Vehicle *v = GetVehicle(veh);

   260

				void *a;

   261

   262

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

   263

					return a;

   264

				veh = v->next_hash;

   265

			}

   266

   267

			if (x == x2)

   268

				break;

   269

   270

			x = (x + 1) & 0x3F;

   271

		}

   272

		x = xb;

   273

   274

		if (y == y2)

   275

			break;

   276

   277

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

   278

	}

   279

	return NULL;

   280

}

   281

   282

   283

   284

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

   285

{

   286

	VehicleID *old_hash, *new_hash;

   287

	int old_x = v->left_coord;

   288

	int old_y = v->top_coord;

   289

	Vehicle *u;

   290

   291

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

   292

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

   293

   294

	if (old_hash == new_hash)

   295

		return;

   296

   297

	/* remove from hash table? */

   298

	if (old_hash != NULL) {

   299

		Vehicle *last = NULL;

   300

		int idx = *old_hash;

   301

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

   302

			idx = u->next_hash;

   303

			assert(idx != INVALID_VEHICLE);

   304

			last = u;

   305

		}

   306

   307

		if (last == NULL)

   308

			*old_hash = v->next_hash;

   309

		else

   310

			last->next_hash = v->next_hash;

   311

	}

   312

   313

	/* insert into hash table? */

   314

	if (new_hash != NULL) {

   315

		v->next_hash = *new_hash;

   316

		*new_hash = v->index;

   317

	}

   318

}

   319

   320

void InitializeVehicles()

   321

{

   322

	Vehicle *v;

   323

	int i;

   324

   325

	// clear it...

   326

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

   327

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

   328

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

   329

   330

	// setup indexes..

   331

	i = 0;

   332

	FOR_ALL_VEHICLES(v)

   333

		v->index = i++;

   334

   335

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

   336

}

   337

   338

Vehicle *GetLastVehicleInChain(Vehicle *v)

   339

{

   340

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

   341

	return v;

   342

}

   343

   344

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   345

{

   346

	Vehicle *org = v;

   347

   348

	FOR_ALL_VEHICLES(v) {

   349

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

   350

			return v;

   351

	}

   352

   353

	return NULL;

   354

}

   355

   356

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   357

{

   358

	Vehicle *u;

   359

   360

	while (true) {

   361

		u = v;

   362

		v = GetPrevVehicleInChain(v);

   363

		/* If there is no such vehicle,

   364

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

   365

		if (v == NULL)

   366

			return u;

   367

	}

   368

}

   369

   370

int CountVehiclesInChain(Vehicle *v)

   371

{

   372

	int count = 0;

   373

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

   374

	return count;

   375

}

   376

   377

   378

Depot *AllocateDepot()

   379

{

   380

	Depot *dep, *free_dep = NULL;

   381

	int num_free = 0;

   382

   383

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

   384

		if (dep->xy == 0) {

   385

			num_free++;

   386

			if (free_dep==NULL)

   387

				free_dep = dep;

   388

		}

   389

	}

   390

   391

	if (free_dep == NULL ||

   392

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

   393

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   394

		return NULL;

   395

	}

   396

   397

	return free_dep;

   398

}

   399

   400

Waypoint *AllocateWaypoint()

   401

{

   402

	Waypoint *cp;

   403

   404

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

   405

		if (cp->xy == 0)

   406

			return cp;

   407

	}

   408

   409

	return NULL;

   410

}

   411

   412

uint GetWaypointByTile(uint tile)

   413

{

   414

	Waypoint *cp;

   415

	int i=0;

   416

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

   417

	return i;

   418

}

   419

   420

void DoDeleteDepot(uint tile)

   421

{

   422

	Order order;

   423

	byte dep_index;

   424

	Depot *d;

   425

   426

	// Clear it

   427

	DoClearSquare(tile);

   428

   429

	// Nullify the depot struct

   430

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

   431

	d->xy = 0;

   432

   433

	order.type = OT_GOTO_DEPOT;

   434

	order.station = dep_index;

   435

	DeleteDestinationFromVehicleOrder(order);

   436

   437

	// Delete the depot

   438

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   439

}

   440

   441

void DeleteVehicle(Vehicle *v)

   442

{

   443

	DeleteName(v->string_id);

   444

	v->type = 0;

   445

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   446

	v->next_hash = 0xffff;

   447

   448

	if (v->orders != NULL)

   449

		DeleteVehicleOrders(v);

   450

}

   451

   452

void DeleteVehicleChain(Vehicle *v)

   453

{

   454

	do {

   455

		Vehicle *u = v;

   456

		v = v->next;

   457

		DeleteVehicle(u);

   458

	} while (v);

   459

}

   460

   461

   462

void Aircraft_Tick(Vehicle *v);

   463

void RoadVeh_Tick(Vehicle *v);

   464

void Ship_Tick(Vehicle *v);

   465

void Train_Tick(Vehicle *v);

   466

static void EffectVehicle_Tick(Vehicle *v);

   467

void DisasterVehicle_Tick(Vehicle *v);

   468

   469

VehicleTickProc *_vehicle_tick_procs[] = {

   470

	Train_Tick,

   471

	RoadVeh_Tick,

   472

	Ship_Tick,

   473

	Aircraft_Tick,

   474

	EffectVehicle_Tick,

   475

	DisasterVehicle_Tick,

   476

};

   477

   478

void CallVehicleTicks()

   479

{

   480

	Vehicle *v;

   481

   482

	FOR_ALL_VEHICLES(v) {

   483

		if (v->type != 0)

   484

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

   485

	}

   486

}

   487

   488

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   489

{

   490

	uint32 full = 0, not_full = 0;

   491

   492

	//special handling of aircraft

   493

   494

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

   495

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

   496

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

   497

		return true;

   498

	}

   499

   500

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

   501

	do {

   502

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

   503

		assert(v->cargo_type<32);

   504

   505

		if (v->cargo_cap != 0) {

   506

			uint32 mask = 1 << v->cargo_type;

   507

			if (v->cargo_cap == v->cargo_count) full |= mask; else not_full |= mask;

   508

		}

   509

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

   510

   511

	// continue loading if there is a non full cargo type and no cargo type that is full

   512

	return not_full && (full & ~not_full) == 0;

   513

}

   514