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

   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

	v->set_for_replacement = false;

   216

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

   217

	    which are technical the same (newgrf stuff).

   218

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

   219

	    not really matter that one client has other visual vehicles than

   220

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

   221

	*/

   222

	v->random_bits = InteractiveRandomRange(256);

   223

	return v;

   224

}

   225

   226

Vehicle *ForceAllocateSpecialVehicle(void)

   227

{

   228

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

   229

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

   230

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

   231

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   232

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

   233

   234

	Vehicle *v;

   235

   236

	FOR_ALL_VEHICLES(v) {

   237

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

   238

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

   239

			return NULL;

   240

   241

		if (v->type == 0)

   242

			return InitializeVehicle(v);

   243

	}

   244

   245

	return NULL;

   246

}

   247

   248

Vehicle *AllocateVehicle(void)

   249

{

   250

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

   251

	 * first blocks */

   252

	Vehicle *v;

   253

   254

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

   255

		if (v->type == 0)

   256

			return InitializeVehicle(v);

   257

	}

   258

   259

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

   260

	if (AddBlockToPool(&_vehicle_pool))

   261

		return AllocateVehicle();

   262

   263

	return NULL;

   264

}

   265

   266

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

   267

{

   268

	int x,y,x2,y2;

   269

	VehicleID veh;

   270

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

   271

   272

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

   273

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

   274

   275

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

   276

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

   277

   278

	for(;;) {

   279

		int xb = x;

   280

		for(;;) {

   281

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

   282

			while (veh != INVALID_VEHICLE) {

   283

				Vehicle *v = GetVehicle(veh);

   284

				void *a;

   285

   286

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

   287

					return a;

   288

				veh = v->next_hash;

   289

			}

   290

   291

			if (x == x2)

   292

				break;

   293

   294

			x = (x + 1) & 0x3F;

   295

		}

   296

		x = xb;

   297

   298

		if (y == y2)

   299

			break;

   300

   301

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

   302

	}

   303

	return NULL;

   304

}

   305

   306

   307

   308

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

   309

{

   310

	VehicleID *old_hash, *new_hash;

   311

	int old_x = v->left_coord;

   312

	int old_y = v->top_coord;

   313

	Vehicle *u;

   314

   315

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

   316

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

   317

   318

	if (old_hash == new_hash)

   319

		return;

   320

   321

	/* remove from hash table? */

   322

	if (old_hash != NULL) {

   323

		Vehicle *last = NULL;

   324

		int idx = *old_hash;

   325

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

   326

			idx = u->next_hash;

   327

			assert(idx != INVALID_VEHICLE);

   328

			last = u;

   329

		}

   330

   331

		if (last == NULL)

   332

			*old_hash = v->next_hash;

   333

		else

   334

			last->next_hash = v->next_hash;

   335

	}

   336

   337

	/* insert into hash table? */

   338

	if (new_hash != NULL) {

   339

		v->next_hash = *new_hash;

   340

		*new_hash = v->index;

   341

	}

   342

}

   343

   344

void InitializeVehicles(void)

   345

{

   346

	int i;

   347

   348

	/* Clean the vehicle pool, and reserve enough blocks

   349

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

   350

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

   351

	CleanPool(&_vehicle_pool);

   352

	AddBlockToPool(&_vehicle_pool);

   353

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

   354

		AddBlockToPool(&_vehicle_pool);

   355

   356

	// clear it...

   357

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

   358

   359

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

   360

}

   361

   362

Vehicle *GetLastVehicleInChain(Vehicle *v)

   363

{

   364

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

   365

	return v;

   366

}

   367

   368

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   369

{

   370

	Vehicle *org = v;

   371

   372

	FOR_ALL_VEHICLES(v) {

   373

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

   374

			return v;

   375

	}

   376

   377

	return NULL;

   378

}

   379

   380

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   381

{

   382

	Vehicle *u;

   383

   384

	while (true) {

   385

		u = v;

   386

		v = GetPrevVehicleInChain(v);

   387

		/* If there is no such vehicle,

   388

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

   389

		if (v == NULL)

   390

			return u;

   391

	}

   392

}

   393

   394

int CountVehiclesInChain(Vehicle *v)

   395

{

   396

	int count = 0;

   397

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

   398

	return count;

   399

}

   400

   401

Waypoint *AllocateWaypoint(void)

   402

{

   403

	Waypoint *cp;

   404

   405

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

   406

		if (cp->xy == 0)

   407

			return cp;

   408

	}

   409

   410

	return NULL;

   411

}

   412

   413

uint GetWaypointByTile(uint tile)

   414

{

   415

	Waypoint *cp;

   416

	int i=0;

   417

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

   418

	return i;

   419

}

   420

   421

void DeleteVehicle(Vehicle *v)

   422

{

   423

	DeleteName(v->string_id);

   424

	v->type = 0;

   425

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   426

	v->next_hash = 0xffff;

   427

   428

	if (v->orders != NULL)

   429

		DeleteVehicleOrders(v);

   430

}

   431

   432

void DeleteVehicleChain(Vehicle *v)

   433

{

   434

	do {

   435

		Vehicle *u = v;

   436

		v = v->next;

   437

		DeleteVehicle(u);

   438

	} while (v);

   439

}

   440

   441

   442

void Aircraft_Tick(Vehicle *v);

   443

void RoadVeh_Tick(Vehicle *v);

   444

void Ship_Tick(Vehicle *v);

   445

void Train_Tick(Vehicle *v);

   446

static void EffectVehicle_Tick(Vehicle *v);

   447

void DisasterVehicle_Tick(Vehicle *v);

   448

   449

VehicleTickProc *_vehicle_tick_procs[] = {

   450

	Train_Tick,

   451

	RoadVeh_Tick,

   452

	Ship_Tick,

   453

	Aircraft_Tick,

   454

	EffectVehicle_Tick,

   455

	DisasterVehicle_Tick,

   456

};

   457

   458

void CallVehicleTicks(void)

   459

{

   460

	Vehicle *v;

   461

   462

	FOR_ALL_VEHICLES(v) {

   463

		if (v->type != 0)

   464

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

   465

	}

   466

}

   467

   468

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   469

{

   470

	uint32 full = 0, not_full = 0;

   471

   472

	//special handling of aircraft

   473

   474

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

   475

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

   476

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

   477

		return true;

   478

	}

   479

   480

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

   481

	do {

   482

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

   483

		assert(v->cargo_type<32);

   484

   485

		if (v->cargo_cap != 0) {

   486

			uint32 mask = 1 << v->cargo_type;

   487

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

   488

		}

   489

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

   490

   491

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

   492

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

   493

}

   494

   495

bool CanFillVehicle(Vehicle *v)

   496

{

   497

	TileIndex tile = v->tile;

   498

   499

	if (IsTileType(tile, MP_STATION) ||

   500

			(v->type == VEH_Ship && (

   501

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

   502

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

   503

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

   504

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

   505

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

   506

			))) {

   507

   508

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