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

enum {

    31

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

    32

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

    33

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    34

    35

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

    36

};

    37

    38

/**

    39

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

    40

 */

    41

static void VehiclePoolNewBlock(uint start_item)

    42

{

    43

	Vehicle *v;

    44

    45

	FOR_ALL_VEHICLES_FROM(v, start_item)

    46

		v->index = start_item++;

    47

}

    48

    49

/* Initialize the vehicle-pool */

    50

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

    51

    52

void VehicleServiceInDepot(Vehicle *v)

    53

{

    54

	v->date_of_last_service = _date;

    55

	v->breakdowns_since_last_service = 0;

    56

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

    57

}

    58

    59

bool VehicleNeedsService(const Vehicle *v)

    60

{

    61

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

    62

		return false;

    63

    64

	if (v->vehstatus & VS_CRASHED)

    65

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

    66

    67

	return _patches.servint_ispercent ?

    68

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

    69

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

    70

}

    71

    72

void VehicleInTheWayErrMsg(Vehicle *v)

    73

{

    74

	StringID id;

    75

    76

	(id = STR_8803_TRAIN_IN_THE_WAY,v->type == VEH_Train) ||

    77

	(id = STR_9000_ROAD_VEHICLE_IN_THE_WAY,v->type == VEH_Road) ||

    78

	(id = STR_A015_AIRCRAFT_IN_THE_WAY,v->type == VEH_Aircraft) ||

    79

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    80

    81

	_error_message = id;

    82

}

    83

    84

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

    85

{

    86

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

    87

		return NULL;

    88

    89

	VehicleInTheWayErrMsg(v);

    90

	return v;

    91

}

    92

    93

bool EnsureNoVehicle(TileIndex tile)

    94

{

    95

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

    96

}

    97

    98

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

    99

{

   100

	const TileInfo *ti = data;

   101

   102

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

   103

		return NULL;

   104

   105

	VehicleInTheWayErrMsg(v);

   106

	return v;

   107

}

   108

   109

static inline uint Correct_Z(uint tileh)

   110

{

   111

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

   112

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

   113

	return CorrectZ(tileh) ? 8 : 0;

   114

}

   115

   116

uint GetCorrectTileHeight(TileIndex tile)

   117

{

   118

	return Correct_Z(GetTileSlope(tile, NULL));

   119

}

   120

   121

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   122

{

   123

	TileInfo ti;

   124

   125

	FindLandscapeHeightByTile(&ti, tile);

   126

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

   127

   128

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

   129

}

   130

   131

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   132

{

   133

	TileInfo ti;

   134

   135

	ti.tile = tile;

   136

	ti.z = z;

   137

   138

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   139

}

   140

   141

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

   142

{

   143

	int x1 = TileX(from);

   144

	int y1 = TileY(from);

   145

	int x2 = TileX(to);

   146

	int y2 = TileY(to);

   147

	Vehicle *veh;

   148

   149

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

   150

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

   151

		intswap(x1,x2);

   152

		intswap(y1,y2);

   153

	}

   154

	FOR_ALL_VEHICLES(veh) {

   155

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

   156

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

   157

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

   158

				return veh;

   159

			}

   160

		}

   161

	}

   162

	return NULL;

   163

}

   164

   165

void VehiclePositionChanged(Vehicle *v)

   166

{

   167

	int img = v->cur_image;

   168

	const SpriteDimension *sd;

   169

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

   170

   171

	sd = GetSpriteDimension(img);

   172

   173

	pt.x += sd->xoffs;

   174

	pt.y += sd->yoffs;

   175

   176

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

   177

   178

	v->left_coord = pt.x;

   179

	v->top_coord = pt.y;

   180

	v->right_coord = pt.x + sd->xsize + 2;

   181

	v->bottom_coord = pt.y + sd->ysize + 2;

   182

}

   183

   184

// Called after load to update coordinates

   185

void AfterLoadVehicles(void)

   186

{

   187

	Vehicle *v;

   188

   189

	FOR_ALL_VEHICLES(v) {

   190

		v->first = NULL;

   191

		if (v->type != 0) {

   192

			v->left_coord = INVALID_COORD;

   193

			VehiclePositionChanged(v);

   194

   195

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

   196

				TrainConsistChanged(v);

   197

		}

   198

	}

   199

}

   200

   201

static Vehicle *InitializeVehicle(Vehicle *v)

   202

{

   203

	VehicleID index = v->index;

   204

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

   205

	v->index = index;

   206

   207

	assert(v->orders == NULL);

   208

   209

	v->left_coord = INVALID_COORD;

   210

	v->first = NULL;

   211

	v->next = NULL;

   212

	v->next_hash = INVALID_VEHICLE;

   213

	v->string_id = 0;

   214

	v->next_shared = NULL;

   215

	v->prev_shared = NULL;

   216

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

   217

	    which are technical the same (newgrf stuff).

   218

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

   219

	    not really matter that one client has other visual vehicles than

   220

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

   221

	*/

   222

	v->random_bits = InteractiveRandomRange(256);

   223

	return v;

   224

}

   225

   226

Vehicle *ForceAllocateSpecialVehicle(void)

   227

{

   228

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

   229

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

   230

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

   231

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   232

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

   233

   234

	Vehicle *v;

   235

   236

	FOR_ALL_VEHICLES(v) {

   237

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

   238

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

   239

			return NULL;

   240

   241

		if (v->type == 0)

   242

			return InitializeVehicle(v);

   243

	}

   244

   245

	return NULL;

   246

}

   247

   248

Vehicle *AllocateVehicle(void)

   249

{

   250

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

   251

	 * first blocks */

   252

	Vehicle *v;

   253

   254

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

   255

		if (v->type == 0)

   256

			return InitializeVehicle(v);

   257

	}

   258

   259

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

   260

	if (AddBlockToPool(&_vehicle_pool))

   261

		return AllocateVehicle();

   262

   263

	return NULL;

   264

}

   265

   266

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

   267

{

   268

	int x,y,x2,y2;

   269

	VehicleID veh;

   270

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

   271

   272

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

   273

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

   274

   275

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

   276

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

   277

   278

	for(;;) {

   279

		int xb = x;

   280

		for(;;) {

   281

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

   282

			while (veh != INVALID_VEHICLE) {

   283

				Vehicle *v = GetVehicle(veh);

   284

				void *a;

   285

   286

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

   287

					return a;

   288

				veh = v->next_hash;

   289

			}

   290

   291

			if (x == x2)

   292

				break;

   293

   294

			x = (x + 1) & 0x3F;

   295

		}

   296

		x = xb;

   297

   298

		if (y == y2)

   299

			break;

   300

   301

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

   302

	}

   303

	return NULL;

   304

}

   305

   306

   307

   308

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

   309

{

   310

	VehicleID *old_hash, *new_hash;

   311

	int old_x = v->left_coord;

   312

	int old_y = v->top_coord;

   313

	Vehicle *u;

   314

   315

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

   316

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

   317

   318

	if (old_hash == new_hash)

   319

		return;

   320

   321

	/* remove from hash table? */

   322

	if (old_hash != NULL) {

   323

		Vehicle *last = NULL;

   324

		int idx = *old_hash;

   325

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

   326

			idx = u->next_hash;

   327

			assert(idx != INVALID_VEHICLE);

   328

			last = u;

   329

		}

   330

   331

		if (last == NULL)

   332

			*old_hash = v->next_hash;

   333

		else

   334

			last->next_hash = v->next_hash;

   335

	}

   336

   337

	/* insert into hash table? */

   338

	if (new_hash != NULL) {

   339

		v->next_hash = *new_hash;

   340

		*new_hash = v->index;

   341

	}

   342

}

   343

   344

void InitializeVehicles(void)

   345

{

   346

	int i;

   347

   348

	/* Clean the vehicle pool, and reserve enough blocks

   349

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

   350

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

   351

	CleanPool(&_vehicle_pool);

   352

	AddBlockToPool(&_vehicle_pool);

   353

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

   354

		AddBlockToPool(&_vehicle_pool);

   355

   356

	// clear it...

   357

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

   358

}

   359

   360

Vehicle *GetLastVehicleInChain(Vehicle *v)

   361

{

   362

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

   363

	return v;

   364

}

   365

   366

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

   367

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

   368

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

   369

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

   370

 * called by anything but GetFirstVehicleInChain

   371

 */

   372

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   373

{

   374

	Vehicle *u;

   375

   376

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

   377

   378

	return NULL;

   379

}

   380

   381

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

   382

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

   383

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

   384

 */

   385

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   386

{

   387

	Vehicle *u;

   388

	assert(v != NULL);

   389

   390

	u = GetFirstVehicleInChain(v);

   391

   392

 	// Check to see if this is the first

   393

	if (v == u) return NULL;

   394

   395

	do {

   396

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

   397

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

   398

   399

	return NULL;

   400

}

   401

   402

/** Finds the first vehicle in a chain.

   403

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

   404

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

   405

 */

   406

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   407

{

   408

	Vehicle* u;

   409

   410

	assert(v != NULL);

   411

   412

	if (v->first != NULL) {

   413

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

   414

   415

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

   416

	}

   417

   418

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

   419

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

   420

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

   421

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

   422

   423

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

   424

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

   425

   426

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

   427

	if (v->subtype == TS_Front_Engine)

   428

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

   429

   430

	return (Vehicle*)v;

   431

}

   432

   433

int CountVehiclesInChain(Vehicle *v)

   434

{

   435

	int count = 0;

   436

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

   437

	return count;

   438

}

   439

   440

void DeleteVehicle(Vehicle *v)

   441

{

   442

	DeleteName(v->string_id);

   443

	v->type = 0;

   444

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   445

	v->next_hash = INVALID_VEHICLE;

   446

   447

	if (v->orders != NULL)

   448

		DeleteVehicleOrders(v);

   449

}

   450

   451

void DeleteVehicleChain(Vehicle *v)

   452

{

   453

	do {

   454

		Vehicle *u = v;

   455

		v = v->next;

   456

		DeleteVehicle(u);

   457

	} while (v != NULL);

   458

}

   459

   460

   461

void Aircraft_Tick(Vehicle *v);

   462

void RoadVeh_Tick(Vehicle *v);

   463

void Ship_Tick(Vehicle *v);

   464

void Train_Tick(Vehicle *v);

   465

static void EffectVehicle_Tick(Vehicle *v);

   466

void DisasterVehicle_Tick(Vehicle *v);

   467

   468

VehicleTickProc *_vehicle_tick_procs[] = {

   469

	Train_Tick,

   470

	RoadVeh_Tick,

   471

	Ship_Tick,

   472

	Aircraft_Tick,

   473

	EffectVehicle_Tick,

   474

	DisasterVehicle_Tick,

   475

};

   476

   477

void CallVehicleTicks(void)

   478

{

   479

	Vehicle *v;

   480

   481

	FOR_ALL_VEHICLES(v) {

   482

		if (v->type != 0)

   483

			_vehicle_tick_procs[v->type - 0x10](v);

   484

	}

   485

}

   486

   487

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   488

{

   489

	uint32 full = 0, not_full = 0;

   490

   491

	//special handling of aircraft

   492

   493

	//if the aircraft carries passengers and is NOT full, then

   494

	//continue loading, no matter how much mail is in

   495

	if ((v->type == VEH_Aircraft) && (v->cargo_type == CT_PASSENGERS) && (v->cargo_cap != v->cargo_count)) {

   496

		return true;

   497

	}

   498

   499

	// patch should return "true" to continue loading, i.e. when there is no cargo type that is fully loaded.

   500

	do {

   501

		//Should never happen, but just in case future additions change this

   502

		assert(v->cargo_type<32);

   503

   504

		if (v->cargo_cap != 0) {