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

    42

static const uint32 _veh_build_proc_table[] = {

    43

	CMD_BUILD_RAIL_VEHICLE,

    44

	CMD_BUILD_ROAD_VEH,

    45

	CMD_BUILD_SHIP,

    46

	CMD_BUILD_AIRCRAFT,

    47

};

    48

static const uint32 _veh_sell_proc_table[] = {

    49

	CMD_SELL_RAIL_WAGON,

    50

	CMD_SELL_ROAD_VEH,

    51

	CMD_SELL_SHIP,

    52

	CMD_SELL_AIRCRAFT,

    53

};

    54

static const uint32 _veh_start_stop_proc_table[] = {

    55

	CMD_START_STOP_TRAIN,

    56

	CMD_START_STOP_ROADVEH,

    57

	CMD_START_STOP_SHIP,

    58

	CMD_START_STOP_AIRCRAFT,

    59

};

    60

static const uint32 _veh_refit_proc_table[] = {

    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

   110

void VehicleInTheWayErrMsg(const Vehicle* v)

   111

{

   118

}

   119

   120

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

   121

{

   122

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

   123

		return NULL;

   124

   125

	VehicleInTheWayErrMsg(v);

   126

	return v;

   127

}

   128

   129

bool EnsureNoVehicle(TileIndex tile)

   130

{

   131

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

   132

}

   133

   134

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

   135

{

   136

	const TileInfo *ti = data;

   137

   138

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

   139

		return NULL;

   140

   141

	VehicleInTheWayErrMsg(v);

   142

	return v;

   143

}

   144

   145

static inline uint Correct_Z(uint tileh)

   146

{

   147

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

   148

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

   149

	return CorrectZ(tileh) ? 8 : 0;

   150

}

   151

   152

uint GetCorrectTileHeight(TileIndex tile)

   153

{

   154

	return Correct_Z(GetTileSlope(tile, NULL));

   155

}

   156

   157

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   158

{

   159

	TileInfo ti;

   160

   161

	FindLandscapeHeightByTile(&ti, tile);

   162

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

   163

   164

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

   165

}

   166

   167

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   168

{

   169

	TileInfo ti;

   170

   171

	ti.tile = tile;

   172

	ti.z = z;

   173

   174

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   175

}

   176

   177

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

   178

{

   179

	int x1 = TileX(from);

   180

	int y1 = TileY(from);

   181

	int x2 = TileX(to);

   182

	int y2 = TileY(to);

   183

	Vehicle *veh;

   184

   185

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

   186

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

   187

		intswap(x1,x2);

   188

		intswap(y1,y2);

   189

	}

   190

	FOR_ALL_VEHICLES(veh) {

   191

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

   192

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

   193

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

   194

				return veh;

   195

			}

   196

		}

   197

	}

   198

	return NULL;

   199

}

   200

   201

void VehiclePositionChanged(Vehicle *v)

   202

{

   203

	int img = v->cur_image;

   204

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

   205

	const Sprite* spr = GetSprite(img);

   206

   207

	pt.x += spr->x_offs;

   208

	pt.y += spr->y_offs;

   209

   210

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

   211

   212

	v->left_coord = pt.x;

   213

	v->top_coord = pt.y;

   214

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

   215

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

   216

}

   217

   218

// Called after load to update coordinates

   219

void AfterLoadVehicles(void)

   220

{

   221

	Vehicle *v;

   222

   223

	FOR_ALL_VEHICLES(v) {

   224

		v->first = NULL;

   225

		if (v->type != 0) {

   226

			switch (v->type) {

   227

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

   228

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

   229

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

   230

				case VEH_Aircraft:

   231

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

   232

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

   233

						if (v->next != NULL) {

   234

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

   235

						}

   236

					}

   237

					break;

   238

				default: break;

   239

			}

   240

   241

			v->left_coord = INVALID_COORD;

   242

			VehiclePositionChanged(v);

   243

   244

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

   245

				TrainConsistChanged(v);

   246

		}

   247

	}

   248

}

   249

   250

static Vehicle *InitializeVehicle(Vehicle *v)

   251

{

   252

	VehicleID index = v->index;

   253

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

   254

	v->index = index;

   255

   256

	assert(v->orders == NULL);

   257

   258

	v->left_coord = INVALID_COORD;

   259

	v->first = NULL;

   260

	v->next = NULL;

   261

	v->next_hash = INVALID_VEHICLE;

   262

	v->string_id = 0;

   263

	v->next_shared = NULL;

   264

	v->prev_shared = NULL;

   265

	v->depot_list  = NULL;

   266

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

   267

	    which are technical the same (newgrf stuff).

   268

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

   269

	    not really matter that one client has other visual vehicles than

   270

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

   271

	*/

   272

	v->random_bits = InteractiveRandomRange(256);

   273

	return v;

   274

}

   275

   276

Vehicle *ForceAllocateSpecialVehicle(void)

   277

{

   278

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

   279

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

   280

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

   281

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   282

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

   283

   284

	Vehicle *v;

   285

   286

	FOR_ALL_VEHICLES(v) {

   287

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

   288

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

   289

			return NULL;

   290

   291

		if (v->type == 0)

   292

			return InitializeVehicle(v);

   293

	}

   294

   295

	return NULL;

   296

}

   297

   298

/*

   299

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

   300

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

   301

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

   302

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

   303

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

   304

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

   305

 */

   306

static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)

   307

{

   308

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

   309

	 * first blocks */

   310

	Vehicle *v;

   311

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

   312

   313

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

   314

		FOR_ALL_VEHICLES_FROM(v, offset + *skip_vehicles) {

   315

			(*skip_vehicles)++;

   316

			if (v->type == 0)

   317

				return InitializeVehicle(v);

   318

		}

   319

	}

   320

   321

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

   322

	if (AddBlockToPool(&_vehicle_pool))

   323

		return AllocateSingleVehicle(skip_vehicles);

   324

   325

	return NULL;

   326

}

   327

   328

Vehicle *AllocateVehicle(void)

   329

{

   330

	VehicleID counter = 0;

   331

	return AllocateSingleVehicle(&counter);

   332

}

   333

   334

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

   335

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

   336

* @param num number of vehicles to allocate room for

   337

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

   338

*/

   339

bool AllocateVehicles(Vehicle **vl, int num)

   340

{

   341

	int i;

   342

	Vehicle *v;

   343

	VehicleID counter = 0;

   344

   345

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

   346

		v = AllocateSingleVehicle(&counter);

   347

		if (v == NULL) {

   348

			return false;

   349

		}

   350

		if (vl != NULL) {

   351

			vl[i] = v;

   352

		}

   353

	}

   354

   355

	return true;

   356

}

   357

   358

   359

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

   360

{

   361

	int x,y,x2,y2;

   362

	VehicleID veh;

   363

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

   364

   365

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

   366

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

   367

   368

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

   369

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

   370

   371

	for(;;) {

   372

		int xb = x;

   373

		for(;;) {

   374

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

   375

			while (veh != INVALID_VEHICLE) {

   376

				Vehicle *v = GetVehicle(veh);

   377

				void *a;

   378

   379

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

   380

					return a;

   381

				veh = v->next_hash;

   382

			}

   383

   384

			if (x == x2)

   385

				break;

   386

   387

			x = (x + 1) & 0x3F;

   388

		}

   389

		x = xb;

   390

   391

		if (y == y2)

   392

			break;

   393

   394

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

   395

	}

   396

	return NULL;

   397

}

   398

   399

   400

   401

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

   402

{

   403

	VehicleID *old_hash, *new_hash;

   404

	int old_x = v->left_coord;

   405

	int old_y = v->top_coord;

   406

	Vehicle *u;

   407

   408

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

   409

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

   410

   411

	if (old_hash == new_hash)

   412

		return;

   413

   414

	/* remove from hash table? */

   415

	if (old_hash != NULL) {

   416

		Vehicle *last = NULL;

   417

		VehicleID idx = *old_hash;

   418

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

   419

			idx = u->next_hash;

   420

			assert(idx != INVALID_VEHICLE);

   421

			last = u;

   422

		}

   423

   424

		if (last == NULL)

   425

			*old_hash = v->next_hash;

   426

		else

   427

			last->next_hash = v->next_hash;

   428

	}

   429

   430

	/* insert into hash table? */

   431

	if (new_hash != NULL) {

   432

		v->next_hash = *new_hash;

   433

		*new_hash = v->index;

   434

	}

   435

}

   436

   437

void InitializeVehicles(void)

   438

{

   439

	int i;

   440

   441

	/* Clean the vehicle pool, and reserve enough blocks

   442

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

   443

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

   444

	CleanPool(&_vehicle_pool);

   445

	AddBlockToPool(&_vehicle_pool);

   446

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

   447

		AddBlockToPool(&_vehicle_pool);

   448

   449

	// clear it...

   450

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

   451

}

   452

   453

Vehicle *GetLastVehicleInChain(Vehicle *v)

   454

{

   455

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

   456

	return v;

   457

}

   458

   459

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

   460

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

   461

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

   462

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

   463

 * called by anything but GetFirstVehicleInChain

   464

 */

   465

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   466

{

   467

	Vehicle *u;

   468

   469

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

   470

   471

	return NULL;

   472

}

   473

   474

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

   475

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

   476

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

   477

 */

   478

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   479

{

   480

	Vehicle *u;

   481

	assert(v != NULL);

   482

   483

	u = GetFirstVehicleInChain(v);

   484

   485

 	// Check to see if this is the first

   486

	if (v == u) return NULL;

   487

   488

	do {

   489

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

   490

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

   491

   492

	return NULL;

   493

}

   494

   495

/** Finds the first vehicle in a chain.

   496

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

   497

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

   498

 */