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

// Called after load to update coordinates

   163

void AfterLoadVehicles(void)

   164

{

   165

	Vehicle *v;

   166

   167

	FOR_ALL_VEHICLES(v) {

   168

		if (v->type != 0) {

   169

			v->left_coord = INVALID_COORD;

   170

			VehiclePositionChanged(v);

   171

   172

			if (!_patches.realistic_acceleration && v->type == VEH_Train) {

   173

				if (v->subtype == TS_Front_Engine)

   174

					UpdateTrainAcceleration(v);

   175

			}

   176

		}

   177

	}

   178

}

   179

   180

static Vehicle *InitializeVehicle(Vehicle *v)

   181

{

   182

	VehicleID index = v->index;

   183

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

   184

	v->index = index;

   185

   186

	assert(v->orders == NULL);

   187

   188

	v->left_coord = INVALID_COORD;

   189

	v->next = NULL;

   190

	v->next_hash = 0xffff;

   191

	v->string_id = 0;

   192

	v->next_shared = NULL;

   193

	v->prev_shared = NULL;

   194

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

   195

	    which are technical the same (newgrf stuff).

   196

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

   197

	    not really matter that one client has other visual vehicles than

   198

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

   199

	*/

   200

	v->random_bits = InteractiveRandomRange(256);

   201

	return v;

   202

}

   203

   204

Vehicle *ForceAllocateSpecialVehicle(void)

   205

{

   206

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

   207

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

   208

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

   209

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   210

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

   211

   212

	Vehicle *v;

   213

   214

	FOR_ALL_VEHICLES(v) {

   215

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

   216

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

   217

			return NULL;

   218

   219

		if (v->type == 0)

   220

			return InitializeVehicle(v);

   221

	}

   222

   223

	return NULL;

   224

}

   225

   226

Vehicle *AllocateVehicle(void)

   227

{

   228

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

   229

	 * first blocks */

   230

	Vehicle *v;

   231

   232

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

   233

		if (v->type == 0)

   234

			return InitializeVehicle(v);

   235

	}

   236

   237

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

   238

	if (AddBlockToPool(&_vehicle_pool))

   239

		return AllocateVehicle();

   240

   241

	return NULL;

   242

}

   243

   244

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

   245

{

   246

	int x,y,x2,y2;

   247

	VehicleID veh;

   248

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

   249

   250

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

   251

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

   252

   253

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

   254

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

   255

   256

	for(;;) {

   257

		int xb = x;

   258

		for(;;) {

   259

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

   260

			while (veh != INVALID_VEHICLE) {

   261

				Vehicle *v = GetVehicle(veh);

   262

				void *a;

   263

   264

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

   265

					return a;

   266

				veh = v->next_hash;

   267

			}

   268

   269

			if (x == x2)

   270

				break;

   271

   272

			x = (x + 1) & 0x3F;

   273

		}

   274

		x = xb;

   275

   276

		if (y == y2)

   277

			break;

   278

   279

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

   280

	}

   281

	return NULL;

   282

}

   283

   284

   285

   286

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

   287

{

   288

	VehicleID *old_hash, *new_hash;

   289

	int old_x = v->left_coord;

   290

	int old_y = v->top_coord;

   291

	Vehicle *u;

   292

   293

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

   294

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

   295

   296

	if (old_hash == new_hash)

   297

		return;

   298

   299

	/* remove from hash table? */

   300

	if (old_hash != NULL) {

   301

		Vehicle *last = NULL;

   302

		int idx = *old_hash;

   303

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

   304

			idx = u->next_hash;

   305

			assert(idx != INVALID_VEHICLE);

   306

			last = u;

   307

		}

   308

   309

		if (last == NULL)

   310

			*old_hash = v->next_hash;

   311

		else

   312

			last->next_hash = v->next_hash;

   313

	}

   314

   315

	/* insert into hash table? */

   316

	if (new_hash != NULL) {

   317

		v->next_hash = *new_hash;

   318

		*new_hash = v->index;

   319

	}

   320

}

   321

   322

void InitializeVehicles(void)

   323

{

   324

	int i;

   325

   326

	/* Clean the vehicle pool, and reserve enough blocks

   327

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

   328

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

   329

	CleanPool(&_vehicle_pool);

   330

	AddBlockToPool(&_vehicle_pool);

   331

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

   332

		AddBlockToPool(&_vehicle_pool);

   333

   334

	// clear it...

   335

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

   336

}

   337

   338

Vehicle *GetLastVehicleInChain(Vehicle *v)

   339

{

   340

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

   341

	return v;

   342

}

   343

   344

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   345

{

   346

	const Vehicle *org = v;

   347

   348

	FOR_ALL_VEHICLES(v) {

   349

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

   350

			return (Vehicle*)v;

   351

	}

   352

   353

	return NULL;

   354

}

   355

   356

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   357

{

   358

	while (true) {

   359

		const Vehicle* u = v;

   360

   361

		v = GetPrevVehicleInChain(v);

   362

		/* If there is no such vehicle,

   363

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

   364

		if (v == NULL)

   365

			return (Vehicle*)u;

   366

	}

   367

}

   368

   369

int CountVehiclesInChain(Vehicle *v)

   370

{

   371

	int count = 0;

   372

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

   373

	return count;

   374

}

   375

   376

void DeleteVehicle(Vehicle *v)

   377

{

   378

	DeleteName(v->string_id);

   379

	v->type = 0;

   380

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   381

	v->next_hash = 0xffff;

   382

   383

	if (v->orders != NULL)

   384

		DeleteVehicleOrders(v);

   385

}

   386

   387

void DeleteVehicleChain(Vehicle *v)

   388

{

   389

	do {

   390

		Vehicle *u = v;

   391

		v = v->next;

   392

		DeleteVehicle(u);

   393

	} while (v);

   394

}

   395

   396

   397

void Aircraft_Tick(Vehicle *v);

   398

void RoadVeh_Tick(Vehicle *v);

   399

void Ship_Tick(Vehicle *v);

   400

void Train_Tick(Vehicle *v);

   401

static void EffectVehicle_Tick(Vehicle *v);

   402

void DisasterVehicle_Tick(Vehicle *v);

   403

   404

VehicleTickProc *_vehicle_tick_procs[] = {

   405

	Train_Tick,

   406

	RoadVeh_Tick,

   407

	Ship_Tick,

   408

	Aircraft_Tick,

   409

	EffectVehicle_Tick,

   410

	DisasterVehicle_Tick,

   411

};

   412

   413

void CallVehicleTicks(void)

   414

{

   415

	Vehicle *v;

   416

   417

	FOR_ALL_VEHICLES(v) {

   418

		if (v->type != 0)

   419

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

   420

	}

   421

}

   422

   423

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   424

{

   425

	uint32 full = 0, not_full = 0;

   426

   427

	//special handling of aircraft

   428

   429

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

   430

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

   431

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

   432

		return true;

   433

	}

   434

   435

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

   436

	do {

   437

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

   438

		assert(v->cargo_type<32);

   439

   440

		if (v->cargo_cap != 0) {

   441

			uint32 mask = 1 << v->cargo_type;

   442

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

   443

		}

   444

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

   445

   446

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

   447

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

   448

}

   449

   450

bool CanFillVehicle(Vehicle *v)

   451

{

   452

	TileIndex tile = v->tile;

   453

   454

	if (IsTileType(tile, MP_STATION) ||

   455

			(v->type == VEH_Ship && (

   456

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

   457

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

   458

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

   459

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

   460

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

   461

			))) {

   462

   463

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

   464

		if (_patches.full_load_any)

   465

			return CanFillVehicle_FullLoadAny(v);

   466

   467

		do {

   468

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

   469

				return true;

   470

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

   471

	}

   472

	return false;

   473

}

   474

   475

static void DoDrawVehicle(Vehicle *v)

   476

{

   477

	uint32 image = v->cur_image;

   478

   479

	if (v->vehstatus & VS_DISASTER) {

   480

		image |= 0x3224000;

   481

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

   482

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

   483

	}

   484

   485

	AddSortableSpriteToDraw(image, v->x_pos + v->x_offs, v->y_pos + v->y_offs,

   486

		v->sprite_width, v->sprite_height, v->z_height, v->z_pos);

   487

}

   488

   489

void ViewportAddVehicles(DrawPixelInfo *dpi)

   490

{

   491

	int x,xb, y, x2, y2;

   492

	VehicleID veh;

   493

	Vehicle *v;

   494

   495

	x  = ((dpi->left - 70) & 0x1F80) >> 7;

   496

	x2 = ((dpi->left + dpi->width) & 0x1F80) >> 7;

   497

   498

	y  = ((dpi->top - 70) & 0xFC0);

   499

	y2 = ((dpi->top + dpi->height) & 0xFC0);

   500

   501

	for(;;) {

   502

		xb = x;

   503

		for(;;) {

   504

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

   505

			while (veh != INVALID_VEHICLE) {

   506

				v = GetVehicle(veh);

   507

   508

				if (!(v->vehstatus & VS_HIDDEN) &&

   509

						dpi->left <= v->right_coord &&