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

#include "train.h"

    27

    28

#define INVALID_COORD (-0x8000)

    29

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

    30

    31

/*

    32

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

    33

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

    34

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

    35

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

    36

 */

    37

    38

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

    39

#define CMD_SELL_VEH(x)				_veh_sell_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

};

    55

static const uint32 _veh_refit_proc_table[] = {

    56

	CMD_REFIT_RAIL_VEHICLE,

    57

	0,	// road vehicles can't be refitted

    58

	CMD_REFIT_SHIP,

    59

	CMD_REFIT_AIRCRAFT,

    60

};

    61

    62

    63

enum {

    64

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

    65

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

    66

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    67

    68

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

    69

};

    70

    71

/**

    72

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

    73

 */

    74

static void VehiclePoolNewBlock(uint start_item)

    75

{

    76

	Vehicle *v;

    77

    78

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

    79

}

    80

    81

/* Initialize the vehicle-pool */

    82

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

    83

    84

void VehicleServiceInDepot(Vehicle *v)

    85

{

    86

	v->date_of_last_service = _date;

    87

	v->breakdowns_since_last_service = 0;

    88

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

    89

}

    90

    91

bool VehicleNeedsService(const Vehicle *v)

    92

{

    93

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

    94

		return false;

    95

    96

	if (v->vehstatus & VS_CRASHED)

    97

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

    98

    99

	return _patches.servint_ispercent ?

   100

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

   101

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

   102

}

   103

   104

void VehicleInTheWayErrMsg(const Vehicle* v)

   105

{

   106

	switch (v->type) {

   107

		case VEH_Train:    _error_message = STR_8803_TRAIN_IN_THE_WAY;        break;

   108

		case VEH_Road:     _error_message = STR_9000_ROAD_VEHICLE_IN_THE_WAY; break;

   109

		case VEH_Aircraft: _error_message = STR_A015_AIRCRAFT_IN_THE_WAY;     break;

   110

		default:           _error_message = STR_980E_SHIP_IN_THE_WAY;         break;

   111

	}

   112

}

   113

   114

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

   115

{

   116

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

   117

		return NULL;

   118

   119

	VehicleInTheWayErrMsg(v);

   120

	return v;

   121

}

   122

   123

bool EnsureNoVehicle(TileIndex tile)

   124

{

   125

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

   126

}

   127

   128

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

   129

{

   130

	const TileInfo *ti = data;

   131

   132

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

   133

		return NULL;

   134

   135

	VehicleInTheWayErrMsg(v);

   136

	return v;

   137

}

   138

   139

static inline uint Correct_Z(uint tileh)

   140

{

   141

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

   142

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

   143

	return CorrectZ(tileh) ? 8 : 0;

   144

}

   145

   146

uint GetCorrectTileHeight(TileIndex tile)

   147

{

   148

	return Correct_Z(GetTileSlope(tile, NULL));

   149

}

   150

   151

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   152

{

   153

	TileInfo ti;

   154

   155

	FindLandscapeHeightByTile(&ti, tile);

   156

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

   157

   158

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

   159

}

   160

   161

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   162

{

   163

	TileInfo ti;

   164

   165

	ti.tile = tile;

   166

	ti.z = z;

   167

   168

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   169

}

   170

   171

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

   172

{

   173

	int x1 = TileX(from);

   174

	int y1 = TileY(from);

   175

	int x2 = TileX(to);

   176

	int y2 = TileY(to);

   177

	Vehicle *veh;

   178

   179

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

   180

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

   181

		intswap(x1,x2);

   182

		intswap(y1,y2);

   183

	}

   184

	FOR_ALL_VEHICLES(veh) {

   185

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

   186

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

   187

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

   188

				return veh;

   189

			}

   190

		}

   191

	}

   192

	return NULL;

   193

}

   194

   195

void VehiclePositionChanged(Vehicle *v)

   196

{

   197

	int img = v->cur_image;

   198

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

   199

	const Sprite* spr = GetSprite(img);

   200

   201

	pt.x += spr->x_offs;

   202

	pt.y += spr->y_offs;

   203

   204

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

   205

   206

	v->left_coord = pt.x;

   207

	v->top_coord = pt.y;

   208

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

   209

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

   210

}

   211

   212

// Called after load to update coordinates

   213

void AfterLoadVehicles(void)

   214

{

   215

	Vehicle *v;

   216

   217

	FOR_ALL_VEHICLES(v) {

   218

		v->first = NULL;

   219

		if (v->type != 0) {

   220

			switch (v->type) {

   221

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

   222

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

   223

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

   224

				case VEH_Aircraft:

   225

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

   226

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

   227

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

   228

					}

   229

					break;

   230

				default: break;

   231

			}

   232

   233

			v->left_coord = INVALID_COORD;

   234

			VehiclePositionChanged(v);

   235

   236

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

   237

				TrainConsistChanged(v);

   238

		}

   239

	}

   240

}

   241

   242

static Vehicle *InitializeVehicle(Vehicle *v)

   243

{

   244

	VehicleID index = v->index;

   245

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

   246

	v->index = index;

   247

   248

	assert(v->orders == NULL);

   249

   250

	v->left_coord = INVALID_COORD;

   251

	v->first = NULL;

   252

	v->next = NULL;

   253

	v->next_hash = INVALID_VEHICLE;

   254

	v->string_id = 0;

   255

	v->next_shared = NULL;

   256

	v->prev_shared = NULL;

   257

	v->depot_list  = NULL;

   258

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

   259

	    which are technical the same (newgrf stuff).

   260

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

   261

	    not really matter that one client has other visual vehicles than

   262

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

   263

	*/

   264

	v->random_bits = InteractiveRandomRange(256);

   265

	return v;

   266

}

   267

   268

Vehicle *ForceAllocateSpecialVehicle(void)

   269

{

   270

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

   271

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

   272

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

   273

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   274

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

   275

   276

	Vehicle *v;

   277

   278

	FOR_ALL_VEHICLES(v) {

   279

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

   280

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

   281

			return NULL;

   282

   283

		if (v->type == 0)

   284

			return InitializeVehicle(v);

   285

	}

   286

   287

	return NULL;

   288

}

   289

   290

/*

   291

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

   292

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

   293

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

   294

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

   295

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

   296

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

   297

 */

   298

static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)

   299

{

   300

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

   301

	 * first blocks */

   302

	Vehicle *v;

   303

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

   304

   305

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

   306

		FOR_ALL_VEHICLES_FROM(v, offset + *skip_vehicles) {

   307

			(*skip_vehicles)++;

   308

			if (v->type == 0)

   309

				return InitializeVehicle(v);

   310

		}

   311

	}

   312

   313

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

   314

	if (AddBlockToPool(&_vehicle_pool))

   315

		return AllocateSingleVehicle(skip_vehicles);

   316

   317

	return NULL;

   318

}

   319

   320

   321

Vehicle *AllocateVehicle(void)

   322

{

   323

	VehicleID counter = 0;

   324

	return AllocateSingleVehicle(&counter);

   325

}

   326

   327

   328

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

   329

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

   330

* @param num number of vehicles to allocate room for

   331

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

   332

*/

   333

bool AllocateVehicles(Vehicle **vl, int num)

   334

{

   335

	int i;

   336

	Vehicle *v;

   337

	VehicleID counter = 0;

   338

   339

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

   340

		v = AllocateSingleVehicle(&counter);

   341

		if (v == NULL) {

   342

			return false;

   343

		}

   344

		if (vl != NULL) {

   345

			vl[i] = v;

   346

		}

   347

	}

   348

   349

	return true;

   350

}

   351

   352

   353

static VehicleID _vehicle_position_hash[0x1000];

   354

   355

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

   356

{

   357

	int x,y,x2,y2;

   358

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

   359

   360

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

   361

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

   362

   363

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

   364

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

   365

   366

	for (;;) {

   367

		int xb = x;

   368

		for (;;) {

   369

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

   370

			while (veh != INVALID_VEHICLE) {

   371

				Vehicle *v = GetVehicle(veh);

   372

				void *a;

   373

   374

				a = proc(v, data);

   375

				if (a != NULL) return a;

   376

				veh = v->next_hash;

   377

			}

   378

   379

			if (x == x2)

   380

				break;

   381

   382

			x = (x + 1) & 0x3F;

   383

		}

   384

		x = xb;

   385

   386

		if (y == y2)

   387

			break;

   388

   389

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

   390

	}

   391

	return NULL;

   392

}

   393

   394

   395

   396

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

   397

{

   398

	VehicleID *old_hash, *new_hash;

   399

	int old_x = v->left_coord;

   400

	int old_y = v->top_coord;

   401

	Vehicle *u;

   402

   403

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

   404

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

   405

   406

	if (old_hash == new_hash) return;

   407

   408

	/* remove from hash table? */

   409

	if (old_hash != NULL) {

   410

		Vehicle *last = NULL;

   411

		VehicleID idx = *old_hash;

   412

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

   413

			idx = u->next_hash;

   414

			assert(idx != INVALID_VEHICLE);

   415

			last = u;

   416

		}

   417

   418

		if (last == NULL) {

   419

			*old_hash = v->next_hash;

   420

		} else {

   421

			last->next_hash = v->next_hash;

   422

		}

   423

	}

   424

   425

	/* insert into hash table? */

   426

	if (new_hash != NULL) {

   427

		v->next_hash = *new_hash;

   428

		*new_hash = v->index;

   429

	}

   430

}

   431

   432

void InitializeVehicles(void)

   433

{

   434

	int i;

   435

   436

	/* Clean the vehicle pool, and reserve enough blocks

   437

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

   438

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

   439

	CleanPool(&_vehicle_pool);

   440

	AddBlockToPool(&_vehicle_pool);

   441

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

   442

		AddBlockToPool(&_vehicle_pool);

   443

   444

	// clear it...

   445

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

   446

}

   447

   448

Vehicle *GetLastVehicleInChain(Vehicle *v)

   449

{

   450

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

   451

	return v;

   452

}

   453

   454

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

   455

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

   456

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

   457

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

   458

 * called by anything but GetFirstVehicleInChain

   459

 */

   460

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   461

{

   462

	Vehicle *u;

   463

   464

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

   465

   466

	return NULL;

   467

}

   468

   469

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

   470

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

   471

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

   472

 */

   473

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   474

{

   475

	Vehicle *u;

   476

	assert(v != NULL);

   477

   478

	u = GetFirstVehicleInChain(v);

   479

   480

 	// Check to see if this is the first

   481

	if (v == u) return NULL;

   482

   483

	do {

   484

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

   485

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

   486

   487

	return NULL;

   488

}

   489

   490

/** Finds the first vehicle in a chain.

   491

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

   492

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

   493

 */

   494

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   495

{

   496

	Vehicle* u;