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 "rail.h"

    25

    26

#define INVALID_COORD (-0x8000)

    27

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

    28

    29

enum {

    30

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

    31

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

    32

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    33

    34

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

    35

};

    36

    37

/**

    38

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

    39

 */

    40

static void VehiclePoolNewBlock(uint start_item)

    41

{

    42

	Vehicle *v;

    43

    44

	FOR_ALL_VEHICLES_FROM(v, start_item)

    45

		v->index = start_item++;

    46

}

    47

    48

/* Initialize the vehicle-pool */

    49

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

    50

    51

void VehicleServiceInDepot(Vehicle *v)

    52

{

    53

	v->date_of_last_service = _date;

    54

	v->breakdowns_since_last_service = 0;

    55

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

    56

}

    57

    58

bool VehicleNeedsService(const Vehicle *v)

    59

{

    60

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

    61

		return false;

    62

    63

	if (v->vehstatus & VS_CRASHED)

    64

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

    65

    66

	return _patches.servint_ispercent ?

    67

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

    68

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

    69

}

    70

    71

void VehicleInTheWayErrMsg(Vehicle *v)

    72

{

    73

	StringID id;

    74

    75

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

    76

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

    77

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

    78

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    79

    80

	_error_message = id;

    81

}

    82

    83

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

    84

{

    85

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

    86

		return NULL;

    87

    88

	VehicleInTheWayErrMsg(v);

    89

	return v;

    90

}

    91

    92

bool EnsureNoVehicle(TileIndex tile)

    93

{

    94

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

    95

}

    96

    97

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

    98

{

    99

	const TileInfo *ti = data;

   100

   101

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

   102

		return NULL;

   103

   104

	VehicleInTheWayErrMsg(v);

   105

	return v;

   106

}

   107

   108

static inline uint Correct_Z(uint tileh)

   109

{

   110

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

   111

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

   112

	return CorrectZ(tileh) ? 8 : 0;

   113

}

   114

   115

uint GetCorrectTileHeight(TileIndex tile)

   116

{

   117

	return Correct_Z(GetTileSlope(tile, NULL));

   118

}

   119

   120

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   121

{

   122

	TileInfo ti;

   123

   124

	FindLandscapeHeightByTile(&ti, tile);

   125

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

   126

   127

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

   128

}

   129

   130

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   131

{

   132

	TileInfo ti;

   133

   134

	ti.tile = tile;

   135

	ti.z = z;

   136

   137

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   138

}

   139

   140

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

   141

{

   142

	int x1 = TileX(from);

   143

	int y1 = TileY(from);

   144

	int x2 = TileX(to);

   145

	int y2 = TileY(to);

   146

	Vehicle *veh;

   147

   148

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

   149

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

   150

		intswap(x1,x2);

   151

		intswap(y1,y2);

   152

	}

   153

	FOR_ALL_VEHICLES(veh) {

   154

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

   155

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

   156

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

   157

				return veh;

   158

			}

   159

		}

   160

	}

   161

	return NULL;

   162

}

   163

   164

void VehiclePositionChanged(Vehicle *v)

   165

{

   166

	int img = v->cur_image;

   167

	const SpriteDimension *sd;

   168

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

   169

   170

	sd = GetSpriteDimension(img);

   171

   172

	pt.x += sd->xoffs;

   173

	pt.y += sd->yoffs;

   174

   175

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

   176

   177

	v->left_coord = pt.x;

   178

	v->top_coord = pt.y;

   179

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

   180

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

   181

}

   182

   183

// Called after load to update coordinates

   184

void AfterLoadVehicles(void)

   185

{

   186

	Vehicle *v;

   187

   188

	FOR_ALL_VEHICLES(v) {

   189

		v->first = NULL;

   190

		if (v->type != 0) {

   191

			v->left_coord = INVALID_COORD;

   192

			VehiclePositionChanged(v);

   193

   194

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

   195

				TrainConsistChanged(v);

   196

		}

   197

	}

   198

}

   199

   200

static Vehicle *InitializeVehicle(Vehicle *v)

   201

{

   202

	VehicleID index = v->index;

   203

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

   204

	v->index = index;

   205

   206

	assert(v->orders == NULL);

   207

   208

	v->left_coord = INVALID_COORD;

   209

	v->first = NULL;

   210

	v->next = NULL;

   211

	v->next_hash = INVALID_VEHICLE;

   212

	v->string_id = 0;

   213

	v->next_shared = NULL;

   214

	v->prev_shared = NULL;

   215

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

   216

	    which are technical the same (newgrf stuff).

   217

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

   218

	    not really matter that one client has other visual vehicles than

   219

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

   220

	*/

   221

	v->random_bits = InteractiveRandomRange(256);

   222

	return v;

   223

}

   224

   225

Vehicle *ForceAllocateSpecialVehicle(void)

   226

{

   227

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

   228

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

   229

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

   230

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   231

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

   232

   233

	Vehicle *v;

   234

   235

	FOR_ALL_VEHICLES(v) {

   236

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

   237

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

   238

			return NULL;

   239

   240

		if (v->type == 0)

   241

			return InitializeVehicle(v);

   242

	}

   243

   244

	return NULL;

   245

}

   246

   247

Vehicle *AllocateVehicle(void)

   248

{

   249

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

   250

	 * first blocks */

   251

	Vehicle *v;

   252

   253

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

   254

		if (v->type == 0)

   255

			return InitializeVehicle(v);

   256

	}

   257

   258

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

   259

	if (AddBlockToPool(&_vehicle_pool))

   260

		return AllocateVehicle();

   261

   262

	return NULL;

   263

}

   264

   265

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

   266

{

   267

	int x,y,x2,y2;

   268

	VehicleID veh;

   269

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

   270

   271

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

   272

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

   273

   274

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

   275

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

   276

   277

	for(;;) {

   278

		int xb = x;

   279

		for(;;) {

   280

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

   281

			while (veh != INVALID_VEHICLE) {

   282

				Vehicle *v = GetVehicle(veh);

   283

				void *a;

   284

   285

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

   286

					return a;

   287

				veh = v->next_hash;

   288

			}

   289

   290

			if (x == x2)

   291

				break;

   292

   293

			x = (x + 1) & 0x3F;

   294

		}

   295

		x = xb;

   296

   297

		if (y == y2)

   298

			break;

   299

   300

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

   301

	}

   302

	return NULL;

   303

}

   304

   305

   306

   307

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

   308

{

   309

	VehicleID *old_hash, *new_hash;

   310

	int old_x = v->left_coord;

   311

	int old_y = v->top_coord;

   312

	Vehicle *u;

   313

   314

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

   315

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

   316

   317

	if (old_hash == new_hash)

   318

		return;

   319

   320

	/* remove from hash table? */

   321

	if (old_hash != NULL) {

   322

		Vehicle *last = NULL;

   323

		int idx = *old_hash;

   324

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

   325

			idx = u->next_hash;

   326

			assert(idx != INVALID_VEHICLE);

   327

			last = u;

   328

		}

   329

   330

		if (last == NULL)

   331

			*old_hash = v->next_hash;

   332

		else

   333

			last->next_hash = v->next_hash;

   334

	}

   335

   336

	/* insert into hash table? */

   337

	if (new_hash != NULL) {

   338

		v->next_hash = *new_hash;

   339

		*new_hash = v->index;

   340

	}

   341

}

   342

   343

void InitializeVehicles(void)

   344

{

   345

	int i;

   346

   347

	/* Clean the vehicle pool, and reserve enough blocks

   348

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

   349

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

   350

	CleanPool(&_vehicle_pool);

   351

	AddBlockToPool(&_vehicle_pool);

   352

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

   353

		AddBlockToPool(&_vehicle_pool);

   354

   355

	// clear it...

   356

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

   357

}

   358

   359

Vehicle *GetLastVehicleInChain(Vehicle *v)

   360

{

   361

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

   362

	return v;

   363

}

   364

   365

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

   366

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

   367

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

   368

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

   369

 * called by anything but GetFirstVehicleInChain

   370

 */

   371

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   372

{

   373

	Vehicle *u;

   374

   375

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

   376

   377

	return NULL;

   378

}

   379

   380

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

   381

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

   382

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

   383

 */

   384

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   385

{

   386

	Vehicle *u;

   387

	assert(v != NULL);

   388

   389

	u = GetFirstVehicleInChain(v);

   390

   391

 	// Check to see if this is the first

   392

	if (v == u) return NULL;

   393

   394

	do {

   395

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

   396

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

   397

   398

	return NULL;

   399

}

   400

   401

/** Finds the first vehicle in a chain.

   402

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

   403

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

   404

 */

   405

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   406

{

   407

	Vehicle* u;

   408

   409

	assert(v != NULL);

   410

   411

	if (v->first != NULL) {

   412

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

   413

   414

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

   415

	}

   416

   417

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

   418

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

   419

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

   420

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

   421

   422

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

   423

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

   424

   425

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

   426

	if (v->subtype == TS_Front_Engine)

   427

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

   428

   429

	return (Vehicle*)v;

   430

}

   431

   432

int CountVehiclesInChain(Vehicle *v)

   433

{

   434

	int count = 0;

   435

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

   436

	return count;

   437

}

   438

   439

void DeleteVehicle(Vehicle *v)

   440

{

   441

	DeleteName(v->string_id);

   442

	v->type = 0;

   443

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   444

	v->next_hash = INVALID_VEHICLE;

   445

   446

	if (v->orders != NULL)

   447

		DeleteVehicleOrders(v);

   448

}

   449

   450

void DeleteVehicleChain(Vehicle *v)

   451

{

   452

	do {

   453

		Vehicle *u = v;

   454

		v = v->next;

   455

		DeleteVehicle(u);

   456

	} while (v != NULL);

   457

}

   458

   459

   460

void Aircraft_Tick(Vehicle *v);

   461

void RoadVeh_Tick(Vehicle *v);

   462

void Ship_Tick(Vehicle *v);

   463

void Train_Tick(Vehicle *v);

   464

static void EffectVehicle_Tick(Vehicle *v);

   465

void DisasterVehicle_Tick(Vehicle *v);

   466

   467

VehicleTickProc *_vehicle_tick_procs[] = {

   468

	Train_Tick,

   469

	RoadVeh_Tick,

   470

	Ship_Tick,

   471

	Aircraft_Tick,

   472

	EffectVehicle_Tick,

   473

	DisasterVehicle_Tick,

   474

};

   475

   476

void CallVehicleTicks(void)

   477

{

   478

	Vehicle *v;

   479

   480

	FOR_ALL_VEHICLES(v) {

   481

		if (v->type != 0)

   482

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

   483

	}

   484

}

   485

   486

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   487

{

   488

	uint32 full = 0, not_full = 0;

   489

   490

	//special handling of aircraft

   491

   492

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

   493

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

   494

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

   495

		return true;

   496

	}

   497

   498

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

   499

	do {

   500

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

   501

		assert(v->cargo_type<32);

   502

   503

		if (v->cargo_cap != 0) {

   504

			uint32 mask = 1 << v->cargo_type;