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

/*

    31

 *	These command macros are used to call vehicle type specific commands with non type specific commands

    32

 *	it should be used like: DoCommandP(x, y, p1, p2, flags, CMD_STARTSTOP_VEH(v->type))

    33

 *	that line will start/stop a vehicle nomatter what type it is

    34

 *	VEH_Train is used as an offset because the vehicle type values doesn't start with 0

    35

 */

    36

    37

#define CMD_BUILD_VEH(x)		   _veh_build_proc_table[ x - VEH_Train]

    38

#define CMD_SELL_VEH(x)				_veh_sell_proc_table[ x - VEH_Train]

    39

#define CMD_STARTSTOP_VEH(x)  _veh_start_stop_proc_table[ x - VEH_Train]

    40

#define CMD_REFIT_VEH(x)		   _veh_refit_proc_table[ x - VEH_Train]

    41

    43

	CMD_BUILD_RAIL_VEHICLE,

    44

	CMD_BUILD_ROAD_VEH,

    45

	CMD_BUILD_SHIP,

    46

	CMD_BUILD_AIRCRAFT,

    47

};

    49

	CMD_SELL_RAIL_WAGON,

    50

	CMD_SELL_ROAD_VEH,

    51

	CMD_SELL_SHIP,

    52

	CMD_SELL_AIRCRAFT,

    53

};

    55

	CMD_START_STOP_TRAIN,

    56

	CMD_START_STOP_ROADVEH,

    57

	CMD_START_STOP_SHIP,

    58

	CMD_START_STOP_AIRCRAFT,

    59

};

    61

	CMD_REFIT_RAIL_VEHICLE,

    62

	0,	// road vehicles can't be refitted

    63

	CMD_REFIT_SHIP,

    64

	CMD_REFIT_AIRCRAFT,

    65

};

    66

    67

    68

enum {

    69

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

    70

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

    71

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    72

    73

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

    74

};

    75

    76

/**

    77

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

    78

 */

    79

static void VehiclePoolNewBlock(uint start_item)

    80

{

    81

	Vehicle *v;

    82

    83

	FOR_ALL_VEHICLES_FROM(v, start_item)

    84

		v->index = start_item++;

    85

}

    86

    87

/* Initialize the vehicle-pool */

    88

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

    89

    90

void VehicleServiceInDepot(Vehicle *v)

    91

{

    92

	v->date_of_last_service = _date;

    93

	v->breakdowns_since_last_service = 0;

    94

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

    95

}

    96

    97

bool VehicleNeedsService(const Vehicle *v)

    98

{

    99

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

   100

		return false;

   101

   102

	if (v->vehstatus & VS_CRASHED)

   103

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

   104

   105

	return _patches.servint_ispercent ?

   106

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

   107

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

   108

}

   109

   111

{

   112

	StringID id;

   113

   114

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

   115

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

   116

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

   117

		(id = STR_980E_SHIP_IN_THE_WAY, true);

   118

   119

	_error_message = id;

   120

}

   121

   122

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

   123

{

   124

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

   125

		return NULL;

   126

   127

	VehicleInTheWayErrMsg(v);

   128

	return v;

   129

}

   130

   131

bool EnsureNoVehicle(TileIndex tile)

   132

{

   133

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

   134

}

   135

   136

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

   137

{

   138

	const TileInfo *ti = data;

   139

   140

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

   141

		return NULL;

   142

   143

	VehicleInTheWayErrMsg(v);

   144

	return v;

   145

}

   146

   147

static inline uint Correct_Z(uint tileh)

   148

{

   149

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

   150

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

   151

	return CorrectZ(tileh) ? 8 : 0;

   152

}

   153

   154

uint GetCorrectTileHeight(TileIndex tile)

   155

{

   156

	return Correct_Z(GetTileSlope(tile, NULL));

   157

}

   158

   159

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   160

{

   161

	TileInfo ti;

   162

   163

	FindLandscapeHeightByTile(&ti, tile);

   164

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

   165

   166

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

   167

}

   168

   169

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   170

{

   171

	TileInfo ti;

   172

   173

	ti.tile = tile;

   174

	ti.z = z;

   175

   176

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   177

}

   178

   179

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

   180

{

   181

	int x1 = TileX(from);

   182

	int y1 = TileY(from);

   183

	int x2 = TileX(to);

   184

	int y2 = TileY(to);

   185

	Vehicle *veh;

   186

   187

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

   188

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

   189

		intswap(x1,x2);

   190

		intswap(y1,y2);

   191

	}

   192

	FOR_ALL_VEHICLES(veh) {

   193

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

   194

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

   195

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

   196

				return veh;

   197

			}

   198

		}

   199

	}

   200

	return NULL;

   201

}

   202

   203

void VehiclePositionChanged(Vehicle *v)

   204

{

   205

	int img = v->cur_image;

   206

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

   207

	const Sprite* spr = GetSprite(img);

   208

   209

	pt.x += spr->x_offs;

   210

	pt.y += spr->y_offs;

   211

   212

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

   213

   214

	v->left_coord = pt.x;

   215

	v->top_coord = pt.y;

   216

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

   217

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

   218

}

   219

   220

// Called after load to update coordinates

   221

void AfterLoadVehicles(void)

   222

{

   223

	Vehicle *v;

   224

   225

	FOR_ALL_VEHICLES(v) {

   226

		v->first = NULL;

   227

		if (v->type != 0) {

   228

			switch (v->type) {

   229

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

   230

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

   231

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

   232

				case VEH_Aircraft:

   233

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

   234

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

   235

						if (v->next != NULL) {

   236

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

   237

						}

   238

					}

   239

					break;

   240

				default: break;

   241

			}

   242

   243

			v->left_coord = INVALID_COORD;

   244

			VehiclePositionChanged(v);

   245

   246

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

   247

				TrainConsistChanged(v);

   248

		}

   249

	}

   250

}

   251

   252

static Vehicle *InitializeVehicle(Vehicle *v)

   253

{

   254

	VehicleID index = v->index;

   255

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

   256

	v->index = index;

   257

   258

	assert(v->orders == NULL);

   259

   260

	v->left_coord = INVALID_COORD;

   261

	v->first = NULL;

   262

	v->next = NULL;

   263

	v->next_hash = INVALID_VEHICLE;

   264

	v->string_id = 0;

   265

	v->next_shared = NULL;

   266

	v->prev_shared = NULL;

   267

	v->depot_list  = NULL;

   268

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

   269

	    which are technical the same (newgrf stuff).

   270

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

   271

	    not really matter that one client has other visual vehicles than

   272

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

   273

	*/

   274

	v->random_bits = InteractiveRandomRange(256);

   275

	return v;

   276

}

   277

   278

Vehicle *ForceAllocateSpecialVehicle(void)

   279

{

   280

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

   281

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

   282

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

   283

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   284

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

   285

   286

	Vehicle *v;

   287

   288

	FOR_ALL_VEHICLES(v) {

   289

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

   290

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

   291

			return NULL;

   292

   293

		if (v->type == 0)

   294

			return InitializeVehicle(v);

   295

	}

   296

   297

	return NULL;

   298

}

   299

   300

/*

   301

 * finds a free vehicle in the memory or allocates a new one

   302

 * returns a pointer to the first free vehicle or NULL if all vehicles are in use

   303

 * *skip_vehicles is an offset to where in the array we should begin looking

   304

 * this is to avoid looping though the same vehicles more than once after we learned that they are not free

   305

 * this feature is used by AllocateVehicles() since it need to allocate more than one and when

   306

 * another block is added to _vehicle_pool, since we only do that when we know it's already full

   307

 */

   308

static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)

   309

{

   310

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

   311

	 * first blocks */

   312

	Vehicle *v;

   313

	const int offset = (1 << VEHICLES_POOL_BLOCK_SIZE_BITS) * BLOCKS_FOR_SPECIAL_VEHICLES;

   314

   315

	if (*skip_vehicles < (_vehicle_pool.total_items - offset)) {	// make sure the offset in the array is not larger than the array itself

   316

		FOR_ALL_VEHICLES_FROM(v, offset + *skip_vehicles) {

   317

			(*skip_vehicles)++;

   318

			if (v->type == 0)

   319

				return InitializeVehicle(v);

   320

		}

   321

	}

   322

   323

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

   324

	if (AddBlockToPool(&_vehicle_pool))

   325

		return AllocateSingleVehicle(skip_vehicles);

   326

   327

	return NULL;

   328

}

   329

   330

Vehicle *AllocateVehicle(void)

   331

{

   332

	VehicleID counter = 0;

   333

	return AllocateSingleVehicle(&counter);

   334

}

   335

   336

/** Allocates a lot of vehicles and frees them again

   337

* @param vl pointer to an array of vehicles to get allocated. Can be NULL if the vehicles aren't needed (makes it test only)

   338

* @param num number of vehicles to allocate room for

   339

*	returns true if there is room to allocate all the vehicles

   340

*/

   341

bool AllocateVehicles(Vehicle **vl, int num)

   342

{

   343

	int i;

   344

	Vehicle *v;

   345

	VehicleID counter = 0;

   346

   347

	for(i = 0; i != num; i++) {

   348

		v = AllocateSingleVehicle(&counter);

   349

		if (v == NULL) {

   350

			return false;

   351

		}

   352

		if (vl != NULL) {

   353

			vl[i] = v;

   354

		}

   355

	}

   356

   357

	return true;

   358

}

   359

   360

   361

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

   362

{

   363

	int x,y,x2,y2;

   364

	VehicleID veh;

   365

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

   366

   367

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

   368

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

   369

   370

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

   371

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

   372

   373

	for(;;) {

   374

		int xb = x;

   375

		for(;;) {

   376

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

   377

			while (veh != INVALID_VEHICLE) {

   378

				Vehicle *v = GetVehicle(veh);

   379

				void *a;

   380

   381

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

   382

					return a;

   383

				veh = v->next_hash;

   384

			}

   385

   386

			if (x == x2)

   387

				break;

   388

   389

			x = (x + 1) & 0x3F;

   390

		}

   391

		x = xb;

   392

   393

		if (y == y2)

   394

			break;

   395

   396

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

   397

	}

   398

	return NULL;

   399

}

   400

   401

   402

   403

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

   404

{

   405

	VehicleID *old_hash, *new_hash;

   406

	int old_x = v->left_coord;

   407

	int old_y = v->top_coord;

   408

	Vehicle *u;

   409

   410

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

   411

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

   412

   413

	if (old_hash == new_hash)

   414

		return;

   415

   416

	/* remove from hash table? */

   417

	if (old_hash != NULL) {

   418

		Vehicle *last = NULL;

   419

		VehicleID idx = *old_hash;

   420

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

   421

			idx = u->next_hash;

   422

			assert(idx != INVALID_VEHICLE);

   423

			last = u;

   424

		}

   425

   426

		if (last == NULL)

   427

			*old_hash = v->next_hash;

   428

		else

   429

			last->next_hash = v->next_hash;

   430

	}

   431

   432

	/* insert into hash table? */

   433

	if (new_hash != NULL) {

   434

		v->next_hash = *new_hash;

   435

		*new_hash = v->index;

   436

	}

   437

}

   438

   439

void InitializeVehicles(void)

   440

{

   441

	int i;

   442

   443

	/* Clean the vehicle pool, and reserve enough blocks

   444

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

   445

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

   446

	CleanPool(&_vehicle_pool);

   447

	AddBlockToPool(&_vehicle_pool);

   448

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

   449

		AddBlockToPool(&_vehicle_pool);

   450

   451

	// clear it...

   452

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

   453

}

   454

   455

Vehicle *GetLastVehicleInChain(Vehicle *v)

   456

{

   457

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

   458

	return v;

   459

}

   460

   461

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

   462

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

   463

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

   464

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

   465

 * called by anything but GetFirstVehicleInChain

   466

 */

   467

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   468

{

   469

	Vehicle *u;

   470

   471

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

   472

   473

	return NULL;

   474

}

   475

   476

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

   477

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

   478

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

   479

 */

   480

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   481

{

   482

	Vehicle *u;

   483

	assert(v != NULL);

   484

   485

	u = GetFirstVehicleInChain(v);

   486

   487

 	// Check to see if this is the first

   488

	if (v == u) return NULL;

   489

   490

	do {

   491

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

   492

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

   493

   494

	return NULL;

   495

}

   496

   497

/** Finds the first vehicle in a chain.

   498

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

   499

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