1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "spritecache.h"

     6

#include "table/sprites.h"

     7

#include "table/strings.h"

     8

#include "functions.h"

     9

#include "map.h"

    10

#include "tile.h"

    11

#include "vehicle.h"

    12

#include "gfx.h"

    13

#include "viewport.h"

    14

#include "news.h"

    15

#include "command.h"

    16

#include "saveload.h"

    17

#include "player.h"

    18

#include "engine.h"

    19

#include "sound.h"

    20

#include "debug.h"

    21

#include "vehicle_gui.h"

    22

#include "depot.h"

    23

#include "station.h"

    24

#include "gui.h"

    25

#include "rail.h"

    26

    27

#define INVALID_COORD (-0x8000)

    28

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

    29

    30

enum {

    31

	/* Max vehicles: 64000 (512 * 125) */

    32

	VEHICLES_POOL_BLOCK_SIZE_BITS = 9,       /* In bits, so (1 << 9) == 512 */

    33

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    34

    35

	BLOCKS_FOR_SPECIAL_VEHICLES   = 2, //! Blocks needed for special vehicles

    36

};

    37

    38

/**

    39

 * Called if a new block is added to the vehicle-pool

    40

 */

    41

static void VehiclePoolNewBlock(uint start_item)

    42

{

    43

	Vehicle *v;

    44

    45

	FOR_ALL_VEHICLES_FROM(v, start_item)

    46

		v->index = start_item++;

    47

}

    48

    49

/* Initialize the vehicle-pool */

    50

MemoryPool _vehicle_pool = { "Vehicle", VEHICLES_POOL_MAX_BLOCKS, VEHICLES_POOL_BLOCK_SIZE_BITS, sizeof(Vehicle), &VehiclePoolNewBlock, 0, 0, NULL };

    51

    52

void VehicleServiceInDepot(Vehicle *v)

    53

{

    54

	v->date_of_last_service = _date;

    55

	v->breakdowns_since_last_service = 0;

    56

	v->reliability = GetEngine(v->engine_type)->reliability;

    57

}

    58

    59

bool VehicleNeedsService(const Vehicle *v)

    60

{

    61

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

    62

		return false;

    63

    64

	if (v->vehstatus & VS_CRASHED)

    65

		return false; /* Crashed vehicles don't need service anymore */

    66

    67

	return _patches.servint_ispercent ?

    68

		(v->reliability < GetEngine(v->engine_type)->reliability * (100 - v->service_interval) / 100) :

    69

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

    70

}

    71

    72

void VehicleInTheWayErrMsg(Vehicle *v)

    73

{

    74

	StringID id;

    75

    76

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

    77

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

    78

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

    79

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    80

    81

	_error_message = id;

    82

}

    83

    84

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

    85

{

    86

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

    87

		return NULL;

    88

    89

	VehicleInTheWayErrMsg(v);

    90

	return v;

    91

}

    92

    93

bool EnsureNoVehicle(TileIndex tile)

    94

{

    95

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

    96

}

    97

    98

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

    99

{

   100

	const TileInfo *ti = data;

   101

   102

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

   103

		return NULL;

   104

   105

	VehicleInTheWayErrMsg(v);

   106

	return v;

   107

}

   108

   109

static inline uint Correct_Z(uint tileh)

   110

{

   111

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

   112

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

   113

	return CorrectZ(tileh) ? 8 : 0;

   114

}

   115

   116

uint GetCorrectTileHeight(TileIndex tile)

   117

{

   118

	return Correct_Z(GetTileSlope(tile, NULL));

   119

}

   120

   121

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   122

{

   123

	TileInfo ti;

   124

   125

	FindLandscapeHeightByTile(&ti, tile);

   126

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

   127

   128

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

   129

}

   130

   131

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   132

{

   133

	TileInfo ti;

   134

   135

	ti.tile = tile;

   136

	ti.z = z;

   137

   138

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   139

}

   140

   141

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

   142

{

   143

	int x1 = TileX(from);

   144

	int y1 = TileY(from);

   145

	int x2 = TileX(to);

   146

	int y2 = TileY(to);

   147

	Vehicle *veh;

   148

   149

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

   150

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

   151

		intswap(x1,x2);

   152

		intswap(y1,y2);

   153

	}

   154

	FOR_ALL_VEHICLES(veh) {

   155

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

   156

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

   157

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

   158

				return veh;

   159

			}

   160

		}

   161

	}

   162

	return NULL;

   163

}

   164

   165

void VehiclePositionChanged(Vehicle *v)

   166

{

   167

	int img = v->cur_image;

   168

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

   169

	const Sprite* spr = GetSprite(img);

   170

   171

	pt.x += spr->x_offs;

   172

	pt.y += spr->y_offs;

   173

   174

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

   175

   176

	v->left_coord = pt.x;

   177

	v->top_coord = pt.y;

   178

	v->right_coord = pt.x + spr->width + 2;

   179

	v->bottom_coord = pt.y + spr->height + 2;

   180

}

   181

   182

// Called after load to update coordinates

   183

void AfterLoadVehicles(void)

   184

{

   185

	Vehicle *v;

   186

   187

	FOR_ALL_VEHICLES(v) {

   188

		v->first = NULL;

   189

		if (v->type != 0) {

   190

			v->left_coord = INVALID_COORD;

   191

			VehiclePositionChanged(v);

   192

   193

			if (v->type == VEH_Train && (v->subtype == TS_Front_Engine || v->subtype == TS_Free_Car))

   194

				TrainConsistChanged(v);

   195

		}

   196

	}

   197

}

   198

   199

static Vehicle *InitializeVehicle(Vehicle *v)

   200

{

   201

	VehicleID index = v->index;

   202

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

   203

	v->index = index;

   204

   205

	assert(v->orders == NULL);

   206

   207

	v->left_coord = INVALID_COORD;

   208

	v->first = NULL;

   209

	v->next = NULL;

   210

	v->next_hash = INVALID_VEHICLE;

   211

	v->string_id = 0;

   212

	v->next_shared = NULL;

   213

	v->prev_shared = NULL;

   214

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

   215

	    which are technical the same (newgrf stuff).

   216

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

   217

	    not really matter that one client has other visual vehicles than

   218

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

   219

	*/

   220

	v->random_bits = InteractiveRandomRange(256);

   221

	return v;

   222

}

   223

   224

Vehicle *ForceAllocateSpecialVehicle(void)

   225

{

   226

	/* This stays a strange story.. there should always be room for special

   227

	 * vehicles (special effects all over the map), but with 65k of vehicles

   228

	 * is this realistic to double-check for that? For now we just reserve

   229

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   230

	 * be used for special vehicles.. should work nicely :) */

   231

   232

	Vehicle *v;

   233

   234

	FOR_ALL_VEHICLES(v) {

   235

		/* No more room for the special vehicles, return NULL */

   236

		if (v->index >= (1 << _vehicle_pool.block_size_bits) * BLOCKS_FOR_SPECIAL_VEHICLES)

   237

			return NULL;

   238

   239

		if (v->type == 0)

   240

			return InitializeVehicle(v);

   241

	}

   242

   243

	return NULL;

   244

}

   245

   246

Vehicle *AllocateVehicle(void)

   247

{

   248

	/* See note by ForceAllocateSpecialVehicle() why we skip the

   249

	 * first blocks */

   250

	Vehicle *v;

   251

   252

	FOR_ALL_VEHICLES_FROM(v, (1 << _vehicle_pool.block_size_bits) * BLOCKS_FOR_SPECIAL_VEHICLES) {

   253

		if (v->type == 0)

   254

			return InitializeVehicle(v);

   255

	}

   256

   257

	/* Check if we can add a block to the pool */

   258

	if (AddBlockToPool(&_vehicle_pool))

   259

		return AllocateVehicle();

   260

   261

	return NULL;

   262

}

   263

   264

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

   265

{

   266

	int x,y,x2,y2;

   267

	VehicleID veh;

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

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

   275

   276

	for(;;) {

   277

		int xb = x;

   278

		for(;;) {

   279

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

   280

			while (veh != INVALID_VEHICLE) {

   281

				Vehicle *v = GetVehicle(veh);

   282

				void *a;

   283

   284

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

   285

					return a;

   286

				veh = v->next_hash;

   287

			}

   288

   289

			if (x == x2)

   290

				break;

   291

   292

			x = (x + 1) & 0x3F;

   293

		}

   294

		x = xb;

   295

   296

		if (y == y2)

   297

			break;

   298

   299

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

   300

	}

   301

	return NULL;

   302

}

   303

   304

   305

   306

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

   307

{

   308

	VehicleID *old_hash, *new_hash;

   309

	int old_x = v->left_coord;

   310

	int old_y = v->top_coord;

   311

	Vehicle *u;

   312

   313

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

   314

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

   315

   316

	if (old_hash == new_hash)

   317

		return;

   318

   319

	/* remove from hash table? */

   320

	if (old_hash != NULL) {

   321

		Vehicle *last = NULL;

   322

		int idx = *old_hash;

   323

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

   324

			idx = u->next_hash;

   325

			assert(idx != INVALID_VEHICLE);

   326

			last = u;

   327

		}

   328

   329

		if (last == NULL)

   330

			*old_hash = v->next_hash;

   331

		else

   332

			last->next_hash = v->next_hash;

   333

	}

   334

   335

	/* insert into hash table? */

   336

	if (new_hash != NULL) {

   337

		v->next_hash = *new_hash;

   338

		*new_hash = v->index;

   339

	}

   340

}

   341

   342

void InitializeVehicles(void)

   343

{

   344

	int i;

   345

   346

	/* Clean the vehicle pool, and reserve enough blocks

   347

	 *  for the special vehicles, plus one for all the other

   348

	 *  vehicles (which is increased on-the-fly) */

   349

	CleanPool(&_vehicle_pool);

   350

	AddBlockToPool(&_vehicle_pool);

   351

	for (i = 0; i < BLOCKS_FOR_SPECIAL_VEHICLES; i++)

   352

		AddBlockToPool(&_vehicle_pool);

   353

   354

	// clear it...

   355

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

   356

}

   357

   358

Vehicle *GetLastVehicleInChain(Vehicle *v)

   359

{

   360

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

   361

	return v;

   362

}

   363

   364

/** Finds the previous vehicle in a chain, by a brute force search.

   365

 * This old function is REALLY slow because it searches through all vehicles to

   366

 * find the previous vehicle, but if v->first has not been set, then this function

   367

 * will need to be used to find the previous one. This function should never be

   368

 * called by anything but GetFirstVehicleInChain

   369

 */

   370

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   371

{

   372

	Vehicle *u;

   373

   374

	FOR_ALL_VEHICLES(u) if (u->type == VEH_Train && u->next == v) return u;

   375

   376

	return NULL;

   377

}

   378

   379

/** Find the previous vehicle in a chain, by using the v->first cache.

   380

 * While this function is fast, it cannot be used in the GetFirstVehicleInChain

   381

 * function, otherwise you'll end up in an infinite loop call

   382

 */

   383

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   384

{

   385

	Vehicle *u;

   386

	assert(v != NULL);

   387

   388

	u = GetFirstVehicleInChain(v);

   389

   390

 	// Check to see if this is the first

   391

	if (v == u) return NULL;

   392

   393

	do {

   394

		if (u->next == v) return u;

   395

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

   396

   397

	return NULL;

   398

}

   399

   400

/** Finds the first vehicle in a chain.

   401

 * This function reads out the v->first cache. Should the cache be dirty,

   402

 * it determines the first vehicle in a chain, and updates the cache.

   403

 */

   404

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   405

{

   406

	Vehicle* u;

   407

   408

	assert(v != NULL);

   409

   410

	if (v->first != NULL) {

   411

		if (v->first->subtype == TS_Front_Engine) return v->first;

   412

   413

		DEBUG(misc, 0) ("v->first cache faulty. We shouldn't be here, rebuilding cache!");

   414

	}

   415

   416

	/* It is the fact (currently) that newly built vehicles do not have

   417

	* their ->first pointer set. When this is the case, go up to the

   418

	* first engine and set the pointers correctly. Also the first pointer

   419

	* is not saved in a savegame, so this has to be fixed up after loading */

   420

   421

	/* Find the 'locomotive' or the first wagon in a chain */

   422

	while ((u = GetPrevVehicleInChain_bruteforce(v)) != NULL) v = u;

   423

   424

	/* Set the first pointer of all vehicles in that chain to the first wagon */

   425

	if (v->subtype == TS_Front_Engine)

   426

		for (u = (Vehicle *)v; u != NULL; u = u->next) u->first = (Vehicle *)v;

   427

   428

	return (Vehicle*)v;

   429

}

   430

   431

int CountVehiclesInChain(Vehicle *v)

   432

{

   433

	int count = 0;

   434

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

   435

	return count;

   436

}

   437

   438

void DeleteVehicle(Vehicle *v)

   439

{

   440

	DeleteName(v->string_id);

   441

	v->type = 0;

   442

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   443

	v->next_hash = INVALID_VEHICLE;

   444

   445

	if (v->orders != NULL)

   446

		DeleteVehicleOrders(v);

   447

}

   448

   449

void DeleteVehicleChain(Vehicle *v)

   450

{

   451

	do {

   452

		Vehicle *u = v;

   453

		v = v->next;

   454

		DeleteVehicle(u);

   455

	} while (v != NULL);

   456

}

   457

   458

   459

void Aircraft_Tick(Vehicle *v);

   460

void RoadVeh_Tick(Vehicle *v);

   461

void Ship_Tick(Vehicle *v);

   462

void Train_Tick(Vehicle *v);

   463

static void EffectVehicle_Tick(Vehicle *v);

   464

void DisasterVehicle_Tick(Vehicle *v);

   465

   466

VehicleTickProc *_vehicle_tick_procs[] = {

   467

	Train_Tick,

   468

	RoadVeh_Tick,

   469

	Ship_Tick,

   470

	Aircraft_Tick,

   471

	EffectVehicle_Tick,

   472

	DisasterVehicle_Tick,

   473

};

   474

   475

void CallVehicleTicks(void)

   476

{

   477

	Vehicle *v;

   478

   479

	FOR_ALL_VEHICLES(v) {

   480

		if (v->type != 0)

   481

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

   482

	}

   483

}

   484

   485

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   486

{

   487

	uint32 full = 0, not_full = 0;

   488

   489

	//special handling of aircraft

   490

   491

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

   492

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

   493

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

   494

		return true;

   495

	}

   496

   497

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

   498

	do {

   499

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

   500

		assert(v->cargo_type<32);

   501

   502

		if (v->cargo_cap != 0) {

   503

			uint32 mask = 1 << v->cargo_type;