1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "spritecache.h"

     4

#include "table/sprites.h"

     5

#include "table/strings.h"

     7

#include "map.h"

     8

#include "tile.h"

     9

#include "vehicle.h"

    10

#include "gfx.h"

    11

#include "viewport.h"

    12

#include "news.h"

    13

#include "command.h"

    14

#include "saveload.h"

    15

#include "player.h"

    16

#include "engine.h"

    17

#include "sound.h"

    18

#include "debug.h"

    19

#include "vehicle_gui.h"

    20

#include "depot.h"

    21

#include "station.h"

    22

#include "rail.h"

    23

    24

#define INVALID_COORD (-0x8000)

    25

#define GEN_HASH(x,y) (((x & 0x1F80)>>7) + ((y & 0xFC0)))

    26

    27

enum {

    28

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

    29

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

    30

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    31

    32

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

    33

};

    34

    35

/**

    36

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

    37

 */

    38

static void VehiclePoolNewBlock(uint start_item)

    39

{

    40

	Vehicle *v;

    41

    42

	FOR_ALL_VEHICLES_FROM(v, start_item)

    43

		v->index = start_item++;

    44

}

    45

    46

/* Initialize the vehicle-pool */

    47

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

    48

    49

void VehicleServiceInDepot(Vehicle *v)

    50

{

    51

	v->date_of_last_service = _date;

    52

	v->breakdowns_since_last_service = 0;

    53

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

    54

}

    55

    56

bool VehicleNeedsService(const Vehicle *v)

    57

{

    58

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

    59

		return false;

    60

    61

	if (v->vehstatus & VS_CRASHED)

    62

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

    63

    64

	return _patches.servint_ispercent ?

    65

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

    66

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

    67

}

    68

    69

void VehicleInTheWayErrMsg(Vehicle *v)

    70

{

    71

	StringID id;

    72

    73

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

    74

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

    75

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

    76

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    77

    78

	_error_message = id;

    79

}

    80

    81

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

    82

{

    83

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

    84

		return NULL;

    85

    86

	VehicleInTheWayErrMsg(v);

    87

	return v;

    88

}

    89

    90

bool EnsureNoVehicle(TileIndex tile)

    91

{

    92

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

    93

}

    94

    95

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

    96

{

    97

	const TileInfo *ti = data;

    98

    99

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

   100

		return NULL;

   101

   102

	VehicleInTheWayErrMsg(v);

   103

	return v;

   104

}

   105

   106

static inline uint Correct_Z(uint tileh)

   107

{

   108

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

   109

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

   110

	return CorrectZ(tileh) ? 8 : 0;

   111

}

   112

   113

uint GetCorrectTileHeight(TileIndex tile)

   114

{

   115

	return Correct_Z(GetTileSlope(tile, NULL));

   116

}

   117

   118

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   119

{

   120

	TileInfo ti;

   121

   122

	FindLandscapeHeightByTile(&ti, tile);

   123

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

   124

   125

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

   126

}

   127

   128

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   129

{

   130

	TileInfo ti;

   131

   132

	ti.tile = tile;

   133

	ti.z = z;

   134

   135

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   136

}

   137

   138

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

   139

{

   140

	int x1 = TileX(from);

   141

	int y1 = TileY(from);

   142

	int x2 = TileX(to);

   143

	int y2 = TileY(to);

   144

	Vehicle *veh;

   145

   146

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

   147

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

   148

		intswap(x1,x2);

   149

		intswap(y1,y2);

   150

	}

   151

	FOR_ALL_VEHICLES(veh) {

   152

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

   153

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

   154

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

   155

				return veh;

   156

			}

   157

		}

   158

	}

   159

	return NULL;

   160

}

   161

   162

void VehiclePositionChanged(Vehicle *v)

   163

{

   164

	int img = v->cur_image;

   165

	const SpriteDimension *sd;

   166

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

   167

   168

	sd = GetSpriteDimension(img);

   169

   170

	pt.x += sd->xoffs;

   171

	pt.y += sd->yoffs;

   172

   173

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

   174

   175

	v->left_coord = pt.x;

   176

	v->top_coord = pt.y;

   177

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

   178

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

   179

}

   180

   181

// Called after load to update coordinates

   182

void AfterLoadVehicles(void)

   183

{

   184

	Vehicle *v;

   185

   186

	FOR_ALL_VEHICLES(v) {

   187

		v->first = NULL;

   188

		if (v->type != 0) {

   189

			v->left_coord = INVALID_COORD;

   190

			VehiclePositionChanged(v);

   191

   192

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

   193

				TrainConsistChanged(v);

   194

		}

   195

	}

   196

}

   197

   198

static Vehicle *InitializeVehicle(Vehicle *v)

   199

{

   200

	VehicleID index = v->index;

   201

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

   202

	v->index = index;

   203

   204

	assert(v->orders == NULL);

   205

   206

	v->left_coord = INVALID_COORD;

   207

	v->first = NULL;

   208

	v->next = NULL;

   209

	v->next_hash = INVALID_VEHICLE;

   210

	v->string_id = 0;

   211

	v->next_shared = NULL;

   212

	v->prev_shared = NULL;

   213

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

   214

	    which are technical the same (newgrf stuff).

   215

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

   216

	    not really matter that one client has other visual vehicles than

   217

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

   218

	*/

   219

	v->random_bits = InteractiveRandomRange(256);

   220

	return v;

   221

}

   222

   223

Vehicle *ForceAllocateSpecialVehicle(void)

   224

{

   225

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

   226

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

   227

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

   228

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   229

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

   230

   231

	Vehicle *v;

   232

   233

	FOR_ALL_VEHICLES(v) {

   234

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

   235

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

   236

			return NULL;

   237

   238

		if (v->type == 0)

   239

			return InitializeVehicle(v);

   240

	}

   241

   242

	return NULL;

   243

}

   244

   245

Vehicle *AllocateVehicle(void)

   246

{

   247

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

   248

	 * first blocks */

   249

	Vehicle *v;

   250

   251

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

   252

		if (v->type == 0)

   253

			return InitializeVehicle(v);

   254

	}

   255

   256

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

   257

	if (AddBlockToPool(&_vehicle_pool))

   258

		return AllocateVehicle();

   259

   260

	return NULL;

   261

}

   262

   263

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

   264

{

   265

	int x,y,x2,y2;

   266

	VehicleID veh;

   267

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

   268

   269

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

   270

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

   271

   272

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

   273

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

   274

   275

	for(;;) {

   276

		int xb = x;

   277

		for(;;) {

   278

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

   279

			while (veh != INVALID_VEHICLE) {

   280

				Vehicle *v = GetVehicle(veh);

   281

				void *a;

   282

   283

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

   284

					return a;

   285

				veh = v->next_hash;

   286

			}

   287

   288

			if (x == x2)

   289

				break;

   290

   291

			x = (x + 1) & 0x3F;

   292

		}

   293

		x = xb;

   294

   295

		if (y == y2)

   296

			break;

   297

   298

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

   299

	}

   300

	return NULL;

   301

}

   302

   303

   304

   305

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

   306

{

   307

	VehicleID *old_hash, *new_hash;

   308

	int old_x = v->left_coord;

   309

	int old_y = v->top_coord;

   310

	Vehicle *u;

   311

   312

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

   313

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

   314

   315

	if (old_hash == new_hash)

   316

		return;

   317

   318

	/* remove from hash table? */

   319

	if (old_hash != NULL) {

   320

		Vehicle *last = NULL;

   321

		int idx = *old_hash;

   322

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

   323

			idx = u->next_hash;

   324

			assert(idx != INVALID_VEHICLE);

   325

			last = u;

   326

		}

   327

   328

		if (last == NULL)

   329

			*old_hash = v->next_hash;

   330

		else

   331

			last->next_hash = v->next_hash;

   332

	}

   333

   334

	/* insert into hash table? */

   335

	if (new_hash != NULL) {

   336

		v->next_hash = *new_hash;

   337

		*new_hash = v->index;

   338

	}

   339

}

   340

   341

void InitializeVehicles(void)

   342

{

   343

	int i;

   344

   345

	/* Clean the vehicle pool, and reserve enough blocks

   346

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

   347

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

   348

	CleanPool(&_vehicle_pool);

   349

	AddBlockToPool(&_vehicle_pool);

   350

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

   351

		AddBlockToPool(&_vehicle_pool);

   352

   353

	// clear it...

   354

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

   355

}

   356

   357

Vehicle *GetLastVehicleInChain(Vehicle *v)

   358

{

   359

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

   360

	return v;

   361

}

   362

   363

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

   364

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

   365

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

   366

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

   367

 * called by anything but GetFirstVehicleInChain

   368

 */

   369

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   370

{

   371

	Vehicle *u;

   372

   373

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

   374

   375

	return NULL;

   376

}

   377

   378

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

   379

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

   380

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

   381

 */

   382

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   383

{

   384

	Vehicle *u;

   385

	assert(v != NULL);

   386

   387

	u = GetFirstVehicleInChain(v);

   388

   389

 	// Check to see if this is the first

   390

	if (v == u) return NULL;

   391

   392

	do {

   393

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

   394

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

   395

   396

	return NULL;

   397

}

   398

   399

/** Finds the first vehicle in a chain.

   400

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

   401

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

   402

 */

   403

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   404

{

   405

	Vehicle* u;

   406

   407

	assert(v != NULL);

   408

   409

	if (v->first != NULL) {

   410

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

   411

   412

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

   413

	}

   414

   415

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

   416

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

   417

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

   418

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

   419

   420

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

   421

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

   422

   423

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

   424

	if (v->subtype == TS_Front_Engine)

   425

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

   426

   427

	return (Vehicle*)v;

   428

}

   429

   430

int CountVehiclesInChain(Vehicle *v)

   431

{

   432

	int count = 0;

   433

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

   434

	return count;

   435

}

   436

   437

void DeleteVehicle(Vehicle *v)

   438

{

   439

	DeleteName(v->string_id);

   440

	v->type = 0;

   441

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   442

	v->next_hash = INVALID_VEHICLE;

   443

   444

	if (v->orders != NULL)

   445

		DeleteVehicleOrders(v);

   446

}

   447

   448

void DeleteVehicleChain(Vehicle *v)

   449

{

   450

	do {

   451

		Vehicle *u = v;

   452

		v = v->next;

   453

		DeleteVehicle(u);

   454

	} while (v != NULL);

   455

}

   456

   457

   458

void Aircraft_Tick(Vehicle *v);

   459

void RoadVeh_Tick(Vehicle *v);

   460

void Ship_Tick(Vehicle *v);

   461

void Train_Tick(Vehicle *v);

   462

static void EffectVehicle_Tick(Vehicle *v);

   463

void DisasterVehicle_Tick(Vehicle *v);

   464

   465

VehicleTickProc *_vehicle_tick_procs[] = {

   466

	Train_Tick,

   467

	RoadVeh_Tick,

   468

	Ship_Tick,

   469

	Aircraft_Tick,

   470

	EffectVehicle_Tick,

   471

	DisasterVehicle_Tick,

   472

};

   473

   474

void CallVehicleTicks(void)

   475

{

   476

	Vehicle *v;

   477

   478

	FOR_ALL_VEHICLES(v) {

   479

		if (v->type != 0)

   480

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

   481

	}

   482

}

   483

   484

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   485

{

   486

	uint32 full = 0, not_full = 0;

   487

   488

	//special handling of aircraft

   489

   490

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

   491

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

   492

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

   493

		return true;

   494

	}

   495

   496

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

   497

	do {

   498

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

   499

		assert(v->cargo_type<32);

   500

   501

		if (v->cargo_cap != 0) {

   502

			uint32 mask = 1 << v->cargo_type;

   503

			if (v->cargo_cap == v->cargo_count) full |= mask; else not_full |= mask;

   504

		}