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

#include "train.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_REFIT_VEH(x)		   _veh_refit_proc_table[ x - VEH_Train]

    40

    41

static const uint32 _veh_build_proc_table[] = {

    42

	CMD_BUILD_RAIL_VEHICLE,

    43

	CMD_BUILD_ROAD_VEH,

    44

	CMD_BUILD_SHIP,

    45

	CMD_BUILD_AIRCRAFT,

    46

};

    47

static const uint32 _veh_sell_proc_table[] = {

    48

	CMD_SELL_RAIL_WAGON,

    49

	CMD_SELL_ROAD_VEH,

    50

	CMD_SELL_SHIP,

    51

	CMD_SELL_AIRCRAFT,

    52

};

    53

    54

static const uint32 _veh_refit_proc_table[] = {

    55

	CMD_REFIT_RAIL_VEHICLE,

    56

	0,	// road vehicles can't be refitted

    57

	CMD_REFIT_SHIP,

    58

	CMD_REFIT_AIRCRAFT,

    59

};

    60

    61

    62

enum {

    63

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

    64

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

    65

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    66

    67

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

    68

};

    69

    70

/**

    71

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

    72

 */

    73

static void VehiclePoolNewBlock(uint start_item)

    74

{

    75

	Vehicle *v;

    76

    77

	FOR_ALL_VEHICLES_FROM(v, start_item) v->index = start_item++;

    78

}

    79

    80

/* Initialize the vehicle-pool */

    81

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

    82

    83

void VehicleServiceInDepot(Vehicle *v)

    84

{

    85

	v->date_of_last_service = _date;

    86

	v->breakdowns_since_last_service = 0;

    87

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

    88

}

    89

    90

bool VehicleNeedsService(const Vehicle *v)

    91

{

    92

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

    93

		return false;

    94

    95

	if (v->vehstatus & VS_CRASHED)

    96

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

    97

    98

	return _patches.servint_ispercent ?

    99

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

   100

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

   101

}

   102

   103

void VehicleInTheWayErrMsg(const Vehicle* v)

   104

{

   105

	switch (v->type) {

   106

		case VEH_Train:    _error_message = STR_8803_TRAIN_IN_THE_WAY;        break;

   107

		case VEH_Road:     _error_message = STR_9000_ROAD_VEHICLE_IN_THE_WAY; break;

   108

		case VEH_Aircraft: _error_message = STR_A015_AIRCRAFT_IN_THE_WAY;     break;

   109

		default:           _error_message = STR_980E_SHIP_IN_THE_WAY;         break;

   110

	}

   111

}

   112

   113

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

   114

{

   115

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

   116

		return NULL;

   117

   118

	VehicleInTheWayErrMsg(v);

   119

	return v;

   120

}

   121

   122

bool EnsureNoVehicle(TileIndex tile)

   123

{

   124

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

   125

}

   126

   127

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

   128

{

   129

	const TileInfo *ti = data;

   130

   131

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

   132

		return NULL;

   133

   134

	VehicleInTheWayErrMsg(v);

   135

	return v;

   136

}

   137

   138

static inline uint Correct_Z(uint tileh)

   139

{

   140

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

   141

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

   142

	return CorrectZ(tileh) ? 8 : 0;

   143

}

   144

   145

uint GetCorrectTileHeight(TileIndex tile)

   146

{

   147

	return Correct_Z(GetTileSlope(tile, NULL));

   148

}

   149

   150

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   151

{

   152

	TileInfo ti;

   153

   154

	FindLandscapeHeightByTile(&ti, tile);

   155

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

   156

   157

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

   158

}

   159

   160

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   161

{

   162

	TileInfo ti;

   163

   164

	ti.tile = tile;

   165

	ti.z = z;

   166

   167

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   168

}

   169

   170

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

   171

{

   172

	int x1 = TileX(from);

   173

	int y1 = TileY(from);

   174

	int x2 = TileX(to);

   175

	int y2 = TileY(to);

   176

	Vehicle *veh;

   177

   178

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

   179

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

   180

		intswap(x1,x2);

   181

		intswap(y1,y2);

   182

	}

   183

	FOR_ALL_VEHICLES(veh) {

   184

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

   185

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

   186

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

   187

				return veh;

   188

			}

   189

		}

   190

	}

   191

	return NULL;

   192

}

   193

   194

void VehiclePositionChanged(Vehicle *v)

   195

{

   196

	int img = v->cur_image;

   197

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

   198

	const Sprite* spr = GetSprite(img);

   199

   200

	pt.x += spr->x_offs;

   201

	pt.y += spr->y_offs;

   202

   203

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

   204

   205

	v->left_coord = pt.x;

   206

	v->top_coord = pt.y;

   207

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

   208

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

   209

}

   210

   211

// Called after load to update coordinates

   212

void AfterLoadVehicles(void)

   213

{

   214

	Vehicle *v;

   215

   216

	FOR_ALL_VEHICLES(v) {

   217

		v->first = NULL;

   218

		if (v->type != 0) {

   219

			switch (v->type) {

   220

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

   221

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

   222

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

   223

				case VEH_Aircraft:

   224

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

   225

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

   226

						if (v->next != NULL) v->next->cur_image = v->cur_image;

   227

					}

   228

					break;

   229

				default: break;

   230

			}

   231

   232

			v->left_coord = INVALID_COORD;

   233

			VehiclePositionChanged(v);

   234

   235

			if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v)))

   236

				TrainConsistChanged(v);

   237

		}

   238

	}

   239

}

   240

   241

static Vehicle *InitializeVehicle(Vehicle *v)

   242

{

   243

	VehicleID index = v->index;

   244

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

   245

	v->index = index;

   246

   247

	assert(v->orders == NULL);

   248

   249

	v->left_coord = INVALID_COORD;

   250

	v->first = NULL;

   251

	v->next = NULL;

   252

	v->next_hash = INVALID_VEHICLE;

   253

	v->string_id = 0;

   254

	v->next_shared = NULL;

   255

	v->prev_shared = NULL;

   256

	v->depot_list  = NULL;

   257

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

   258

	    which are technical the same (newgrf stuff).

   259

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

   260

	    not really matter that one client has other visual vehicles than

   261

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

   262

	*/

   263

	v->random_bits = InteractiveRandomRange(256);

   264

	return v;

   265

}

   266

   267

Vehicle *ForceAllocateSpecialVehicle(void)

   268

{

   269

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

   270

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

   271

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

   272

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   273

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

   274

   275

	Vehicle *v;

   276

   277

	FOR_ALL_VEHICLES(v) {

   278

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

   279

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

   280

			return NULL;

   281

   282

		if (v->type == 0)

   283

			return InitializeVehicle(v);

   284

	}

   285

   286

	return NULL;

   287

}

   288

   289

/*

   290

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

   291

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

   292

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

   293

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

   294

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

   295

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

   296

 */

   297

static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)

   298

{

   299

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

   300

	 * first blocks */

   301

	Vehicle *v;

   302

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

   303

   304

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

   305

		FOR_ALL_VEHICLES_FROM(v, offset + *skip_vehicles) {

   306

			(*skip_vehicles)++;

   307

			if (v->type == 0)

   308

				return InitializeVehicle(v);

   309

		}

   310

	}

   311

   312

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

   313

	if (AddBlockToPool(&_vehicle_pool))

   314

		return AllocateSingleVehicle(skip_vehicles);

   315

   316

	return NULL;

   317

}

   318

   319

   320

Vehicle *AllocateVehicle(void)

   321

{

   322

	VehicleID counter = 0;

   323

	return AllocateSingleVehicle(&counter);

   324

}

   325

   326

   327

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

   328

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

   329

* @param num number of vehicles to allocate room for

   330

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

   331

*/

   332

bool AllocateVehicles(Vehicle **vl, int num)

   333

{

   334

	int i;

   335

	Vehicle *v;

   336

	VehicleID counter = 0;

   337

   338

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

   339

		v = AllocateSingleVehicle(&counter);

   340

		if (v == NULL) {

   341

			return false;

   342

		}

   343

		if (vl != NULL) {

   344

			vl[i] = v;

   345

		}

   346

	}

   347

   348

	return true;

   349

}

   350

   351

   352

static VehicleID _vehicle_position_hash[0x1000];

   353

   354

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

   355

{

   356

	int x,y,x2,y2;

   357

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

   358

   359

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

   360

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

   361

   362

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

   363

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

   364

   365

	for (;;) {

   366

		int xb = x;

   367

		for (;;) {

   368

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

   369

			while (veh != INVALID_VEHICLE) {

   370

				Vehicle *v = GetVehicle(veh);

   371

				void *a;

   372

   373

				a = proc(v, data);

   374

				if (a != NULL) return a;

   375

				veh = v->next_hash;

   376

			}

   377

   378

			if (x == x2)

   379

				break;

   380

   381

			x = (x + 1) & 0x3F;

   382

		}

   383

		x = xb;

   384

   385

		if (y == y2)

   386

			break;

   387

   388

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

   389

	}

   390

	return NULL;

   391

}

   392

   393

   394

   395

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

   396

{

   397

	VehicleID *old_hash, *new_hash;

   398

	int old_x = v->left_coord;

   399

	int old_y = v->top_coord;

   400

	Vehicle *u;

   401

   402

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

   403

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

   404

   405

	if (old_hash == new_hash) return;

   406

   407

	/* remove from hash table? */

   408

	if (old_hash != NULL) {

   409

		Vehicle *last = NULL;

   410

		VehicleID idx = *old_hash;

   411

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

   412

			idx = u->next_hash;

   413

			assert(idx != INVALID_VEHICLE);

   414

			last = u;

   415

		}

   416

   417

		if (last == NULL) {

   418

			*old_hash = v->next_hash;

   419

		} else {

   420

			last->next_hash = v->next_hash;

   421

		}

   422

	}

   423

   424

	/* insert into hash table? */

   425

	if (new_hash != NULL) {

   426

		v->next_hash = *new_hash;

   427

		*new_hash = v->index;

   428

	}

   429

}

   430

   431

void InitializeVehicles(void)

   432

{

   433

	int i;

   434

   435

	/* Clean the vehicle pool, and reserve enough blocks

   436

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

   437

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

   438

	CleanPool(&_vehicle_pool);

   439

	AddBlockToPool(&_vehicle_pool);

   440

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

   441

		AddBlockToPool(&_vehicle_pool);

   442

   443

	// clear it...

   444

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

   445

}

   446

   447

Vehicle *GetLastVehicleInChain(Vehicle *v)

   448

{

   449

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

   450

	return v;

   451

}

   452

   453

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

   454

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

   455

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

   456

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

   457

 * called by anything but GetFirstVehicleInChain

   458

 */

   459

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   460

{

   461

	Vehicle *u;

   462

   463

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

   464

   465

	return NULL;

   466

}

   467

   468

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

   469

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

   470

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

   471

 */

   472

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   473

{

   474

	Vehicle *u;

   475

	assert(v != NULL);

   476

   477

	u = GetFirstVehicleInChain(v);

   478

   479

 	// Check to see if this is the first

   480

	if (v == u) return NULL;

   481

   482

	do {

   483

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

   484

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

   485

   486

	return NULL;

   487

}

   488

   489

/** Finds the first vehicle in a chain.

   490

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

   491

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

   492

 */

   493

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   494

{

   495

	Vehicle* u;

   496