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

			switch (v->type) {

   191

				case VEH_Train: v->cur_image = GetTrainImage(v, v->direction); break;

   192

				case VEH_Road: v->cur_image = GetRoadVehImage(v, v->direction); break;

   193

				case VEH_Ship: v->cur_image = GetShipImage(v, v->direction); break;

   194

				case VEH_Aircraft:

   195

					if (v->subtype == 0 || v->subtype == 2) {

   196

						v->cur_image = GetAircraftImage(v, v->direction);

   197

						if (v->next != NULL) {

   198

							v->next->cur_image = v->cur_image;

   199

						}

   200

					}

   201

					break;

   202

				default: break;

   203

			}

   204

   205

			v->left_coord = INVALID_COORD;

   206

			VehiclePositionChanged(v);

   207

   208

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

   209

				TrainConsistChanged(v);

   210

		}

   211

	}

   212

}

   213

   214

static Vehicle *InitializeVehicle(Vehicle *v)

   215

{

   216

	VehicleID index = v->index;

   217

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

   218

	v->index = index;

   219

   220

	assert(v->orders == NULL);

   221

   222

	v->left_coord = INVALID_COORD;

   223

	v->first = NULL;

   224

	v->next = NULL;

   225

	v->next_hash = INVALID_VEHICLE;

   226

	v->string_id = 0;

   227

	v->next_shared = NULL;

   228

	v->prev_shared = NULL;

   229

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

   230

	    which are technical the same (newgrf stuff).

   231

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

   232

	    not really matter that one client has other visual vehicles than

   233

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

   234

	*/

   235

	v->random_bits = InteractiveRandomRange(256);

   236

	return v;

   237

}

   238

   239

Vehicle *ForceAllocateSpecialVehicle(void)

   240

{

   241

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

   242

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

   243

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

   244

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   245

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

   246

   247

	Vehicle *v;

   248

   249

	FOR_ALL_VEHICLES(v) {

   250

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

   251

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

   252

			return NULL;

   253

   254

		if (v->type == 0)

   255

			return InitializeVehicle(v);

   256

	}

   257

   258

	return NULL;

   259

}

   260

   261

Vehicle *AllocateVehicle(void)

   262

{

   263

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

   264

	 * first blocks */

   265

	Vehicle *v;

   266

   267

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

   268

		if (v->type == 0)

   269

			return InitializeVehicle(v);

   270

	}

   271

   272

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

   273

	if (AddBlockToPool(&_vehicle_pool))

   274

		return AllocateVehicle();

   275

   276

	return NULL;

   277

}

   278

   279

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

   280

{

   281

	int x,y,x2,y2;

   282

	VehicleID veh;

   283

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

   284

   285

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

   286

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

   287

   288

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

   289

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

   290

   291

	for(;;) {

   292

		int xb = x;

   293

		for(;;) {

   294

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

   295

			while (veh != INVALID_VEHICLE) {

   296

				Vehicle *v = GetVehicle(veh);

   297

				void *a;

   298

   299

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

   300

					return a;

   301

				veh = v->next_hash;

   302

			}

   303

   304

			if (x == x2)

   305

				break;

   306

   307

			x = (x + 1) & 0x3F;

   308

		}

   309

		x = xb;

   310

   311

		if (y == y2)

   312

			break;

   313

   314

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

   315

	}

   316

	return NULL;

   317

}

   318

   319

   320

   321

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

   322

{

   323

	VehicleID *old_hash, *new_hash;

   324

	int old_x = v->left_coord;

   325

	int old_y = v->top_coord;

   326

	Vehicle *u;

   327

   328

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

   329

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

   330

   331

	if (old_hash == new_hash)

   332

		return;

   333

   334

	/* remove from hash table? */

   335

	if (old_hash != NULL) {

   336

		Vehicle *last = NULL;

   337

		int idx = *old_hash;

   338

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

   339

			idx = u->next_hash;

   340

			assert(idx != INVALID_VEHICLE);

   341

			last = u;

   342

		}

   343

   344

		if (last == NULL)

   345

			*old_hash = v->next_hash;

   346

		else

   347

			last->next_hash = v->next_hash;

   348

	}

   349

   350

	/* insert into hash table? */

   351

	if (new_hash != NULL) {

   352

		v->next_hash = *new_hash;

   353

		*new_hash = v->index;

   354

	}

   355

}

   356

   357

void InitializeVehicles(void)

   358

{

   359

	int i;

   360

   361

	/* Clean the vehicle pool, and reserve enough blocks

   362

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

   363

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

   364

	CleanPool(&_vehicle_pool);

   365

	AddBlockToPool(&_vehicle_pool);

   366

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

   367

		AddBlockToPool(&_vehicle_pool);

   368

   369

	// clear it...

   370

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

   371

}

   372

   373

Vehicle *GetLastVehicleInChain(Vehicle *v)

   374

{

   375

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

   376

	return v;

   377

}

   378

   379

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

   380

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

   381

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

   382

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

   383

 * called by anything but GetFirstVehicleInChain

   384

 */

   385

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   386

{

   387

	Vehicle *u;

   388

   389

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

   390

   391

	return NULL;

   392

}

   393

   394

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

   395

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

   396

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

   397

 */

   398

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   399

{

   400

	Vehicle *u;

   401

	assert(v != NULL);

   402

   403

	u = GetFirstVehicleInChain(v);

   404

   405

 	// Check to see if this is the first

   406

	if (v == u) return NULL;

   407

   408

	do {

   409

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

   410

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

   411

   412

	return NULL;

   413

}

   414

   415

/** Finds the first vehicle in a chain.

   416

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

   417

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

   418

 */

   419

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   420

{

   421

	Vehicle* u;

   422

   423

	assert(v != NULL);

   424

   425

	if (v->first != NULL) {

   426

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

   427

   428

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

   429

	}

   430

   431

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

   432

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

   433

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

   434

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

   435

   436

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

   437

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

   438

   439

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

   440

	if (v->subtype == TS_Front_Engine)

   441

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

   442

   443

	return (Vehicle*)v;

   444

}

   445

   446

int CountVehiclesInChain(Vehicle *v)

   447

{

   448

	int count = 0;

   449

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

   450

	return count;

   451

}

   452

   453

void DeleteVehicle(Vehicle *v)

   454

{

   455

	DeleteName(v->string_id);

   456

	v->type = 0;

   457

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   458

	v->next_hash = INVALID_VEHICLE;

   459

   460

	if (v->orders != NULL)

   461

		DeleteVehicleOrders(v);

   462

}

   463

   464

void DeleteVehicleChain(Vehicle *v)

   465

{

   466

	do {

   467

		Vehicle *u = v;

   468

		v = v->next;

   469

		DeleteVehicle(u);

   470

	} while (v != NULL);

   471

}

   472

   473

   474

void Aircraft_Tick(Vehicle *v);

   475

void RoadVeh_Tick(Vehicle *v);

   476

void Ship_Tick(Vehicle *v);

   477

void Train_Tick(Vehicle *v);

   478

static void EffectVehicle_Tick(Vehicle *v);

   479

void DisasterVehicle_Tick(Vehicle *v);

   480

   481

VehicleTickProc *_vehicle_tick_procs[] = {

   482

	Train_Tick,

   483

	RoadVeh_Tick,

   484

	Ship_Tick,

   485

	Aircraft_Tick,

   486

	EffectVehicle_Tick,

   487

	DisasterVehicle_Tick,

   488

};

   489

   490

void CallVehicleTicks(void)

   491

{

   492

	Vehicle *v;

   493

   494

	FOR_ALL_VEHICLES(v) {

   495

		if (v->type != 0)

   496

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

   497

	}

   498

}

   499

   500

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   501

{

   502

	uint32 full = 0, not_full = 0;

   503