1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "spritecache.h"

     4

#include "table/sprites.h"

     5

#include "table/strings.h"

     6

#include "map.h"

     7

#include "tile.h"

     8

#include "vehicle.h"

     9

#include "gfx.h"

    10

#include "viewport.h"

    11

#include "news.h"

    12

#include "command.h"

    13

#include "saveload.h"

    14

#include "player.h"

    15

#include "engine.h"

    16

#include "sound.h"

    17

#include "debug.h"

    18

#include "vehicle_gui.h"

    19

#include "depot.h"

    20

#include "station.h"

    21

#include "rail.h"

    22

    23

#define INVALID_COORD (-0x8000)

    24

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

    25

    26

enum {

    27

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

    28

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

    29

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    30

    31

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

    32

};

    33

    34

/**

    35

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

    36

 */

    37

static void VehiclePoolNewBlock(uint start_item)

    38

{

    39

	Vehicle *v;

    40

    41

	FOR_ALL_VEHICLES_FROM(v, start_item)

    42

		v->index = start_item++;

    43

}

    44

    45

/* Initialize the vehicle-pool */

    46

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

    47

    48

void VehicleServiceInDepot(Vehicle *v)

    49

{

    50

	v->date_of_last_service = _date;

    51

	v->breakdowns_since_last_service = 0;

    52

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

    53

}

    54

    55

bool VehicleNeedsService(const Vehicle *v)

    56

{

    57

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

    58

		return false;

    59

    60

	if (v->vehstatus & VS_CRASHED)

    61

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

    62

    63

	return _patches.servint_ispercent ?

    64

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

    65

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

    66

}

    67

    68

void VehicleInTheWayErrMsg(Vehicle *v)

    69

{

    70

	StringID id;

    71

    72

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

    73

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

    74

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

    75

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    76

    77

	_error_message = id;

    78

}

    79

    80

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

    81

{

    82

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

    83

		return NULL;

    84

    85

	VehicleInTheWayErrMsg(v);

    86

	return v;

    87

}

    88

    89

bool EnsureNoVehicle(TileIndex tile)

    90

{

    91

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

    92

}

    93

    94

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

    95

{

    96

	const TileInfo *ti = data;

    97

    98

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

    99

		return NULL;

   100

   101

	VehicleInTheWayErrMsg(v);

   102

	return v;

   103

}

   104

   105

static inline uint Correct_Z(uint tileh)

   106

{

   107

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

   108

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

   109

	return CorrectZ(tileh) ? 8 : 0;

   110

}

   111

   112

uint GetCorrectTileHeight(TileIndex tile)

   113

{

   114

	return Correct_Z(GetTileSlope(tile, NULL));

   115

}

   116

   117

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   118

{

   119

	TileInfo ti;

   120

   121

	FindLandscapeHeightByTile(&ti, tile);

   122

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

   123

   124

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

   125

}

   126

   127

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   128

{

   129

	TileInfo ti;

   130

   131

	ti.tile = tile;

   132

	ti.z = z;

   133

   134

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   135

}

   136

   137

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

   138

{

   139

	int x1 = TileX(from);

   140

	int y1 = TileY(from);

   141

	int x2 = TileX(to);

   142

	int y2 = TileY(to);

   143

	Vehicle *veh;

   144

   145

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

   146

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

   147

		intswap(x1,x2);

   148

		intswap(y1,y2);

   149

	}

   150

	FOR_ALL_VEHICLES(veh) {

   151

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

   152

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

   153

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

   154

				return veh;

   155

			}

   156

		}

   157

	}

   158

	return NULL;

   159

}

   160

   161

void VehiclePositionChanged(Vehicle *v)

   162

{

   163

	int img = v->cur_image;

   164

	const SpriteDimension *sd;

   165

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

   166

   167

	sd = GetSpriteDimension(img);

   168

   169

	pt.x += sd->xoffs;

   170

	pt.y += sd->yoffs;

   171

   172

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

   173

   174

	v->left_coord = pt.x;

   175

	v->top_coord = pt.y;

   176

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

   177

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

   178

}

   179

   180

// Called after load to update coordinates

   181

void AfterLoadVehicles(void)

   182

{

   183

	Vehicle *v;

   184

   185

	FOR_ALL_VEHICLES(v) {

   186

		v->first = NULL;

   187

		if (v->type != 0) {

   188

			v->left_coord = INVALID_COORD;

   189

			VehiclePositionChanged(v);

   190

   191

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

   192

				TrainConsistChanged(v);

   193

		}

   194

	}

   195

}

   196

   197

static Vehicle *InitializeVehicle(Vehicle *v)

   198

{

   199

	VehicleID index = v->index;

   200

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

   201

	v->index = index;

   202

   203

	assert(v->orders == NULL);

   204

   205

	v->left_coord = INVALID_COORD;

   206

	v->first = NULL;

   207

	v->next = NULL;

   208

	v->next_hash = INVALID_VEHICLE;

   209

	v->string_id = 0;

   210

	v->next_shared = NULL;

   211

	v->prev_shared = NULL;

   212

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

   213

	    which are technical the same (newgrf stuff).

   214

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

   215

	    not really matter that one client has other visual vehicles than

   216

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

   217

	*/

   218

	v->random_bits = InteractiveRandomRange(256);

   219

	return v;

   220

}

   221

   222

Vehicle *ForceAllocateSpecialVehicle(void)

   223

{

   224

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

   225

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

   226

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

   227

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   228

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

   229

   230

	Vehicle *v;

   231

   232

	FOR_ALL_VEHICLES(v) {

   233

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

   234

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

   235

			return NULL;

   236

   237

		if (v->type == 0)

   238

			return InitializeVehicle(v);

   239

	}

   240

   241

	return NULL;

   242

}

   243

   244

Vehicle *AllocateVehicle(void)

   245

{

   246

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

   247

	 * first blocks */

   248

	Vehicle *v;

   249

   250

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

   251

		if (v->type == 0)

   252

			return InitializeVehicle(v);

   253

	}

   254

   255

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

   256

	if (AddBlockToPool(&_vehicle_pool))

   257

		return AllocateVehicle();

   258

   259

	return NULL;

   260

}

   261

   262

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

   263

{

   264

	int x,y,x2,y2;

   265

	VehicleID veh;

   266

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

   267

   268

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

   269

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

   270

   271

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

   272

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

   273

   274

	for(;;) {

   275

		int xb = x;

   276

		for(;;) {

   277

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

   278

			while (veh != INVALID_VEHICLE) {

   279

				Vehicle *v = GetVehicle(veh);

   280

				void *a;

   281

   282

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

   283

					return a;

   284

				veh = v->next_hash;

   285

			}

   286

   287

			if (x == x2)

   288

				break;

   289

   290

			x = (x + 1) & 0x3F;

   291

		}

   292

		x = xb;

   293

   294

		if (y == y2)

   295

			break;

   296

   297

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

   298

	}

   299

	return NULL;

   300

}

   301

   302

   303

   304

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

   305

{

   306

	VehicleID *old_hash, *new_hash;

   307

	int old_x = v->left_coord;

   308

	int old_y = v->top_coord;

   309

	Vehicle *u;

   310

   311

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

   312

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

   313

   314

	if (old_hash == new_hash)

   315

		return;

   316

   317

	/* remove from hash table? */

   318

	if (old_hash != NULL) {

   319

		Vehicle *last = NULL;

   320

		int idx = *old_hash;

   321

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

   322

			idx = u->next_hash;

   323

			assert(idx != INVALID_VEHICLE);

   324

			last = u;

   325

		}

   326

   327

		if (last == NULL)

   328

			*old_hash = v->next_hash;

   329

		else

   330

			last->next_hash = v->next_hash;

   331

	}

   332

   333

	/* insert into hash table? */

   334

	if (new_hash != NULL) {

   335

		v->next_hash = *new_hash;

   336

		*new_hash = v->index;

   337

	}

   338

}

   339

   340

void InitializeVehicles(void)

   341

{

   342

	int i;

   343

   344

	/* Clean the vehicle pool, and reserve enough blocks

   345

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

   346

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

   347

	CleanPool(&_vehicle_pool);

   348

	AddBlockToPool(&_vehicle_pool);

   349

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

   350

		AddBlockToPool(&_vehicle_pool);

   351

   352

	// clear it...

   353

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

   354

}

   355

   356

Vehicle *GetLastVehicleInChain(Vehicle *v)

   357

{

   358

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

   359

	return v;

   360

}

   361

   362

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

   363

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

   364

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

   365

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

   366

 * called by anything but GetFirstVehicleInChain

   367

 */

   368

static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)

   369

{

   370

	Vehicle *u;

   371

   372

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

   373

   374

	return NULL;

   375

}

   376

   377

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

   378

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

   379

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

   380

 */

   381

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   382

{

   383

	Vehicle *u;

   384

	assert(v != NULL);

   385

   386

	u = GetFirstVehicleInChain(v);

   387

   388

 	// Check to see if this is the first

   389

	if (v == u) return NULL;

   390

   391

	do {

   392

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

   393

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

   394

   395

	return NULL;

   396

}

   397

   398

/** Finds the first vehicle in a chain.

   399

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

   400

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

   401

 */

   402

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   403

{

   404

	Vehicle* u;

   405

   406

	assert(v != NULL);

   407

   408

	if (v->first != NULL) {

   409

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

   410

   411

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

   412

	}

   413

   414

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

   415

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

   416

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

   417

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

   418

   419

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

   420

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

   421

   422

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

   423

	if (v->subtype == TS_Front_Engine)

   424

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

   425

   426

	return (Vehicle*)v;

   427

}

   428

   429

int CountVehiclesInChain(Vehicle *v)

   430

{

   431

	int count = 0;

   432

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

   433

	return count;

   434

}

   435

   436

void DeleteVehicle(Vehicle *v)

   437

{

   438

	DeleteName(v->string_id);

   439

	v->type = 0;

   440

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   441

	v->next_hash = INVALID_VEHICLE;

   442

   443

	if (v->orders != NULL)

   444

		DeleteVehicleOrders(v);

   445

}

   446

   447

void DeleteVehicleChain(Vehicle *v)

   448

{

   449

	do {

   450

		Vehicle *u = v;

   451

		v = v->next;

   452

		DeleteVehicle(u);

   453

	} while (v != NULL);

   454

}

   455

   456

   457

void Aircraft_Tick(Vehicle *v);

   458

void RoadVeh_Tick(Vehicle *v);

   459

void Ship_Tick(Vehicle *v);

   460

void Train_Tick(Vehicle *v);

   461

static void EffectVehicle_Tick(Vehicle *v);

   462

void DisasterVehicle_Tick(Vehicle *v);

   463

   464

VehicleTickProc *_vehicle_tick_procs[] = {

   465

	Train_Tick,

   466

	RoadVeh_Tick,

   467

	Ship_Tick,

   468

	Aircraft_Tick,

   469

	EffectVehicle_Tick,

   470

	DisasterVehicle_Tick,

   471

};

   472

   473

void CallVehicleTicks(void)

   474

{

   475

	Vehicle *v;

   476

   477

	FOR_ALL_VEHICLES(v) {

   478

		if (v->type != 0)

   479

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

   480

	}

   481

}

   482

   483

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   484

{

   485

	uint32 full = 0, not_full = 0;

   486

   487

	//special handling of aircraft

   488

   489

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

   490

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

   491

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

   492

		return true;

   493

	}

   494

   495

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

   496

	do {

   497

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

   498

		assert(v->cargo_type<32);

   499

   500

		if (v->cargo_cap != 0) {

   501

			uint32 mask = 1 << v->cargo_type;

   502

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

   503

		}

   504

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