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"

    20

    21

#define INVALID_COORD (-0x8000)

    22

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

    23

    24

enum {

    25

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

    26

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

    27

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    28

    29

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

    30

};

    31

    32

/**

    33

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

    34

 */

    35

static void VehiclePoolNewBlock(uint start_item)

    36

{

    37

	Vehicle *v;

    38

    39

	FOR_ALL_VEHICLES_FROM(v, start_item)

    40

		v->index = start_item++;

    41

}

    42

    43

/* Initialize the vehicle-pool */

    44

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

    45

    46

void VehicleServiceInDepot(Vehicle *v)

    47

{

    48

	v->date_of_last_service = _date;

    49

	v->breakdowns_since_last_service = 0;

    50

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

    51

}

    52

    53

bool VehicleNeedsService(const Vehicle *v)

    54

{

    55

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

    56

		return false;

    57

    58

	return _patches.servint_ispercent ?

    59

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

    60

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

    61

}

    62

    63

void VehicleInTheWayErrMsg(Vehicle *v)

    64

{

    65

	StringID id;

    66

    67

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

    68

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

    69

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

    70

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    71

    72

	_error_message = id;

    73

}

    74

    75

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

    76

{

    77

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

    78

		return NULL;

    79

    80

	VehicleInTheWayErrMsg(v);

    81

	return v;

    82

}

    83

    84

bool EnsureNoVehicle(TileIndex tile)

    85

{

    86

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

    87

}

    88

    89

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

    90

{

    91

	const TileInfo *ti = data;

    92

    93

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

    94

		return NULL;

    95

    96

	VehicleInTheWayErrMsg(v);

    97

	return v;

    98

}

    99

   100

static inline uint Correct_Z(uint tileh)

   101

{

   102

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

   103

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

   104

	return CorrectZ(tileh) ? 8 : 0;

   105

}

   106

   107

uint GetCorrectTileHeight(TileIndex tile)

   108

{

   109

	return Correct_Z(GetTileSlope(tile, NULL));

   110

}

   111

   112

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   113

{

   114

	TileInfo ti;

   115

   116

	FindLandscapeHeightByTile(&ti, tile);

   117

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

   118

   119

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

   120

}

   121

   122

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)

   123

{

   124

	TileInfo ti;

   125

   126

	ti.tile = tile;

   127

	ti.z = z;

   128

   129

	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);

   130

}

   131

   132

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

   133

{

   134

	int x1 = TileX(from);

   135

	int y1 = TileY(from);

   136

	int x2 = TileX(to);

   137

	int y2 = TileY(to);

   138

	Vehicle *veh;

   139

   140

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

   141

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

   142

		intswap(x1,x2);

   143

		intswap(y1,y2);

   144

	}

   145

	FOR_ALL_VEHICLES(veh) {

   146

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

   147

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

   148

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

   149

				return veh;

   150

			}

   151

		}

   152

	}

   153

	return NULL;

   154

}

   155

   156

void VehiclePositionChanged(Vehicle *v)

   157

{

   158

	int img = v->cur_image;

   159

	const SpriteDimension *sd;

   160

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

   161

   162

	sd = GetSpriteDimension(img);

   163

   164

	pt.x += sd->xoffs;

   165

	pt.y += sd->yoffs;

   166

   167

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

   168

   169

	v->left_coord = pt.x;

   170

	v->top_coord = pt.y;

   171

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

   172

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

   173

}

   174

   175

// Called after load to update coordinates

   176

void AfterLoadVehicles(void)

   177

{

   178

	Vehicle *v;

   179

   180

	FOR_ALL_VEHICLES(v) {

   181

		v->first = NULL;

   182

		if (v->type != 0) {

   183

			v->left_coord = INVALID_COORD;

   184

			VehiclePositionChanged(v);

   185

   186

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

   187

				if (v->subtype == TS_Front_Engine)

   188

					UpdateTrainAcceleration(v);

   189

			}

   190

		}

   191

	}

   192

}

   193

   194

static Vehicle *InitializeVehicle(Vehicle *v)

   195

{

   196

	VehicleID index = v->index;

   197

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

   198

	v->index = index;

   199

   200

	assert(v->orders == NULL);

   201

   202

	v->left_coord = INVALID_COORD;

   203

	v->first = NULL;

   204

	v->next = NULL;

   205

	v->next_hash = 0xffff;

   206

	v->string_id = 0;

   207

	v->next_shared = NULL;

   208

	v->prev_shared = NULL;

   209

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

   210

	    which are technical the same (newgrf stuff).

   211

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

   212

	    not really matter that one client has other visual vehicles than

   213

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

   214

	*/

   215

	v->random_bits = InteractiveRandomRange(256);

   216

	return v;

   217

}

   218

   219

Vehicle *ForceAllocateSpecialVehicle(void)

   220

{

   221

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

   222

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

   223

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

   224

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   225

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

   226

   227

	Vehicle *v;

   228

   229

	FOR_ALL_VEHICLES(v) {

   230

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

   231

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

   232

			return NULL;

   233

   234

		if (v->type == 0)

   235

			return InitializeVehicle(v);

   236

	}

   237

   238

	return NULL;

   239

}

   240

   241

Vehicle *AllocateVehicle(void)

   242

{

   243

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

   244

	 * first blocks */

   245

	Vehicle *v;

   246

   247

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

   248

		if (v->type == 0)

   249

			return InitializeVehicle(v);

   250

	}

   251

   252

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

   253

	if (AddBlockToPool(&_vehicle_pool))

   254

		return AllocateVehicle();

   255

   256

	return NULL;

   257

}

   258

   259

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

   260

{

   261

	int x,y,x2,y2;

   262

	VehicleID veh;

   263

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

   264

   265

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

   266

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

   267

   268

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

   269

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

   270

   271

	for(;;) {

   272

		int xb = x;

   273

		for(;;) {

   274

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

   275

			while (veh != INVALID_VEHICLE) {

   276

				Vehicle *v = GetVehicle(veh);

   277

				void *a;

   278

   279

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

   280

					return a;

   281

				veh = v->next_hash;

   282

			}

   283

   284

			if (x == x2)

   285

				break;

   286

   287

			x = (x + 1) & 0x3F;

   288

		}

   289

		x = xb;

   290

   291

		if (y == y2)

   292

			break;

   293

   294

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

   295

	}

   296

	return NULL;

   297

}

   298

   299

   300

   301

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

   302

{

   303

	VehicleID *old_hash, *new_hash;

   304

	int old_x = v->left_coord;

   305

	int old_y = v->top_coord;

   306

	Vehicle *u;

   307

   308

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

   309

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

   310

   311

	if (old_hash == new_hash)

   312

		return;

   313

   314

	/* remove from hash table? */

   315

	if (old_hash != NULL) {

   316

		Vehicle *last = NULL;

   317

		int idx = *old_hash;

   318

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

   319

			idx = u->next_hash;

   320

			assert(idx != INVALID_VEHICLE);

   321

			last = u;

   322

		}

   323

   324

		if (last == NULL)

   325

			*old_hash = v->next_hash;

   326

		else

   327

			last->next_hash = v->next_hash;

   328

	}

   329

   330

	/* insert into hash table? */

   331

	if (new_hash != NULL) {

   332

		v->next_hash = *new_hash;

   333

		*new_hash = v->index;

   334

	}

   335

}

   336

   337

void InitializeVehicles(void)

   338

{

   339

	int i;

   340

   341

	/* Clean the vehicle pool, and reserve enough blocks

   342

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

   343

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

   344

	CleanPool(&_vehicle_pool);

   345

	AddBlockToPool(&_vehicle_pool);

   346

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

   347

		AddBlockToPool(&_vehicle_pool);

   348

   349

	// clear it...

   350

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

   351

}

   352

   353

Vehicle *GetLastVehicleInChain(Vehicle *v)

   354

{

   355

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

   356

	return v;

   357

}

   358

   359

Vehicle *GetPrevVehicleInChain(const Vehicle *v)

   360

{

   361

	Vehicle *u;

   362

   363

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

   364

   365

	return NULL;

   366

}

   367

   368

Vehicle *GetFirstVehicleInChain(const Vehicle *v)

   369

{

   370

	Vehicle* u;

   371

   372

	if (v->first != NULL) {

   373

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

   374

			return v->first;

   375

		} else {

   376

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

   377

		}

   378

	}

   379

   380

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

   381

   382

	if (v->subtype == TS_Front_Engine)

   383

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

   384

   385

	return (Vehicle*)v;

   386

}

   387

   388

int CountVehiclesInChain(Vehicle *v)

   389

{

   390

	int count = 0;

   391

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

   392

	return count;

   393

}

   394

   395

void DeleteVehicle(Vehicle *v)

   396

{

   397

	DeleteName(v->string_id);

   398

	v->type = 0;

   399

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   400

	v->next_hash = 0xffff;

   401

   402

	if (v->orders != NULL)

   403

		DeleteVehicleOrders(v);

   404

}

   405

   406

void DeleteVehicleChain(Vehicle *v)

   407

{

   408

	do {

   409

		Vehicle *u = v;

   410

		v = v->next;

   411

		DeleteVehicle(u);

   412

	} while (v);

   413

}

   414

   415

   416

void Aircraft_Tick(Vehicle *v);

   417

void RoadVeh_Tick(Vehicle *v);

   418

void Ship_Tick(Vehicle *v);

   419

void Train_Tick(Vehicle *v);

   420

static void EffectVehicle_Tick(Vehicle *v);

   421

void DisasterVehicle_Tick(Vehicle *v);

   422

   423

VehicleTickProc *_vehicle_tick_procs[] = {

   424

	Train_Tick,

   425

	RoadVeh_Tick,

   426

	Ship_Tick,

   427

	Aircraft_Tick,

   428

	EffectVehicle_Tick,

   429

	DisasterVehicle_Tick,

   430

};

   431

   432

void CallVehicleTicks(void)

   433

{

   434

	Vehicle *v;

   435

   436

	FOR_ALL_VEHICLES(v) {

   437

		if (v->type != 0)

   438

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

   439

	}

   440

}

   441

   442

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   443

{

   444

	uint32 full = 0, not_full = 0;

   445

   446

	//special handling of aircraft

   447

   448

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

   449

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

   450

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

   451

		return true;

   452

	}

   453

   454

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

   455

	do {

   456

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

   457

		assert(v->cargo_type<32);

   458

   459

		if (v->cargo_cap != 0) {

   460

			uint32 mask = 1 << v->cargo_type;

   461

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

   462

		}

   463

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

   464

   465

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

   466

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

   467

}

   468

   469

bool CanFillVehicle(Vehicle *v)

   470

{

   471

	TileIndex tile = v->tile;

   472

   473

	if (IsTileType(tile, MP_STATION) ||

   474

			(v->type == VEH_Ship && (

   475

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

   476

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

   477

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

   478

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

   479

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

   480

			))) {

   481

   482

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

   483

		if (_patches.full_load_any)

   484

			return CanFillVehicle_FullLoadAny(v);

   485

   486

		do {

   487

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

   488

				return true;

   489

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

   490

	}

   491

	return false;

   492

}

   493

   494

static void DoDrawVehicle(Vehicle *v)

   495

{

   496

	uint32 image = v->cur_image;

   497

   498

	if (v->vehstatus & VS_DISASTER) {

   499

		image |= 0x3224000;

   500

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

   501

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

   502

	}

   503

   504

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

   505

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

   506

}

   507

   508