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;

   267

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

   268

	    which are technical the same (newgrf stuff).

   269

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

   270

	    not really matter that one client has other visual vehicles than

   271

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

   272

	*/

   273

	v->random_bits = InteractiveRandomRange(256);

   274

	return v;

   275

}

   276

   277

Vehicle *ForceAllocateSpecialVehicle(void)

   278

{

   279

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

   280

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

   281

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

   282

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   283

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

   284

   285

	Vehicle *v;

   286

   287

	FOR_ALL_VEHICLES(v) {

   288

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

   289

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

   290

			return NULL;

   291

   292

		if (v->type == 0)

   293

			return InitializeVehicle(v);

   294

	}

   295

   296

	return NULL;

   297

}

   298

   299

Vehicle *AllocateVehicle(void)

   300

{

   301

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

   302

	 * first blocks */

   303

	Vehicle *v;

   304

   305

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

   306

		if (v->type == 0)

   307

			return InitializeVehicle(v);

   308

	}

   309

   310

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

   311

	if (AddBlockToPool(&_vehicle_pool))

   312

		return AllocateVehicle();

   313

   314

	return NULL;

   315

}

   316

   317

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

   318

{

   319

	int x,y,x2,y2;

   320

	VehicleID veh;

   321

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

   322

   323

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

   324

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

   325

   326

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

   327

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

   328

   329

	for(;;) {

   330

		int xb = x;

   331

		for(;;) {

   332

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

   333

			while (veh != INVALID_VEHICLE) {

   334

				Vehicle *v = GetVehicle(veh);

   335

				void *a;

   336

   337

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

   338

					return a;

   339

				veh = v->next_hash;

   340

			}

   341

   342

			if (x == x2)

   343

				break;

   344

   345

			x = (x + 1) & 0x3F;

   346

		}

   347

		x = xb;

   348

   349

		if (y == y2)

   350

			break;

   351

   352

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

   353

	}

   354

	return NULL;

   355

}

   356

   357

   358

   359

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

   360

{

   361

	VehicleID *old_hash, *new_hash;

   362

	int old_x = v->left_coord;

   363

	int old_y = v->top_coord;

   364

	Vehicle *u;

   365

   366

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

   367

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

   368

   369

	if (old_hash == new_hash)

   370

		return;

   371

   372

	/* remove from hash table? */

   373

	if (old_hash != NULL) {

   374

		Vehicle *last = NULL;

   375

		VehicleID idx = *old_hash;

   376

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

   377

			idx = u->next_hash;

   378

			assert(idx != INVALID_VEHICLE);

   379

			last = u;

   380

		}

   381

   382

		if (last == NULL)

   383

			*old_hash = v->next_hash;

   384

		else

   385

			last->next_hash = v->next_hash;

   386

	}

   387

   388

	/* insert into hash table? */

   389

	if (new_hash != NULL) {

   390

		v->next_hash = *new_hash;

   391

		*new_hash = v->index;

   392

	}

   393

}

   394

   395

void InitializeVehicles(void)

   396

{

   397

	int i;

   398

   399

	/* Clean the vehicle pool, and reserve enough blocks

   400

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

   401

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

   402

	CleanPool(&_vehicle_pool);

   403

	AddBlockToPool(&_vehicle_pool);

   404

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

   405

		AddBlockToPool(&_vehicle_pool);

   406

   407

	// clear it...

   408

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

   409

}

   410

   411

Vehicle *GetLastVehicleInChain(Vehicle *v)

   412

{

   413

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

   414

	return v;

   415

}

   416

   417

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

   418

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

   419

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

   420

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

   421

 * called by anything but GetFirstVehicleInChain

   422

 */

   423

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   424

{

   425

	Vehicle *u;

   426

   427

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

   428

   429

	return NULL;

   430

}

   431

   432

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

   433

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

   434

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

   435

 */

   436

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   437

{

   438

	Vehicle *u;

   439

	assert(v != NULL);

   440

   441

	u = GetFirstVehicleInChain(v);

   442

   443

 	// Check to see if this is the first

   444

	if (v == u) return NULL;

   445

   446

	do {

   447

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

   448

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

   449

   450

	return NULL;

   451

}

   452

   453

/** Finds the first vehicle in a chain.

   454

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

   455

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

   456

 */

   457

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   458

{

   459

	Vehicle* u;

   460

   461

	assert(v != NULL);

   462

   463

	if (v->first != NULL) {

   464

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

   465

   466

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

   467

	}

   468

   469

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

   470

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

   471

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

   472

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

   473

   474

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

   475

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

   476

   477

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

   478

	if (v->subtype == TS_Front_Engine)

   479

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

   480

   481

	return (Vehicle*)v;

   482

}

   483

   484

int CountVehiclesInChain(Vehicle *v)

   485

{

   486

	int count = 0;

   487

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

   488

	return count;

   489

}

   490

   491

void DeleteVehicle(Vehicle *v)

   492

{

   493

	DeleteName(v->string_id);

   494

	v->type = 0;

   495

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   496

	v->next_hash = INVALID_VEHICLE;

   497

   498

	if (v->orders != NULL)

   499

		DeleteVehicleOrders(v);

   500

}

   501