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

	v->depot_list  = 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

   346

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

   347

{

   348

	int x,y,x2,y2;

   349

	VehicleID veh;

   350

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

   351

   352

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

   353

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

   354

   355

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

   356

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

   357

   358

	for(;;) {

   359

		int xb = x;

   360

		for(;;) {

   361

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

   362

			while (veh != INVALID_VEHICLE) {

   363

				Vehicle *v = GetVehicle(veh);

   364

				void *a;

   365

   366

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

   367

					return a;

   368

				veh = v->next_hash;

   369

			}

   370

   371

			if (x == x2)

   372

				break;

   373

   374

			x = (x + 1) & 0x3F;

   375

		}

   376

		x = xb;

   377

   378

		if (y == y2)

   379

			break;

   380

   381

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

   382

	}

   383

	return NULL;

   384

}

   385

   386

   387

   388

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

   389

{

   390

	VehicleID *old_hash, *new_hash;

   391

	int old_x = v->left_coord;

   392

	int old_y = v->top_coord;

   393

	Vehicle *u;

   394

   395

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

   396

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

   397

   398

	if (old_hash == new_hash)

   399

		return;

   400

   401

	/* remove from hash table? */

   402

	if (old_hash != NULL) {

   403

		Vehicle *last = NULL;

   404

		VehicleID idx = *old_hash;

   405

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

   406

			idx = u->next_hash;

   407

			assert(idx != INVALID_VEHICLE);

   408

			last = u;

   409

		}

   410

   411

		if (last == NULL)

   412

			*old_hash = v->next_hash;

   413

		else

   414

			last->next_hash = v->next_hash;

   415

	}

   416

   417

	/* insert into hash table? */

   418

	if (new_hash != NULL) {

   419

		v->next_hash = *new_hash;

   420

		*new_hash = v->index;

   421

	}

   422

}

   423

   424

void InitializeVehicles(void)

   425

{

   426

	int i;

   427

   428

	/* Clean the vehicle pool, and reserve enough blocks

   429

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

   430

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

   431

	CleanPool(&_vehicle_pool);

   432

	AddBlockToPool(&_vehicle_pool);

   433

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

   434

		AddBlockToPool(&_vehicle_pool);

   435

   436

	// clear it...

   437

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

   438

}

   439

   440

Vehicle *GetLastVehicleInChain(Vehicle *v)

   441

{

   442

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

   443

	return v;

   444

}

   445

   446

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

   447

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

   448

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

   449

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

   450

 * called by anything but GetFirstVehicleInChain

   451

 */

   452

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   453

{

   454

	Vehicle *u;

   455

   456

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

   457

   458

	return NULL;

   459

}

   460

   461

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

   462

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

   463

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

   464

 */

   465

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   466

{

   467

	Vehicle *u;

   468

	assert(v != NULL);

   469

   470

	u = GetFirstVehicleInChain(v);

   471

   472

 	// Check to see if this is the first

   473

	if (v == u) return NULL;

   474

   475

	do {

   476

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

   477

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

   478

   479

	return NULL;

   480

}

   481

   482

/** Finds the first vehicle in a chain.

   483

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

   484

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

   485

 */

   486

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   487

{

   488

	Vehicle* u;

   489

   490

	assert(v != NULL);

   491

   492

	if (v->first != NULL) {

   493

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

   494

   495

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

   496

	}

   497

   498

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

   499

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

   500

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