1

#include "stdafx.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 "npf.h"

    19

#include "vehicle_gui.h"

    20

#include "depot.h"

    21

#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 = _engines[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 < _engines[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 (!_patches.realistic_acceleration && v->type == VEH_Train) {

   192

				if (v->subtype == TS_Front_Engine)

   193

					UpdateTrainAcceleration(v);

   194

			}

   195

		}

   196

	}

   197

}

   198

   199

static Vehicle *InitializeVehicle(Vehicle *v)

   200

{

   201

	VehicleID index = v->index;

   202

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

   203

	v->index = index;

   204

   205

	assert(v->orders == NULL);

   206

   207

	v->left_coord = INVALID_COORD;

   208

	v->first = NULL;

   209

	v->next = NULL;

   210

	v->next_hash = INVALID_VEHICLE;

   211

	v->string_id = 0;

   212

	v->next_shared = NULL;

   213

	v->prev_shared = NULL;

   214

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

   215

	    which are technical the same (newgrf stuff).

   216

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

   217

	    not really matter that one client has other visual vehicles than

   218

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

   219

	*/

   220

	v->random_bits = InteractiveRandomRange(256);

   221

	return v;

   222

}

   223

   224

Vehicle *ForceAllocateSpecialVehicle(void)

   225

{

   226

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

   227

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

   228

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

   229

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   230

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

   231

   232

	Vehicle *v;

   233

   234

	FOR_ALL_VEHICLES(v) {

   235

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

   236

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

   237

			return NULL;

   238

   239

		if (v->type == 0)

   240

			return InitializeVehicle(v);

   241

	}

   242

   243

	return NULL;

   244

}

   245

   246

Vehicle *AllocateVehicle(void)

   247

{

   248

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

   249

	 * first blocks */

   250

	Vehicle *v;

   251

   252

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

   253

		if (v->type == 0)

   254

			return InitializeVehicle(v);

   255

	}

   256

   257

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

   258

	if (AddBlockToPool(&_vehicle_pool))

   259

		return AllocateVehicle();

   260

   261

	return NULL;

   262

}

   263

   264

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

   265

{

   266

	int x,y,x2,y2;

   267

	VehicleID veh;

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

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

   275

   276

	for(;;) {

   277

		int xb = x;

   278

		for(;;) {

   279

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

   280

			while (veh != INVALID_VEHICLE) {

   281

				Vehicle *v = GetVehicle(veh);

   282

				void *a;

   283

   284

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

   285

					return a;

   286

				veh = v->next_hash;

   287

			}

   288

   289

			if (x == x2)

   290

				break;

   291

   292

			x = (x + 1) & 0x3F;

   293

		}

   294

		x = xb;

   295

   296

		if (y == y2)

   297

			break;

   298

   299

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

   300

	}

   301

	return NULL;

   302

}

   303

   304

   305

   306

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

   307

{

   308

	VehicleID *old_hash, *new_hash;

   309

	int old_x = v->left_coord;

   310

	int old_y = v->top_coord;

   311

	Vehicle *u;

   312

   313

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

   314

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

   315

   316

	if (old_hash == new_hash)

   317

		return;

   318

   319

	/* remove from hash table? */

   320

	if (old_hash != NULL) {

   321

		Vehicle *last = NULL;

   322

		int idx = *old_hash;

   323

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

   324

			idx = u->next_hash;

   325

			assert(idx != INVALID_VEHICLE);

   326

			last = u;

   327

		}

   328

   329

		if (last == NULL)

   330

			*old_hash = v->next_hash;

   331

		else

   332

			last->next_hash = v->next_hash;

   333

	}

   334

   335

	/* insert into hash table? */

   336

	if (new_hash != NULL) {

   337

		v->next_hash = *new_hash;

   338

		*new_hash = v->index;

   339

	}

   340

}

   341

   342

void InitializeVehicles(void)

   343

{

   344

	int i;

   345

   346

	/* Clean the vehicle pool, and reserve enough blocks

   347

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

   348

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

   349

	CleanPool(&_vehicle_pool);

   350

	AddBlockToPool(&_vehicle_pool);

   351

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

   352

		AddBlockToPool(&_vehicle_pool);

   353

   354

	// clear it...

   355

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

   356

}

   357

   358

Vehicle *GetLastVehicleInChain(Vehicle *v)

   359

{

   360

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

   361

	return v;

   362

}

   363

   364

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   365

{

   366

	Vehicle *u;

   367

   368

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

   369

   370

	return NULL;

   371

}

   372

   373

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   374

{

   375

	Vehicle* u;

   376

   377

	if (v->first != NULL) {

   378

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

   379

   380

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

   381

	}

   382

   383

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

   384

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

   385

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

   386

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

   387

   388

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

   389

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

   390

   391

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

   392

	if (v->subtype == TS_Front_Engine)

   393

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

   394

   395

	return (Vehicle*)v;

   396

}

   397

   398

int CountVehiclesInChain(Vehicle *v)

   399

{

   400

	int count = 0;

   401

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

   402

	return count;

   403

}

   404

   405

void DeleteVehicle(Vehicle *v)

   406

{

   407

	DeleteName(v->string_id);

   408

	v->type = 0;

   409

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   410

	v->next_hash = INVALID_VEHICLE;

   411

   412

	if (v->orders != NULL)

   413

		DeleteVehicleOrders(v);

   414

}

   415

   416

void DeleteVehicleChain(Vehicle *v)

   417

{

   418

	do {

   419

		Vehicle *u = v;

   420

		v = v->next;

   421

		DeleteVehicle(u);

   422

	} while (v != NULL);

   423

}

   424

   425

   426

void Aircraft_Tick(Vehicle *v);

   427

void RoadVeh_Tick(Vehicle *v);

   428

void Ship_Tick(Vehicle *v);

   429

void Train_Tick(Vehicle *v);

   430

static void EffectVehicle_Tick(Vehicle *v);

   431

void DisasterVehicle_Tick(Vehicle *v);

   432

   433

VehicleTickProc *_vehicle_tick_procs[] = {

   434

	Train_Tick,

   435

	RoadVeh_Tick,

   436

	Ship_Tick,

   437

	Aircraft_Tick,

   438

	EffectVehicle_Tick,

   439

	DisasterVehicle_Tick,

   440

};

   441

   442

void CallVehicleTicks(void)

   443

{

   444

	Vehicle *v;

   445

   446

	FOR_ALL_VEHICLES(v) {

   447

		if (v->type != 0)

   448

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

   449

	}

   450

}

   451

   452

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   453

{

   454

	uint32 full = 0, not_full = 0;

   455

   456

	//special handling of aircraft

   457

   458

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

   459

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

   460

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

   461

		return true;

   462

	}

   463

   464

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

   465

	do {

   466

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

   467

		assert(v->cargo_type<32);

   468

   469

		if (v->cargo_cap != 0) {

   470

			uint32 mask = 1 << v->cargo_type;

   471

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

   472

		}

   473

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

   474

   475

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

   476

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

   477

}

   478

   479

bool CanFillVehicle(Vehicle *v)

   480

{

   481

	TileIndex tile = v->tile;

   482

   483

	if (IsTileType(tile, MP_STATION) ||

   484

			(v->type == VEH_Ship && (

   485

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

   486

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

   487

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

   488

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

   489

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

   490

			))) {

   491

   492

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

   493

		if (_patches.full_load_any)

   494

			return CanFillVehicle_FullLoadAny(v);

   495

   496

		do {

   497

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

   498

				return true;

   499

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

   500

	}

   501

	return false;

   502

}

   503

   504

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

   505

 * @param *v vehicle to check

   506

 * @param cid_to check refit to this cargo-type