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"

    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

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   363

{

   364

	Vehicle *u;

   365

   366

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

   367

   368

	return NULL;

   369

}

   370

   371

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   372

{

   373

	Vehicle* u;

   374

   375

	if (v->first != NULL) {

   376

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

   377

   378

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

   379

	}

   380

   381

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

   382

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

   383

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

   384

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

   385

   386

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

   387

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

   388

   389

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

   390

	if (v->subtype == TS_Front_Engine)

   391

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

   392

   393

	return (Vehicle*)v;

   394

}

   395

   396

int CountVehiclesInChain(Vehicle *v)

   397

{

   398

	int count = 0;

   399

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

   400

	return count;

   401

}

   402

   403

void DeleteVehicle(Vehicle *v)

   404

{

   405

	DeleteName(v->string_id);

   406

	v->type = 0;

   407

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   408

	v->next_hash = INVALID_VEHICLE;

   409

   410

	if (v->orders != NULL)

   411

		DeleteVehicleOrders(v);

   412

}

   413

   414

void DeleteVehicleChain(Vehicle *v)

   415

{

   416

	do {

   417

		Vehicle *u = v;

   418

		v = v->next;

   419

		DeleteVehicle(u);

   420

	} while (v != NULL);

   421

}

   422

   423

   424

void Aircraft_Tick(Vehicle *v);

   425

void RoadVeh_Tick(Vehicle *v);

   426

void Ship_Tick(Vehicle *v);

   427

void Train_Tick(Vehicle *v);

   428

static void EffectVehicle_Tick(Vehicle *v);

   429

void DisasterVehicle_Tick(Vehicle *v);

   430

   431

VehicleTickProc *_vehicle_tick_procs[] = {

   432

	Train_Tick,

   433

	RoadVeh_Tick,

   434

	Ship_Tick,

   435

	Aircraft_Tick,

   436

	EffectVehicle_Tick,

   437

	DisasterVehicle_Tick,

   438

};

   439

   440

void CallVehicleTicks(void)

   441

{

   442

	Vehicle *v;

   443

   444

	FOR_ALL_VEHICLES(v) {

   445

		if (v->type != 0)

   446

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

   447

	}

   448

}

   449

   450

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   451

{

   452

	uint32 full = 0, not_full = 0;

   453

   454

	//special handling of aircraft

   455

   456

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

   457

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

   458

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

   459

		return true;

   460

	}

   461

   462

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

   463

	do {

   464

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

   465

		assert(v->cargo_type<32);

   466

   467

		if (v->cargo_cap != 0) {

   468

			uint32 mask = 1 << v->cargo_type;

   469

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

   470

		}

   471

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

   472

   473

	// continue loading if there is a non full cargo type and no cargo type that is full

   474

	return not_full && (full & ~not_full) == 0;

   475

}

   476

   477

bool CanFillVehicle(Vehicle *v)

   478

{

   479

	TileIndex tile = v->tile;

   480

   481

	if (IsTileType(tile, MP_STATION) ||

   482

			(v->type == VEH_Ship && (

   483

				IsTileType(TILE_ADDXY(tile,  1,  0), MP_STATION) ||

   484

				IsTileType(TILE_ADDXY(tile, -1,  0), MP_STATION) ||

   485

				IsTileType(TILE_ADDXY(tile,  0,  1), MP_STATION) ||

   486

				IsTileType(TILE_ADDXY(tile,  0, -1), MP_STATION) ||

   487

				IsTileType(TILE_ADDXY(tile, -2,  0), MP_STATION)

   488

			))) {

   489

   490

		// If patch is active, use alternative CanFillVehicle-function

   491

		if (_patches.full_load_any)

   492

			return CanFillVehicle_FullLoadAny(v);

   493

   494

		do {

   495

			if (v->cargo_count != v->cargo_cap)

   496

				return true;

   497

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

   498

	}

   499

	return false;

   500

}

   501

   502

/** Check if a given vehicle (type) can be refitted to a given cargo

   503

 * @param *v vehicle to check

   504

 * @param cid_to check refit to this cargo-type

   505

 * @return true if it is possible, false otherwise