1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "spritecache.h"

     4

#include "table/strings.h"

     5

#include "map.h"

     6

#include "tile.h"

     7

#include "vehicle.h"

     8

#include "gfx.h"

     9

#include "viewport.h"

    10

#include "news.h"

    11

#include "command.h"

    12

#include "saveload.h"

    13

#include "player.h"

    14

#include "engine.h"

    15

#include "sound.h"

    16

    17

#define INVALID_COORD (-0x8000)

    18

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

    19

    20

enum {

    21

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

    22

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

    23

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    24

    25

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

    26

};

    27

    28

/**

    29

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

    30

 */

    31

static void VehiclePoolNewBlock(uint start_item)

    32

{

    33

	Vehicle *v;

    34

    35

	FOR_ALL_VEHICLES_FROM(v, start_item)

    36

		v->index = start_item++;

    37

}

    38

    39

/* Initialize the vehicle-pool */

    40

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

    41

    42

void VehicleServiceInDepot(Vehicle *v)

    43

{

    44

	v->date_of_last_service = _date;

    45

	v->breakdowns_since_last_service = 0;

    46

	v->reliability = _engines[v->engine_type].reliability;

    47

}

    48

    49

bool VehicleNeedsService(const Vehicle *v)

    50

{

    51

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

    52

		return false;

    53

    54

	return _patches.servint_ispercent ?

    55

		(v->reliability < _engines[v->engine_type].reliability * (100 - v->service_interval) / 100) :

    56

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

    57

}

    58

    59

void VehicleInTheWayErrMsg(Vehicle *v)

    60

{

    61

	StringID id;

    62

    63

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

    64

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

    65

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

    66

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    67

    68

	_error_message = id;

    69

}

    70

    71

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

    72

{

    73

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

    74

		return NULL;

    75

    76

	VehicleInTheWayErrMsg(v);

    77

	return v;

    78

}

    79

    80

bool EnsureNoVehicle(TileIndex tile)

    81

{

    82

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

    83

}

    84

    85

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

    86

{

    87

	const TileInfo *ti = data;

    88

    89

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

    90

		return NULL;

    91

    92

	VehicleInTheWayErrMsg(v);

    93

	return v;

    94

}

    95

    96

static inline uint Correct_Z(uint tileh)

    97

{

    98

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

    99

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

   100

	return (CORRECT_Z(tileh)) ? 8 : 0;

   101

}

   102

   103

uint GetCorrectTileHeight(TileIndex tile)

   104

{

   105

	return Correct_Z(GetTileSlope(tile, NULL));

   106

}

   107

   108

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   109

{

   110

	TileInfo ti;

   111

   112

	FindLandscapeHeightByTile(&ti, tile);

   113

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

   114

   115

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

   116

}

   117

   118

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

   119

{

   120

	int x1 = TileX(from);

   121

	int y1 = TileY(from);

   122

	int x2 = TileX(to);

   123

	int y2 = TileY(to);

   124

	Vehicle *veh;

   125

   126

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

   127

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

   128

		intswap(x1,x2);

   129

		intswap(y1,y2);

   130

	}

   131

	FOR_ALL_VEHICLES(veh) {

   132

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

   133

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

   134

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

   135

				return veh;

   136

			}

   137

		}

   138

	}

   139

	return NULL;

   140

}

   141

   142

void VehiclePositionChanged(Vehicle *v)

   143

{

   144

	int img = v->cur_image;

   145

	const SpriteDimension *sd;

   146

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

   147

   148

	sd = GetSpriteDimension(img);

   149

   150

	pt.x += sd->xoffs;

   151

	pt.y += sd->yoffs;

   152

   153

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

   154

   155

	v->left_coord = pt.x;

   156

	v->top_coord = pt.y;

   157

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

   158

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

   159

}

   160

   161

void UpdateWaypointSign(Waypoint *cp)

   162

{

   163

	Point pt = RemapCoords2(TileX(cp->xy) * 16, TileY(cp->xy) * 16);

   164

	SetDParam(0, cp - _waypoints);

   165

	UpdateViewportSignPos(&cp->sign, pt.x, pt.y - 0x20, STR_WAYPOINT_VIEWPORT);

   166

}

   167

   168

void RedrawWaypointSign(Waypoint *cp)

   169

{

   170

	MarkAllViewportsDirty(

   171

		cp->sign.left - 6,

   172

		cp->sign.top,

   173

		cp->sign.left + (cp->sign.width_1 << 2) + 12,

   174

		cp->sign.top + 48);

   175

}

   176

   177

// Called after load to update coordinates

   178

void AfterLoadVehicles(void)

   179

{

   180

	Vehicle *v;

   181

	Waypoint *cp;

   182

   183

	FOR_ALL_VEHICLES(v) {

   184

		if (v->type != 0) {

   185

			v->left_coord = INVALID_COORD;

   186

			VehiclePositionChanged(v);

   187

   188

			if (v->type == VEH_Train) {

   189

				if (v->subtype == TS_Front_Engine)

   190

					UpdateTrainAcceleration(v);

   191

			}

   192

		}

   193

	}

   194

   195

	// update waypoint signs

   196

	for(cp=_waypoints; cp != endof(_waypoints); cp++) if (cp->xy) UpdateWaypointSign(cp);

   197

}

   198

   199

   200

static Vehicle *InitializeVehicle(Vehicle *v)

   201

{

   202

	VehicleID index = v->index;

   203

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

   204

	v->index = index;

   205

   206

	assert(v->orders == NULL);

   207

   208

	v->left_coord = INVALID_COORD;

   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

	v->set_for_replacement = false;

   215

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

   216

	    which are technical the same (newgrf stuff).

   217

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

   218

	    not really matter that one client has other visual vehicles than

   219

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

   220

	*/

   221

	v->random_bits = InteractiveRandomRange(256);

   222

	return v;

   223

}

   224

   225

Vehicle *ForceAllocateSpecialVehicle(void)

   226

{

   227

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

   228

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

   229

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

   230

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   231

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

   232

   233

	Vehicle *v;

   234

   235

	FOR_ALL_VEHICLES(v) {

   236

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

   237

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

   238

			return NULL;

   239

   240

		if (v->type == 0)

   241

			return InitializeVehicle(v);

   242

	}

   243

   244

	return NULL;

   245

}

   246

   247

Vehicle *AllocateVehicle(void)

   248

{

   249

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

   250

	 * first blocks */

   251

	Vehicle *v;

   252

   253

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

   254

		if (v->type == 0)

   255

			return InitializeVehicle(v);

   256

	}

   257

   258

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

   259

	if (AddBlockToPool(&_vehicle_pool))

   260

		return AllocateVehicle();

   261

   262

	return NULL;

   263

}

   264

   265

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

   266

{

   267

	int x,y,x2,y2;

   268

	VehicleID veh;

   269

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

   270

   271

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

   272

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

   273

   274

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

   275

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

   276

   277

	for(;;) {

   278

		int xb = x;

   279

		for(;;) {

   280

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

   281

			while (veh != INVALID_VEHICLE) {

   282

				Vehicle *v = GetVehicle(veh);

   283

				void *a;

   284

   285

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

   286

					return a;

   287

				veh = v->next_hash;

   288

			}

   289

   290

			if (x == x2)

   291

				break;

   292

   293

			x = (x + 1) & 0x3F;

   294

		}

   295

		x = xb;

   296

   297

		if (y == y2)

   298

			break;

   299

   300

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

   301

	}

   302

	return NULL;

   303

}

   304

   305

   306

   307

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

   308

{

   309

	VehicleID *old_hash, *new_hash;

   310

	int old_x = v->left_coord;

   311

	int old_y = v->top_coord;

   312

	Vehicle *u;

   313

   314

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

   315

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

   316

   317

	if (old_hash == new_hash)

   318

		return;

   319

   320

	/* remove from hash table? */

   321

	if (old_hash != NULL) {

   322

		Vehicle *last = NULL;

   323

		int idx = *old_hash;

   324

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

   325

			idx = u->next_hash;

   326

			assert(idx != INVALID_VEHICLE);

   327

			last = u;

   328

		}

   329

   330

		if (last == NULL)

   331

			*old_hash = v->next_hash;

   332

		else

   333

			last->next_hash = v->next_hash;

   334

	}

   335

   336

	/* insert into hash table? */

   337

	if (new_hash != NULL) {

   338

		v->next_hash = *new_hash;

   339

		*new_hash = v->index;

   340

	}

   341

}

   342

   343

void InitializeVehicles(void)

   344

{

   345

	int i;

   346

   347

	/* Clean the vehicle pool, and reserve enough blocks

   348

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

   349

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

   350

	CleanPool(&_vehicle_pool);

   351

	AddBlockToPool(&_vehicle_pool);

   352

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

   353

		AddBlockToPool(&_vehicle_pool);

   354

   355

	// clear it...

   356

	memset(&_waypoints, 0, sizeof(_waypoints));

   357

   358

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

   359

}

   360

   361

Vehicle *GetLastVehicleInChain(Vehicle *v)

   362

{

   363

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

   364

	return v;

   365

}

   366

   367

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   368

{

   369

	Vehicle *org = v;

   370

   371

	FOR_ALL_VEHICLES(v) {

   372

		if (v->type == VEH_Train && org == v->next)

   373

			return v;

   374

	}

   375

   376

	return NULL;

   377

}

   378

   379

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   380

{

   381

	Vehicle *u;

   382

   383

	while (true) {

   384

		u = v;

   385

		v = GetPrevVehicleInChain(v);

   386

		/* If there is no such vehicle,

   387

		    'v' == NULL and so 'u' is the first vehicle in chain */

   388

		if (v == NULL)

   389

			return u;

   390

	}

   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

Waypoint *AllocateWaypoint(void)

   401

{

   402

	Waypoint *cp;

   403

   404

	for(cp = _waypoints; cp != endof(_waypoints); cp++) {

   405

		if (cp->xy == 0)

   406

			return cp;

   407

	}

   408

   409

	return NULL;

   410

}

   411

   412

uint GetWaypointByTile(uint tile)

   413

{

   414

	Waypoint *cp;

   415

	int i=0;

   416

	for(cp=_waypoints; cp->xy != (TileIndex)tile; cp++) { i++; }

   417

	return i;

   418

}

   419

   420

void DeleteVehicle(Vehicle *v)

   421

{

   422

	DeleteName(v->string_id);

   423

	v->type = 0;

   424

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   425

	v->next_hash = 0xffff;

   426

   427

	if (v->orders != NULL)

   428

		DeleteVehicleOrders(v);

   429

}

   430

   431

void DeleteVehicleChain(Vehicle *v)

   432

{

   433

	do {

   434

		Vehicle *u = v;

   435

		v = v->next;

   436

		DeleteVehicle(u);

   437

	} while (v);

   438

}

   439

   440

   441

void Aircraft_Tick(Vehicle *v);

   442

void RoadVeh_Tick(Vehicle *v);

   443

void Ship_Tick(Vehicle *v);

   444

void Train_Tick(Vehicle *v);

   445

static void EffectVehicle_Tick(Vehicle *v);

   446

void DisasterVehicle_Tick(Vehicle *v);

   447

   448

VehicleTickProc *_vehicle_tick_procs[] = {

   449

	Train_Tick,

   450

	RoadVeh_Tick,

   451

	Ship_Tick,

   452

	Aircraft_Tick,

   453

	EffectVehicle_Tick,

   454

	DisasterVehicle_Tick,

   455

};

   456

   457

void CallVehicleTicks(void)

   458

{

   459

	Vehicle *v;

   460

   461

	FOR_ALL_VEHICLES(v) {

   462

		if (v->type != 0)

   463

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

   464

	}

   465

}

   466

   467

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   468

{

   469

	uint32 full = 0, not_full = 0;

   470

   471

	//special handling of aircraft

   472

   473

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

   474

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

   475

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

   476

		return true;

   477

	}

   478

   479

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

   480

	do {

   481

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

   482

		assert(v->cargo_type<32);

   483

   484

		if (v->cargo_cap != 0) {

   485

			uint32 mask = 1 << v->cargo_type;

   486

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

   487

		}

   488

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

   489

   490

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

   491

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

   492

}

   493

   494

bool CanFillVehicle(Vehicle *v)

   495

{

   496

	TileIndex tile = v->tile;

   497

   498

	if (IsTileType(tile, MP_STATION) ||

   499

			(v->type == VEH_Ship && (

   500

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

   501

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

   502

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

   503

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

   504

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

   505

			))) {

   506

   507

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

   508

		if (_patches.full_load_any)