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"

    18

    19

#define INVALID_COORD (-0x8000)

    20

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

    21

    22

enum {

    23

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

    24

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

    25

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    26

    27

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

    28

};

    29

    30

/**

    31

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

    32

 */

    33

static void VehiclePoolNewBlock(uint start_item)

    34

{

    35

	Vehicle *v;

    36

    37

	FOR_ALL_VEHICLES_FROM(v, start_item)

    38

		v->index = start_item++;

    39

}

    40

    41

/* Initialize the vehicle-pool */

    42

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

    43

    44

void VehicleServiceInDepot(Vehicle *v)

    45

{

    46

	v->date_of_last_service = _date;

    47

	v->breakdowns_since_last_service = 0;

    48

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

    49

}

    50

    51

bool VehicleNeedsService(const Vehicle *v)

    52

{

    53

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

    54

		return false;

    55

    56

	return _patches.servint_ispercent ?

    57

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

    58

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

    59

}

    60

    61

void VehicleInTheWayErrMsg(Vehicle *v)

    62

{

    63

	StringID id;

    64

    65

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

    66

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

    67

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

    68

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    69

    70

	_error_message = id;

    71

}

    72

    73

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

    74

{

    75

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

    76

		return NULL;

    77

    78

	VehicleInTheWayErrMsg(v);

    79

	return v;

    80

}

    81

    82

bool EnsureNoVehicle(TileIndex tile)

    83

{

    84

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

    85

}

    86

    87

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

    88

{

    89

	const TileInfo *ti = data;

    90

    91

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

    92

		return NULL;

    93

    94

	VehicleInTheWayErrMsg(v);

    95

	return v;

    96

}

    97

    98

static inline uint Correct_Z(uint tileh)

    99

{

   100

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

   101

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

   102

	return CorrectZ(tileh) ? 8 : 0;

   103

}

   104

   105

uint GetCorrectTileHeight(TileIndex tile)

   106

{

   107

	return Correct_Z(GetTileSlope(tile, NULL));

   108

}

   109

   110

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   111

{

   112

	TileInfo ti;

   113

   114

	FindLandscapeHeightByTile(&ti, tile);

   115

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

   116

   117

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

   118

}

   119

   120

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

   121

{

   122

	int x1 = TileX(from);

   123

	int y1 = TileY(from);

   124

	int x2 = TileX(to);

   125

	int y2 = TileY(to);

   126

	Vehicle *veh;

   127

   128

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

   129

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

   130

		intswap(x1,x2);

   131

		intswap(y1,y2);

   132

	}

   133

	FOR_ALL_VEHICLES(veh) {

   134

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

   135

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

   136

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

   137

				return veh;

   138

			}

   139

		}

   140

	}

   141

	return NULL;

   142

}

   143

   144

void VehiclePositionChanged(Vehicle *v)

   145

{

   146

	int img = v->cur_image;

   147

	const SpriteDimension *sd;

   148

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

   149

   150

	sd = GetSpriteDimension(img);

   151

   152

	pt.x += sd->xoffs;

   153

	pt.y += sd->yoffs;

   154

   155

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

   156

   157

	v->left_coord = pt.x;

   158

	v->top_coord = pt.y;

   159

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

   160

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

   161

}

   162

   163

// Called after load to update coordinates

   164

void AfterLoadVehicles(void)

   165

{

   166

	Vehicle *v;

   167

   168

	FOR_ALL_VEHICLES(v) {

   170

		if (v->type != 0) {

   171

			v->left_coord = INVALID_COORD;

   172

			VehiclePositionChanged(v);

   173

   174

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

   175

				if (v->subtype == TS_Front_Engine)

   176

					UpdateTrainAcceleration(v);

   177

			}

   178

		}

   179

	}

   180

}

   181

   182

static Vehicle *InitializeVehicle(Vehicle *v)

   183

{

   184

	VehicleID index = v->index;

   185

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

   186

	v->index = index;

   187

   188

	assert(v->orders == NULL);

   189

   190

	v->left_coord = INVALID_COORD;

   192

	v->next = NULL;

   193

	v->next_hash = 0xffff;

   194

	v->string_id = 0;

   195

	v->next_shared = NULL;

   196

	v->prev_shared = NULL;

   197

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

   198

	    which are technical the same (newgrf stuff).

   199

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

   200

	    not really matter that one client has other visual vehicles than

   201

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

   202

	*/

   203

	v->random_bits = InteractiveRandomRange(256);

   204

	return v;

   205

}

   206

   207

Vehicle *ForceAllocateSpecialVehicle(void)

   208

{

   209

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

   210

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

   211

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

   212

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   213

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

   214

   215

	Vehicle *v;

   216

   217

	FOR_ALL_VEHICLES(v) {

   218

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

   219

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

   220

			return NULL;

   221

   222

		if (v->type == 0)

   223

			return InitializeVehicle(v);

   224

	}

   225

   226

	return NULL;

   227

}

   228

   229

Vehicle *AllocateVehicle(void)

   230

{

   231

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

   232

	 * first blocks */

   233

	Vehicle *v;

   234

   235

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

   236

		if (v->type == 0)

   237

			return InitializeVehicle(v);

   238

	}

   239

   240

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

   241

	if (AddBlockToPool(&_vehicle_pool))

   242

		return AllocateVehicle();

   243

   244

	return NULL;

   245

}

   246

   247

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

   248

{

   249

	int x,y,x2,y2;

   250

	VehicleID veh;

   251

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

   252

   253

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

   254

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

   255

   256

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

   257

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

   258

   259

	for(;;) {

   260

		int xb = x;

   261

		for(;;) {

   262

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

   263

			while (veh != INVALID_VEHICLE) {

   264

				Vehicle *v = GetVehicle(veh);

   265

				void *a;

   266

   267

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

   268

					return a;

   269

				veh = v->next_hash;

   270

			}

   271

   272

			if (x == x2)

   273

				break;

   274

   275

			x = (x + 1) & 0x3F;

   276

		}

   277

		x = xb;

   278

   279

		if (y == y2)

   280

			break;

   281

   282

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

   283

	}

   284

	return NULL;

   285

}

   286

   287

   288

   289

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

   290

{

   291

	VehicleID *old_hash, *new_hash;

   292

	int old_x = v->left_coord;

   293

	int old_y = v->top_coord;

   294

	Vehicle *u;

   295

   296

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

   297

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

   298

   299

	if (old_hash == new_hash)

   300

		return;

   301

   302

	/* remove from hash table? */

   303

	if (old_hash != NULL) {

   304

		Vehicle *last = NULL;

   305

		int idx = *old_hash;

   306

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

   307

			idx = u->next_hash;

   308

			assert(idx != INVALID_VEHICLE);

   309

			last = u;

   310

		}

   311

   312

		if (last == NULL)

   313

			*old_hash = v->next_hash;

   314

		else

   315

			last->next_hash = v->next_hash;

   316

	}

   317

   318

	/* insert into hash table? */

   319

	if (new_hash != NULL) {

   320

		v->next_hash = *new_hash;

   321

		*new_hash = v->index;

   322

	}

   323

}

   324

   325

void InitializeVehicles(void)

   326

{

   327

	int i;

   328

   329

	/* Clean the vehicle pool, and reserve enough blocks

   330

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

   331

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

   332

	CleanPool(&_vehicle_pool);

   333

	AddBlockToPool(&_vehicle_pool);

   334

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

   335

		AddBlockToPool(&_vehicle_pool);

   336

   337

	// clear it...

   338

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

   339

}

   340

   341

Vehicle *GetLastVehicleInChain(Vehicle *v)

   342

{

   343

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

   344

	return v;

   345

}

   346

   347

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   348

{

   349

	Vehicle *u;

   350

   351

	FOR_ALL_VEHICLES(u) if (u->next == v) return u;

   352

   353

	return NULL;

   354

}

   355

   356

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   357

{

   367

   368

	while ((u = GetPrevVehicleInChain(v)) != NULL) v = u;

   369

   373

	return (Vehicle*)v;

   374

}

   375

   376

int CountVehiclesInChain(Vehicle *v)

   377

{

   378

	int count = 0;

   379

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

   380

	return count;

   381

}

   382

   383

void DeleteVehicle(Vehicle *v)

   384

{

   385

	DeleteName(v->string_id);

   386

	v->type = 0;

   387

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   388

	v->next_hash = 0xffff;

   389

   390

	if (v->orders != NULL)

   391

		DeleteVehicleOrders(v);

   392

}

   393

   394

void DeleteVehicleChain(Vehicle *v)

   395

{

   396

	do {

   397

		Vehicle *u = v;

   398

		v = v->next;

   399

		DeleteVehicle(u);

   400

	} while (v);

   401

}

   402

   403

   404

void Aircraft_Tick(Vehicle *v);

   405

void RoadVeh_Tick(Vehicle *v);

   406

void Ship_Tick(Vehicle *v);

   407

void Train_Tick(Vehicle *v);

   408

static void EffectVehicle_Tick(Vehicle *v);

   409

void DisasterVehicle_Tick(Vehicle *v);

   410

   411

VehicleTickProc *_vehicle_tick_procs[] = {

   412

	Train_Tick,

   413

	RoadVeh_Tick,

   414

	Ship_Tick,

   415

	Aircraft_Tick,

   416

	EffectVehicle_Tick,

   417

	DisasterVehicle_Tick,

   418

};

   419

   420

void CallVehicleTicks(void)

   421

{

   422

	Vehicle *v;

   423

   424

	FOR_ALL_VEHICLES(v) {

   425

		if (v->type != 0)

   426

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

   427

	}

   428

}

   429

   430

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   431

{

   432

	uint32 full = 0, not_full = 0;

   433

   434

	//special handling of aircraft

   435

   436

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

   437

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

   438

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

   439

		return true;

   440

	}

   441

   442

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

   443

	do {

   444

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

   445

		assert(v->cargo_type<32);

   446

   447

		if (v->cargo_cap != 0) {

   448

			uint32 mask = 1 << v->cargo_type;

   449

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

   450

		}

   451

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

   452

   453

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

   454

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

   455

}

   456

   457

bool CanFillVehicle(Vehicle *v)

   458

{

   459

	TileIndex tile = v->tile;

   460

   461

	if (IsTileType(tile, MP_STATION) ||

   462

			(v->type == VEH_Ship && (

   463

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

   464

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

   465

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

   466

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

   467

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

   468

			))) {

   469

   470

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

   471

		if (_patches.full_load_any)

   472

			return CanFillVehicle_FullLoadAny(v);

   473

   474

		do {

   475

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

   476

				return true;

   477

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

   478

	}

   479

	return false;

   480

}

   481

   482

static void DoDrawVehicle(Vehicle *v)

   483

{

   484

	uint32 image = v->cur_image;

   485

   486

	if (v->vehstatus & VS_DISASTER) {

   487

		image |= 0x3224000;

   488

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

   489

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

   490

	}

   491

   492

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

   493

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

   494

}

   495

   496

void ViewportAddVehicles(DrawPixelInfo *dpi)

   497

{

   498

	int x,xb, y, x2, y2;

   499

	VehicleID veh;

   500

	Vehicle *v;

   501

   502

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

   503

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

   504

   505

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

   506

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

   507

   508

	for(;;) {

   509

		xb = x;