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

{

   347

   349

   350

	return NULL;

   351

}

   352

   353

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   354

{

   356

   360

}

   361

   362

int CountVehiclesInChain(Vehicle *v)

   363

{

   364

	int count = 0;

   365

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

   366

	return count;

   367

}

   368

   369

void DeleteVehicle(Vehicle *v)

   370

{

   371

	DeleteName(v->string_id);

   372

	v->type = 0;

   373

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   374

	v->next_hash = 0xffff;

   375

   376

	if (v->orders != NULL)

   377

		DeleteVehicleOrders(v);

   378

}

   379

   380

void DeleteVehicleChain(Vehicle *v)

   381

{

   382

	do {

   383

		Vehicle *u = v;

   384

		v = v->next;

   385

		DeleteVehicle(u);

   386

	} while (v);

   387

}

   388

   389

   390

void Aircraft_Tick(Vehicle *v);

   391

void RoadVeh_Tick(Vehicle *v);

   392

void Ship_Tick(Vehicle *v);

   393

void Train_Tick(Vehicle *v);

   394

static void EffectVehicle_Tick(Vehicle *v);

   395

void DisasterVehicle_Tick(Vehicle *v);

   396

   397

VehicleTickProc *_vehicle_tick_procs[] = {

   398

	Train_Tick,

   399

	RoadVeh_Tick,

   400

	Ship_Tick,

   401

	Aircraft_Tick,

   402

	EffectVehicle_Tick,

   403

	DisasterVehicle_Tick,

   404

};

   405

   406

void CallVehicleTicks(void)

   407

{

   408

	Vehicle *v;

   409

   410

	FOR_ALL_VEHICLES(v) {

   411

		if (v->type != 0)

   412

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

   413

	}

   414

}

   415

   416

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   417

{

   418

	uint32 full = 0, not_full = 0;

   419

   420

	//special handling of aircraft

   421

   422

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

   423

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

   424

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

   425

		return true;

   426

	}

   427

   428

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

   429

	do {

   430

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

   431

		assert(v->cargo_type<32);

   432

   433

		if (v->cargo_cap != 0) {

   434

			uint32 mask = 1 << v->cargo_type;

   435

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

   436

		}

   437

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

   438

   439

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

   440

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

   441

}

   442

   443

bool CanFillVehicle(Vehicle *v)

   444

{

   445

	TileIndex tile = v->tile;

   446

   447

	if (IsTileType(tile, MP_STATION) ||

   448

			(v->type == VEH_Ship && (

   449

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

   450

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

   451

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

   452

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

   453

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

   454

			))) {

   455

   456

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

   457

		if (_patches.full_load_any)

   458

			return CanFillVehicle_FullLoadAny(v);

   459

   460

		do {

   461

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

   462

				return true;

   463

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

   464

	}

   465

	return false;

   466

}

   467

   468

static void DoDrawVehicle(Vehicle *v)

   469

{

   470

	uint32 image = v->cur_image;

   471

   472

	if (v->vehstatus & VS_DISASTER) {

   473

		image |= 0x3224000;

   474

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

   475

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

   476

	}

   477

   478

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

   479

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

   480

}

   481

   482

void ViewportAddVehicles(DrawPixelInfo *dpi)

   483

{

   484

	int x,xb, y, x2, y2;

   485

	VehicleID veh;

   486

	Vehicle *v;

   487

   488

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

   489

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

   490

   491

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

   492

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

   493

   494

	for(;;) {

   495

		xb = x;

   496

		for(;;) {

   497

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

   498

			while (veh != INVALID_VEHICLE) {

   499

				v = GetVehicle(veh);

   500

   501

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

   502

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

   503

						dpi->top <= v->bottom_coord &&

   504

						dpi->left + dpi->width >= v->left_coord &&

   505

						dpi->top + dpi->height >= v->top_coord) {

   506

					DoDrawVehicle(v);

   507

				}

   508

				veh = v->next_hash;

   509

			}

   510