1

#include "stdafx.h"

     2

#include "ttd.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"

    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 = 0xffff;

   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) {

   379

			return v->first;

   380

		} else {

   381

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

   382

		}

   383

	}

   384

   385

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

   386

   387

	if (v->subtype == TS_Front_Engine)

   388

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

   389

   390

	return (Vehicle*)v;

   391

}

   392

   393

int CountVehiclesInChain(Vehicle *v)

   394

{

   395

	int count = 0;

   396

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

   397

	return count;

   398

}

   399

   400

void DeleteVehicle(Vehicle *v)

   401

{

   402

	DeleteName(v->string_id);

   403

	v->type = 0;

   404

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   405

	v->next_hash = 0xffff;

   406

   407

	if (v->orders != NULL)

   408

		DeleteVehicleOrders(v);

   409

}

   410

   411

void DeleteVehicleChain(Vehicle *v)

   412

{

   413

	do {

   414

		Vehicle *u = v;

   415

		v = v->next;

   416

		DeleteVehicle(u);

   417

	} while (v);

   418

}

   419

   420

   421

void Aircraft_Tick(Vehicle *v);

   422

void RoadVeh_Tick(Vehicle *v);

   423

void Ship_Tick(Vehicle *v);

   424

void Train_Tick(Vehicle *v);

   425

static void EffectVehicle_Tick(Vehicle *v);

   426

void DisasterVehicle_Tick(Vehicle *v);

   427

   428

VehicleTickProc *_vehicle_tick_procs[] = {

   429

	Train_Tick,

   430

	RoadVeh_Tick,

   431

	Ship_Tick,

   432

	Aircraft_Tick,

   433

	EffectVehicle_Tick,

   434

	DisasterVehicle_Tick,

   435

};

   436

   437

void CallVehicleTicks(void)

   438

{

   439

	Vehicle *v;

   440

   441

	FOR_ALL_VEHICLES(v) {

   442

		if (v->type != 0)

   443

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

   444

	}

   445

}

   446

   447

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   448

{

   449

	uint32 full = 0, not_full = 0;

   450

   451

	//special handling of aircraft

   452

   453

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

   454

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

   455

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

   456

		return true;

   457

	}

   458

   459

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

   460

	do {

   461

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

   462

		assert(v->cargo_type<32);

   463

   464

		if (v->cargo_cap != 0) {

   465

			uint32 mask = 1 << v->cargo_type;

   466

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

   467

		}

   468

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

   469

   470

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

   471

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

   472

}

   473

   474

bool CanFillVehicle(Vehicle *v)

   475

{

   476

	TileIndex tile = v->tile;

   477

   478

	if (IsTileType(tile, MP_STATION) ||

   479

			(v->type == VEH_Ship && (

   480

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

   481

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

   482

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

   483

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

   484

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

   485

			))) {

   486

   487

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

   488

		if (_patches.full_load_any)

   489

			return CanFillVehicle_FullLoadAny(v);

   490

   491

		do {

   492

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

   493

				return true;

   494

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

   495

	}

   496

	return false;

   497

}

   498

   499

static void DoDrawVehicle(Vehicle *v)

   500

{

   501

	uint32 image = v->cur_image;

   502

   503

	if (v->vehstatus & VS_DISASTER) {

   504

		image |= 0x3224000;

   505

	} else if (v->vehstatus & VS_DEFPAL) {

   506

		image |= (v->vehstatus & VS_CRASHED) ? 0x3248000 : SPRITE_PALETTE(PLAYER_SPRITE_COLOR(v->owner));

   507

	}