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 uint32 const _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 uint32 const _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 uint32 const _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 uint32 const _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(Vehicle *v)

   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;

   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

Vehicle *AllocateVehicle(void)

   301

{

   302

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

   303

	 * first blocks */

   304

	Vehicle *v;

   305

   306

	FOR_ALL_VEHICLES_FROM(v, (1 << _vehicle_pool.block_size_bits) * BLOCKS_FOR_SPECIAL_VEHICLES) {

   307

		if (v->type == 0)

   308

			return InitializeVehicle(v);

   309

	}

   310

   311

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

   312

	if (AddBlockToPool(&_vehicle_pool))

   313

		return AllocateVehicle();

   314

   315

	return NULL;

   316

}

   317

   318

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

   319

{

   320

	int x,y,x2,y2;

   321

	VehicleID veh;

   322

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

   323

   324

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

   325

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

   326

   327

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

   328

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

   329

   330

	for(;;) {

   331

		int xb = x;

   332

		for(;;) {

   333

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

   334

			while (veh != INVALID_VEHICLE) {

   335

				Vehicle *v = GetVehicle(veh);

   336

				void *a;

   337

   338

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

   339

					return a;

   340

				veh = v->next_hash;

   341

			}

   342

   343

			if (x == x2)

   344

				break;

   345

   346

			x = (x + 1) & 0x3F;

   347

		}

   348

		x = xb;

   349

   350

		if (y == y2)

   351

			break;

   352

   353

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

   354

	}

   355

	return NULL;

   356

}

   357

   358

   359

   360

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

   361

{

   362

	VehicleID *old_hash, *new_hash;

   363

	int old_x = v->left_coord;

   364

	int old_y = v->top_coord;

   365

	Vehicle *u;

   366

   367

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

   368

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

   369

   370

	if (old_hash == new_hash)

   371

		return;

   372

   373

	/* remove from hash table? */

   374

	if (old_hash != NULL) {

   375

		Vehicle *last = NULL;

   376

		VehicleID idx = *old_hash;

   377

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

   378

			idx = u->next_hash;

   379

			assert(idx != INVALID_VEHICLE);

   380

			last = u;

   381

		}

   382

   383

		if (last == NULL)

   384

			*old_hash = v->next_hash;

   385

		else

   386

			last->next_hash = v->next_hash;

   387

	}

   388

   389

	/* insert into hash table? */

   390

	if (new_hash != NULL) {

   391

		v->next_hash = *new_hash;

   392

		*new_hash = v->index;

   393

	}

   394

}

   395

   396

void InitializeVehicles(void)

   397

{

   398

	int i;

   399

   400

	/* Clean the vehicle pool, and reserve enough blocks

   401

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

   402

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

   403

	CleanPool(&_vehicle_pool);

   404

	AddBlockToPool(&_vehicle_pool);

   405

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

   406

		AddBlockToPool(&_vehicle_pool);

   407

   408

	// clear it...

   409

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

   410

}

   411

   412

Vehicle *GetLastVehicleInChain(Vehicle *v)

   413

{

   414

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

   415

	return v;

   416

}

   417

   418

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

   419

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

   420

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

   421

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

   422

 * called by anything but GetFirstVehicleInChain

   423

 */

   424

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   425

{

   426

	Vehicle *u;

   427

   428

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

   429

   430

	return NULL;

   431

}

   432

   433

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

   434

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

   435

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

   436

 */

   437

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   438

{

   439

	Vehicle *u;

   440

	assert(v != NULL);

   441

   442

	u = GetFirstVehicleInChain(v);

   443

   444

 	// Check to see if this is the first

   445

	if (v == u) return NULL;

   446

   447

	do {

   448

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

   449

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

   450

   451

	return NULL;

   452

}

   453

   454

/** Finds the first vehicle in a chain.

   455

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

   456

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

   457

 */

   458

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   459

{

   460

	Vehicle* u;

   461

   462

	assert(v != NULL);

   463

   464

	if (v->first != NULL) {

   465

		if (v->first->subtype == TS_Front_Engine) return v->first;

   466

   467

		DEBUG(misc, 0) ("v->first cache faulty. We shouldn't be here, rebuilding cache!");

   468

	}

   469

   470

	/* It is the fact (currently) that newly built vehicles do not have

   471

	* their ->first pointer set. When this is the case, go up to the

   472

	* first engine and set the pointers correctly. Also the first pointer

   473

	* is not saved in a savegame, so this has to be fixed up after loading */

   474

   475

	/* Find the 'locomotive' or the first wagon in a chain */

   476

	while ((u = GetPrevVehicleInChain_bruteforce(v)) != NULL) v = u;

   477

   478

	/* Set the first pointer of all vehicles in that chain to the first wagon */

   479

	if (v->subtype == TS_Front_Engine)

   480

		for (u = (Vehicle *)v; u != NULL; u = u->next) u->first = (Vehicle *)v;

   481

   482

	return (Vehicle*)v;

   483

}

   484

   485

int CountVehiclesInChain(Vehicle *v)

   486

{

   487

	int count = 0;

   488

	do count++; while ( (v=v->next) != NULL);

   489

	return count;

   490

}

   491

   492

void DeleteVehicle(Vehicle *v)

   493

{

   494

	DeleteName(v->string_id);

   495

	v->type = 0;

   496

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   497

	v->next_hash = INVALID_VEHICLE;

   498

   499

	if (v->orders != NULL)

   500

		DeleteVehicleOrders(v);