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

    18

#define INVALID_COORD (-0x8000)

    19

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

    20

    21

enum {

    22

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

    23

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

    24

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    25

    26

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

    27

};

    28

    29

/**

    30

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

    31

 */

    32

static void VehiclePoolNewBlock(uint start_item)

    33

{

    34

	Vehicle *v;

    35

    36

	FOR_ALL_VEHICLES_FROM(v, start_item)

    37

		v->index = start_item++;

    38

}

    39

    40

/* Initialize the vehicle-pool */

    41

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

    42

    43

void VehicleServiceInDepot(Vehicle *v)

    44

{

    45

	v->date_of_last_service = _date;

    46

	v->breakdowns_since_last_service = 0;

    47

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

    48

}

    49

    50

bool VehicleNeedsService(const Vehicle *v)

    51

{

    52

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

    53

		return false;

    54

    55

	return _patches.servint_ispercent ?

    56

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

    57

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

    58

}

    59

    60

void VehicleInTheWayErrMsg(Vehicle *v)

    61

{

    62

	StringID id;

    63

    64

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

    65

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

    66

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

    67

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    68

    69

	_error_message = id;

    70

}

    71

    72

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

    73

{

    74

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

    75

		return NULL;

    76

    77

	VehicleInTheWayErrMsg(v);

    78

	return v;

    79

}

    80

    81

bool EnsureNoVehicle(TileIndex tile)

    82

{

    83

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

    84

}

    85

    86

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

    87

{

    88

	const TileInfo *ti = data;

    89

    90

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

    91

		return NULL;

    92

    93

	VehicleInTheWayErrMsg(v);

    94

	return v;

    95

}

    96

    97

static inline uint Correct_Z(uint tileh)

    98

{

    99

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

   100

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

   101

	return CorrectZ(tileh) ? 8 : 0;

   102

}

   103

   104

uint GetCorrectTileHeight(TileIndex tile)

   105

{

   106

	return Correct_Z(GetTileSlope(tile, NULL));

   107

}

   108

   109

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   110

{

   111

	TileInfo ti;

   112

   113

	FindLandscapeHeightByTile(&ti, tile);

   114

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

   115

   116

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

   117

}

   118

   119

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

   120

{

   121

	int x1 = TileX(from);

   122

	int y1 = TileY(from);

   123

	int x2 = TileX(to);

   124

	int y2 = TileY(to);

   125

	Vehicle *veh;

   126

   127

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

   128

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

   129

		intswap(x1,x2);

   130

		intswap(y1,y2);

   131

	}

   132

	FOR_ALL_VEHICLES(veh) {

   133

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

   134

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

   135

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

   136

				return veh;

   137

			}

   138

		}

   139

	}

   140

	return NULL;

   141

}

   142

   143

void VehiclePositionChanged(Vehicle *v)

   144

{

   145

	int img = v->cur_image;

   146

	const SpriteDimension *sd;

   147

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

   148

   149

	sd = GetSpriteDimension(img);

   150

   151

	pt.x += sd->xoffs;

   152

	pt.y += sd->yoffs;

   153

   154

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

   155

   156

	v->left_coord = pt.x;

   157

	v->top_coord = pt.y;

   158

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

   159

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

   160

}

   161

   162

void UpdateWaypointSign(Waypoint *cp)

   163

{

   164

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

   165

	SetDParam(0, cp - _waypoints);

   166

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

   167

}

   168

   169

void RedrawWaypointSign(Waypoint *cp)

   170

{

   171

	MarkAllViewportsDirty(

   172

		cp->sign.left - 6,

   173

		cp->sign.top,

   174

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

   175

		cp->sign.top + 48);

   176

}

   177

   178

// Called after load to update coordinates

   179

void AfterLoadVehicles(void)

   180

{

   181

	Vehicle *v;

   182

	Waypoint *cp;

   183

   184

	FOR_ALL_VEHICLES(v) {

   185

		if (v->type != 0) {

   186

			v->left_coord = INVALID_COORD;

   187

			VehiclePositionChanged(v);

   188

   189

			if (v->type == VEH_Train) {

   190

				if (v->subtype == TS_Front_Engine)

   191

					UpdateTrainAcceleration(v);

   192

			}

   193

		}

   194

	}

   195

   196

	// update waypoint signs

   197

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

   198

}

   199

   200

   201

static Vehicle *InitializeVehicle(Vehicle *v)

   202

{

   203

	VehicleID index = v->index;

   204

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

   205

	v->index = index;

   206

   207

	assert(v->orders == NULL);

   208

   209

	v->left_coord = INVALID_COORD;

   210

	v->next = NULL;

   211

	v->next_hash = 0xffff;

   212

	v->string_id = 0;

   213

	v->next_shared = NULL;

   214

	v->prev_shared = NULL;

   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(const Vehicle *v)

   368

{

   369

	const Vehicle *org = v;

   370

   371

	FOR_ALL_VEHICLES(v) {

   372

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

   373

			return (Vehicle*)v;

   374

	}

   375

   376

	return NULL;

   377

}

   378

   379

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   380

{

   381

	while (true) {

   382

		const Vehicle* u = v;

   383

   384

		v = GetPrevVehicleInChain(v);

   385

		/* If there is no such vehicle,

   386

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

   387

		if (v == NULL)

   388

			return (Vehicle*)u;

   389

	}

   390

}

   391

   392

int CountVehiclesInChain(Vehicle *v)

   393

{

   394

	int count = 0;

   395

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

   396

	return count;

   397

}

   398

   399

Waypoint *AllocateWaypoint(void)

   400

{

   401

	Waypoint *cp;

   402

   403

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

   404

		if (cp->xy == 0)

   405

			return cp;

   406

	}

   407

   408

	return NULL;

   409

}

   410

   411

uint GetWaypointByTile(uint tile)

   412

{

   413

	Waypoint *cp;

   414

	int i=0;

   415

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

   416

	return i;

   417

}

   418

   419

void DeleteVehicle(Vehicle *v)

   420

{

   421

	DeleteName(v->string_id);

   422

	v->type = 0;

   423

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   424

	v->next_hash = 0xffff;

   425

   426

	if (v->orders != NULL)

   427

		DeleteVehicleOrders(v);

   428

}

   429

   430

void DeleteVehicleChain(Vehicle *v)

   431

{

   432

	do {

   433

		Vehicle *u = v;

   434

		v = v->next;

   435

		DeleteVehicle(u);

   436

	} while (v);

   437

}

   438

   439

   440

void Aircraft_Tick(Vehicle *v);

   441

void RoadVeh_Tick(Vehicle *v);

   442

void Ship_Tick(Vehicle *v);

   443

void Train_Tick(Vehicle *v);

   444

static void EffectVehicle_Tick(Vehicle *v);

   445

void DisasterVehicle_Tick(Vehicle *v);

   446

   447

VehicleTickProc *_vehicle_tick_procs[] = {

   448

	Train_Tick,

   449

	RoadVeh_Tick,

   450

	Ship_Tick,

   451

	Aircraft_Tick,

   452

	EffectVehicle_Tick,

   453

	DisasterVehicle_Tick,

   454

};

   455

   456

void CallVehicleTicks(void)

   457

{

   458

	Vehicle *v;

   459

   460

	FOR_ALL_VEHICLES(v) {

   461

		if (v->type != 0)

   462

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

   463

	}

   464

}

   465

   466

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   467

{

   468

	uint32 full = 0, not_full = 0;

   469

   470

	//special handling of aircraft

   471

   472

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

   473

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

   474

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

   475

		return true;

   476

	}

   477

   478

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

   479

	do {

   480

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

   481

		assert(v->cargo_type<32);

   482

   483

		if (v->cargo_cap != 0) {

   484

			uint32 mask = 1 << v->cargo_type;

   485

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

   486

		}

   487

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

   488

   489

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

   490

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

   491

}

   492

   493

bool CanFillVehicle(Vehicle *v)

   494

{

   495

	TileIndex tile = v->tile;

   496

   497

	if (IsTileType(tile, MP_STATION) ||

   498

			(v->type == VEH_Ship && (

   499

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

   500

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

   501

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

   502

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

   503

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

   504

			))) {

   505

   506

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

   507

		if (_patches.full_load_any)

   508