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

    84

}

    85

    86

/* Initialize the vehicle-pool */

    87

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

    88

    89

void VehicleServiceInDepot(Vehicle *v)

    90

{

    91

	v->date_of_last_service = _date;

    92

	v->breakdowns_since_last_service = 0;

    93

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

    94

}

    95

    96

bool VehicleNeedsService(const Vehicle *v)

    97

{

    98

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

    99

		return false;

   100

   101

	if (v->vehstatus & VS_CRASHED)

   102

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

   103

   104

	return _patches.servint_ispercent ?

   105

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

   106

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

   107

}

   108

   109

void VehicleInTheWayErrMsg(const Vehicle* v)

   110

{

   111

	switch (v->type) {

   112

		case VEH_Train:    _error_message = STR_8803_TRAIN_IN_THE_WAY;        break;

   113

		case VEH_Road:     _error_message = STR_9000_ROAD_VEHICLE_IN_THE_WAY; break;

   114

		case VEH_Aircraft: _error_message = STR_A015_AIRCRAFT_IN_THE_WAY;     break;

   115

		default:           _error_message = STR_980E_SHIP_IN_THE_WAY;         break;

   116

	}

   117

}

   118

   119

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

   120

{

   121

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

   122

		return NULL;

   123

   124

	VehicleInTheWayErrMsg(v);

   125

	return v;

   126

}

   127

   128

bool EnsureNoVehicle(TileIndex tile)

   129

{

   130

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

   131

}

   132

   133

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

   134

{

   135

	const TileInfo *ti = data;

   136

   137

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

   138

		return NULL;

   139

   140

	VehicleInTheWayErrMsg(v);

   141

	return v;

   142

}

   143

   144

static inline uint Correct_Z(uint tileh)

   145

{

   146

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

   147

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

   148

	return CorrectZ(tileh) ? 8 : 0;

   149

}

   150

   151

uint GetCorrectTileHeight(TileIndex tile)

   152

{

   153

	return Correct_Z(GetTileSlope(tile, NULL));

   154

}

   155

   156

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   157

{

   158

	TileInfo ti;

   159

   160

	FindLandscapeHeightByTile(&ti, tile);

   161

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

   162

   163

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

   164

}

   165

   166

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   167

{

   168

	TileInfo ti;

   169

   170

	ti.tile = tile;

   171

	ti.z = z;

   172

   173

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   174

}

   175

   176

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

   177

{

   178

	int x1 = TileX(from);

   179

	int y1 = TileY(from);

   180

	int x2 = TileX(to);

   181

	int y2 = TileY(to);

   182

	Vehicle *veh;

   183

   184

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

   185

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

   186

		intswap(x1,x2);

   187

		intswap(y1,y2);

   188

	}

   189

	FOR_ALL_VEHICLES(veh) {

   190

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

   191

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

   192

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

   193

				return veh;

   194

			}

   195

		}

   196

	}

   197

	return NULL;

   198

}

   199

   200

void VehiclePositionChanged(Vehicle *v)

   201

{

   202

	int img = v->cur_image;

   203

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

   204

	const Sprite* spr = GetSprite(img);

   205

   206

	pt.x += spr->x_offs;

   207

	pt.y += spr->y_offs;

   208

   209

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

   210

   211

	v->left_coord = pt.x;

   212

	v->top_coord = pt.y;

   213

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

   214

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

   215

}

   216

   217

// Called after load to update coordinates

   218

void AfterLoadVehicles(void)

   219

{

   220

	Vehicle *v;

   221

   222

	FOR_ALL_VEHICLES(v) {

   223

		v->first = NULL;

   224

		if (v->type != 0) {

   225

			switch (v->type) {

   226

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

   227

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

   228

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

   229

				case VEH_Aircraft:

   230

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

   231

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

   233

					}

   234

					break;

   235

				default: break;

   236

			}

   237

   238

			v->left_coord = INVALID_COORD;

   239

			VehiclePositionChanged(v);

   240

   241

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

   242

				TrainConsistChanged(v);

   243

		}

   244

	}

   245

}

   246

   247

static Vehicle *InitializeVehicle(Vehicle *v)

   248

{

   249

	VehicleID index = v->index;

   250

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

   251

	v->index = index;

   252

   253

	assert(v->orders == NULL);

   254

   255

	v->left_coord = INVALID_COORD;

   256

	v->first = NULL;

   257

	v->next = NULL;

   258

	v->next_hash = INVALID_VEHICLE;

   259

	v->string_id = 0;

   260

	v->next_shared = NULL;

   261

	v->prev_shared = NULL;

   262

	v->depot_list  = NULL;

   263

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

   264

	    which are technical the same (newgrf stuff).

   265

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

   266

	    not really matter that one client has other visual vehicles than

   267

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

   268

	*/

   269

	v->random_bits = InteractiveRandomRange(256);

   270

	return v;

   271

}

   272

   273

Vehicle *ForceAllocateSpecialVehicle(void)

   274

{

   275

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

   276

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

   277

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

   278

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   279

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

   280

   281

	Vehicle *v;

   282

   283

	FOR_ALL_VEHICLES(v) {

   284

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

   285

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

   286

			return NULL;

   287

   288

		if (v->type == 0)

   289

			return InitializeVehicle(v);

   290

	}

   291

   292

	return NULL;

   293

}

   294

   295

/*

   296

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

   297

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

   298

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

   299

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

   300

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

   301

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

   302

 */

   303

static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)

   304

{

   305

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

   306

	 * first blocks */

   307

	Vehicle *v;

   308

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

   309

   310

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

   311

		FOR_ALL_VEHICLES_FROM(v, offset + *skip_vehicles) {

   312

			(*skip_vehicles)++;

   313

			if (v->type == 0)

   314

				return InitializeVehicle(v);

   315

		}

   316

	}

   317

   318

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

   319

	if (AddBlockToPool(&_vehicle_pool))

   320

		return AllocateSingleVehicle(skip_vehicles);

   321

   322

	return NULL;

   323

}

   324

   326

Vehicle *AllocateVehicle(void)

   327

{

   328

	VehicleID counter = 0;

   329

	return AllocateSingleVehicle(&counter);

   330

}

   331

   333

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

   334

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

   335

* @param num number of vehicles to allocate room for

   336

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

   337

*/

   338

bool AllocateVehicles(Vehicle **vl, int num)

   339

{

   340

	int i;

   341

	Vehicle *v;

   342

	VehicleID counter = 0;

   343

   344

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

   345

		v = AllocateSingleVehicle(&counter);

   346

		if (v == NULL) {

   347

			return false;

   348

		}

   349

		if (vl != NULL) {

   350

			vl[i] = v;

   351

		}

   352

	}

   353

   354

	return true;

   355

}

   356

   357

   358

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

   359

{

   360

	int x,y,x2,y2;

   361

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

   362

   363

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

   364

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

   365

   366

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

   367

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

   368

   370

		int xb = x;

   373

			while (veh != INVALID_VEHICLE) {

   374

				Vehicle *v = GetVehicle(veh);

   375

				void *a;

   376

   379

				veh = v->next_hash;

   380

			}

   381

   382

			if (x == x2)

   383

				break;

   384

   385

			x = (x + 1) & 0x3F;

   386

		}

   387

		x = xb;

   388

   389

		if (y == y2)

   390

			break;

   391

   392

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

   393

	}

   394

	return NULL;

   395

}

   396

   397

   398

   399

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

   400

{

   401

	VehicleID *old_hash, *new_hash;

   402

	int old_x = v->left_coord;

   403

	int old_y = v->top_coord;

   404

	Vehicle *u;

   405

   406

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

   407

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

   408

   410

   411

	/* remove from hash table? */

   412

	if (old_hash != NULL) {

   413

		Vehicle *last = NULL;

   414

		VehicleID idx = *old_hash;

   415

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

   416

			idx = u->next_hash;

   417

			assert(idx != INVALID_VEHICLE);

   418

			last = u;

   419

		}

   420

   422

			*old_hash = v->next_hash;

   424

			last->next_hash = v->next_hash;

   426

	}

   427

   428

	/* insert into hash table? */

   429

	if (new_hash != NULL) {

   430

		v->next_hash = *new_hash;

   431

		*new_hash = v->index;

   432

	}

   433

}

   434

   435

void InitializeVehicles(void)

   436

{

   437

	int i;

   438

   439

	/* Clean the vehicle pool, and reserve enough blocks

   440

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

   441

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

   442

	CleanPool(&_vehicle_pool);

   443

	AddBlockToPool(&_vehicle_pool);

   444

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

   445

		AddBlockToPool(&_vehicle_pool);

   446

   447

	// clear it...

   448

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

   449

}

   450

   451

Vehicle *GetLastVehicleInChain(Vehicle *v)

   452

{

   453

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

   454

	return v;

   455

}

   456

   457

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

   458

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

   459

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

   460

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

   461

 * called by anything but GetFirstVehicleInChain

   462

 */

   463

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   464

{

   465

	Vehicle *u;

   466

   467

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

   468

   469

	return NULL;

   470

}

   471

   472

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

   473

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

   474

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

   475

 */

   476

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   477

{

   478

	Vehicle *u;

   479

	assert(v != NULL);

   480

   481

	u = GetFirstVehicleInChain(v);

   482

   483

 	// Check to see if this is the first

   484

	if (v == u) return NULL;

   485

   486

	do {

   487

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

   488

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

   489

   490

	return NULL;

   491

}

   492

   493

/** Finds the first vehicle in a chain.

   494

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

   495

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

   496

 */