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

#include "debug.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 *FindVehicleOnTileZ(TileIndex tile, byte z)

   121

{

   122

	TileInfo ti;

   123

   124

	ti.tile = tile;

   125

	ti.z = z;

   126

   127

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   128

}

   129

   130

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

   131

{

   132

	int x1 = TileX(from);

   133

	int y1 = TileY(from);

   134

	int x2 = TileX(to);

   135

	int y2 = TileY(to);

   136

	Vehicle *veh;

   137

   138

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

   139

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

   140

		intswap(x1,x2);

   141

		intswap(y1,y2);

   142

	}

   143

	FOR_ALL_VEHICLES(veh) {

   144

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

   145

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

   146

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

   147

				return veh;

   148

			}

   149

		}

   150

	}

   151

	return NULL;

   152

}

   153

   154

void VehiclePositionChanged(Vehicle *v)

   155

{

   156

	int img = v->cur_image;

   157

	const SpriteDimension *sd;

   158

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

   159

   160

	sd = GetSpriteDimension(img);

   161

   162

	pt.x += sd->xoffs;

   163

	pt.y += sd->yoffs;

   164

   165

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

   166

   167

	v->left_coord = pt.x;

   168

	v->top_coord = pt.y;

   169

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

   170

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

   171

}

   172

   173

// Called after load to update coordinates

   174

void AfterLoadVehicles(void)

   175

{

   176

	Vehicle *v;

   177

   178

	FOR_ALL_VEHICLES(v) {

   179

		v->first = NULL;

   180

		if (v->type != 0) {

   181

			v->left_coord = INVALID_COORD;

   182

			VehiclePositionChanged(v);

   183

   184

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

   185

				if (v->subtype == TS_Front_Engine)

   186

					UpdateTrainAcceleration(v);

   187

			}

   188

		}

   189

	}

   190

}

   191

   192

static Vehicle *InitializeVehicle(Vehicle *v)

   193

{

   194

	VehicleID index = v->index;

   195

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

   196

	v->index = index;

   197

   198

	assert(v->orders == NULL);

   199

   200

	v->left_coord = INVALID_COORD;

   201

	v->first = NULL;

   202

	v->next = NULL;

   203

	v->next_hash = 0xffff;

   204

	v->string_id = 0;

   205

	v->next_shared = NULL;

   206

	v->prev_shared = NULL;

   207

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

   208

	    which are technical the same (newgrf stuff).

   209

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

   210

	    not really matter that one client has other visual vehicles than

   211

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

   212

	*/

   213

	v->random_bits = InteractiveRandomRange(256);

   214

	return v;

   215

}

   216

   217

Vehicle *ForceAllocateSpecialVehicle(void)

   218

{

   219

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

   220

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

   221

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

   222

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   223

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

   224

   225

	Vehicle *v;

   226

   227

	FOR_ALL_VEHICLES(v) {

   228

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

   229

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

   230

			return NULL;

   231

   232

		if (v->type == 0)

   233

			return InitializeVehicle(v);

   234

	}

   235

   236

	return NULL;

   237

}

   238

   239

Vehicle *AllocateVehicle(void)

   240

{

   241

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

   242

	 * first blocks */

   243

	Vehicle *v;

   244

   245

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

   246

		if (v->type == 0)

   247

			return InitializeVehicle(v);

   248

	}

   249

   250

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

   251

	if (AddBlockToPool(&_vehicle_pool))

   252

		return AllocateVehicle();

   253

   254

	return NULL;

   255

}

   256

   257

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

   258

{

   259

	int x,y,x2,y2;

   260

	VehicleID veh;

   261

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

   262

   263

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

   264

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

   265

   266

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

   267

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

   268

   269

	for(;;) {

   270

		int xb = x;

   271

		for(;;) {

   272

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

   273

			while (veh != INVALID_VEHICLE) {

   274

				Vehicle *v = GetVehicle(veh);

   275

				void *a;

   276

   277

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

   278

					return a;

   279

				veh = v->next_hash;

   280

			}

   281

   282

			if (x == x2)

   283

				break;

   284

   285

			x = (x + 1) & 0x3F;

   286

		}

   287

		x = xb;

   288

   289

		if (y == y2)

   290

			break;

   291

   292

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

   293

	}

   294

	return NULL;

   295

}

   296

   297

   298

   299

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

   300

{

   301

	VehicleID *old_hash, *new_hash;

   302

	int old_x = v->left_coord;

   303

	int old_y = v->top_coord;

   304

	Vehicle *u;

   305

   306

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

   307

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

   308

   309

	if (old_hash == new_hash)

   310

		return;

   311

   312

	/* remove from hash table? */

   313

	if (old_hash != NULL) {

   314

		Vehicle *last = NULL;

   315

		int idx = *old_hash;

   316

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

   317

			idx = u->next_hash;

   318

			assert(idx != INVALID_VEHICLE);

   319

			last = u;

   320

		}

   321

   322

		if (last == NULL)

   323

			*old_hash = v->next_hash;

   324

		else

   325

			last->next_hash = v->next_hash;

   326

	}

   327

   328

	/* insert into hash table? */

   329

	if (new_hash != NULL) {

   330

		v->next_hash = *new_hash;

   331

		*new_hash = v->index;

   332

	}

   333

}

   334

   335

void InitializeVehicles(void)

   336

{

   337

	int i;

   338

   339

	/* Clean the vehicle pool, and reserve enough blocks

   340

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

   341

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

   342

	CleanPool(&_vehicle_pool);

   343

	AddBlockToPool(&_vehicle_pool);

   344

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

   345

		AddBlockToPool(&_vehicle_pool);

   346

   347

	// clear it...

   348

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

   349

}

   350

   351

Vehicle *GetLastVehicleInChain(Vehicle *v)

   352

{

   353

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

   354

	return v;

   355

}

   356

   357

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   358

{

   359

	Vehicle *u;

   360

   361

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

   362

   363

	return NULL;

   364

}

   365

   366

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   367

{

   368

	Vehicle* u;

   369

   370

	if (v->first != NULL) {

   371

		if (v->first->subtype == TS_Front_Engine) {

   372

			return v->first;

   373

		} else {

   374

			DEBUG(misc, 0) ("v->first cache faulty. We shouldn't be here");

   375

		}

   376

	}

   377

   378

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

   379

   380

	if (v->subtype == TS_Front_Engine)

   381

		for (u = (Vehicle *)v; u != NULL; u = u->next) u->first = (Vehicle *)v;

   382

   383

	return (Vehicle*)v;

   384

}

   385

   386

int CountVehiclesInChain(Vehicle *v)

   387

{

   388

	int count = 0;

   389

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

   390

	return count;

   391

}

   392

   393

void DeleteVehicle(Vehicle *v)

   394

{

   395

	DeleteName(v->string_id);

   396

	v->type = 0;

   397

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   398

	v->next_hash = 0xffff;

   399

   400

	if (v->orders != NULL)

   401

		DeleteVehicleOrders(v);

   402

}

   403

   404

void DeleteVehicleChain(Vehicle *v)

   405

{

   406

	do {

   407

		Vehicle *u = v;

   408

		v = v->next;

   409

		DeleteVehicle(u);

   410

	} while (v);

   411

}

   412

   413

   414

void Aircraft_Tick(Vehicle *v);

   415

void RoadVeh_Tick(Vehicle *v);

   416

void Ship_Tick(Vehicle *v);

   417

void Train_Tick(Vehicle *v);

   418

static void EffectVehicle_Tick(Vehicle *v);

   419

void DisasterVehicle_Tick(Vehicle *v);

   420

   421

VehicleTickProc *_vehicle_tick_procs[] = {

   422

	Train_Tick,

   423

	RoadVeh_Tick,

   424

	Ship_Tick,

   425

	Aircraft_Tick,

   426

	EffectVehicle_Tick,

   427

	DisasterVehicle_Tick,

   428

};

   429

   430

void CallVehicleTicks(void)

   431

{

   432

	Vehicle *v;

   433

   434

	FOR_ALL_VEHICLES(v) {

   435

		if (v->type != 0)

   436

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

   437

	}

   438

}

   439

   440

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   441

{

   442

	uint32 full = 0, not_full = 0;

   443

   444

	//special handling of aircraft

   445

   446

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

   447

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

   448

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

   449

		return true;

   450

	}

   451

   452

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

   453

	do {

   454

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

   455

		assert(v->cargo_type<32);

   456

   457

		if (v->cargo_cap != 0) {

   458

			uint32 mask = 1 << v->cargo_type;

   459

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

   460

		}

   461

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

   462

   463

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

   464

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

   465

}

   466

   467

bool CanFillVehicle(Vehicle *v)

   468

{

   469

	TileIndex tile = v->tile;

   470

   471

	if (IsTileType(tile, MP_STATION) ||

   472

			(v->type == VEH_Ship && (

   473

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

   474

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

   475

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

   476

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

   477

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

   478

			))) {

   479

   480

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

   481

		if (_patches.full_load_any)

   482

			return CanFillVehicle_FullLoadAny(v);

   483

   484

		do {

   485

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

   486

				return true;

   487

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

   488

	}

   489

	return false;

   490

}

   491

   492

static void DoDrawVehicle(Vehicle *v)

   493

{

   494

	uint32 image = v->cur_image;

   495

   496

	if (v->vehstatus & VS_DISASTER) {

   497

		image |= 0x3224000;

   498

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

   499

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

   500

	}

   501

   502

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

   503

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

   504

}

   505

   506

void ViewportAddVehicles(DrawPixelInfo *dpi)

   507

{

   508

	int x,xb, y, x2, y2;