1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "vehicle.h"

     7

#include "gfx.h"

     8

#include "viewport.h"

     9

#include "news.h"

    10

#include "command.h"

    11

#include "saveload.h"

    12

#include "player.h"

    13

#include "engine.h"

    14

#include "sound.h"

    15

    16

#define INVALID_COORD (-0x8000)

    17

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

    18

    19

enum {

    20

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

    21

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

    22

	VEHICLES_POOL_MAX_BLOCKS      = 125,

    23

    24

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

    25

};

    26

    27

/**

    28

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

    29

 */

    30

static void VehiclePoolNewBlock(uint start_item)

    31

{

    32

	Vehicle *v;

    33

    34

	FOR_ALL_VEHICLES_FROM(v, start_item)

    35

		v->index = start_item++;

    36

}

    37

    38

/* Initialize the vehicle-pool */

    39

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

    40

    41

void VehicleServiceInDepot(Vehicle *v)

    42

{

    43

	v->date_of_last_service = _date;

    44

	v->breakdowns_since_last_service = 0;

    45

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

    46

}

    47

    48

bool VehicleNeedsService(const Vehicle *v)

    49

{

    50

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

    51

		return false;

    52

    53

	return _patches.servint_ispercent ?

    54

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

    55

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

    56

}

    57

    58

void VehicleInTheWayErrMsg(Vehicle *v)

    59

{

    60

	StringID id;

    61

    62

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

    63

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

    64

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

    65

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    66

    67

	_error_message = id;

    68

}

    69

    70

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

    71

{

    72

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

    73

		return NULL;

    74

    75

	VehicleInTheWayErrMsg(v);

    76

	return v;

    77

}

    78

    79

bool EnsureNoVehicle(TileIndex tile)

    80

{

    81

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

    82

}

    83

    84

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

    85

{

    86

	const TileInfo *ti = data;

    87

    88

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

    89

		return NULL;

    90

    91

	VehicleInTheWayErrMsg(v);

    92

	return v;

    93

}

    94

    95

static inline uint Correct_Z(uint tileh)

    96

{

    97

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

    98

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

    99

	return (CORRECT_Z(tileh)) ? 8 : 0;

   100

}

   101

   102

uint GetCorrectTileHeight(TileIndex tile)

   103

{

   104

	return Correct_Z(GetTileSlope(tile, NULL));

   105

}

   106

   107

bool EnsureNoVehicleZ(TileIndex tile, byte z)

   108

{

   109

	TileInfo ti;

   110

   111

	FindLandscapeHeightByTile(&ti, tile);

   112

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

   113

   114

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

   115

}

   116

   117

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

   118

{

   119

	int x1 = TileX(from);

   120

	int y1 = TileY(from);

   121

	int x2 = TileX(to);

   122

	int y2 = TileY(to);

   123

	Vehicle *veh;

   124

   125

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

   126

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

   127

		intswap(x1,x2);

   128

		intswap(y1,y2);

   129

	}

   130

	FOR_ALL_VEHICLES(veh) {

   131

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

   132

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

   133

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

   134

				return veh;

   135

			}

   136

		}

   137

	}

   138

	return NULL;

   139

}

   140

   141

void VehiclePositionChanged(Vehicle *v)

   142

{

   143

	int img = v->cur_image;

   144

	const SpriteDimension *sd;

   145

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

   146

   147

	sd = GetSpriteDimension(img);

   148

   149

	pt.x += sd->xoffs;

   150

	pt.y += sd->yoffs;

   151

   152

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

   153

   154

	v->left_coord = pt.x;

   155

	v->top_coord = pt.y;

   156

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

   157

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

   158

}

   159

   160

void UpdateWaypointSign(Waypoint *cp)

   161

{

   162

	Point pt = RemapCoords2(TileX(cp->xy) * 16, TileY(cp->xy) * 16);

   163

	SetDParam(0, cp - _waypoints);

   164

	UpdateViewportSignPos(&cp->sign, pt.x, pt.y - 0x20, STR_WAYPOINT_VIEWPORT);

   165

}

   166

   167

void RedrawWaypointSign(Waypoint *cp)

   168

{

   169

	MarkAllViewportsDirty(

   170

		cp->sign.left - 6,

   171

		cp->sign.top,

   172

		cp->sign.left + (cp->sign.width_1 << 2) + 12,

   173

		cp->sign.top + 48);

   174

}

   175

   176

// Called after load to update coordinates

   177

void AfterLoadVehicles(void)

   178

{

   179

	Vehicle *v;

   180

	Waypoint *cp;

   181

   182

	FOR_ALL_VEHICLES(v) {

   183

		if (v->type != 0) {

   184

			v->left_coord = INVALID_COORD;

   185

			VehiclePositionChanged(v);

   186

   187

			if (v->type == VEH_Train) {

   188

				if (v->subtype == TS_Front_Engine)

   189

					UpdateTrainAcceleration(v);

   190

			}

   191

		}

   192

	}

   193

   194

	// update waypoint signs

   195

	for(cp=_waypoints; cp != endof(_waypoints); cp++) if (cp->xy) UpdateWaypointSign(cp);

   196

}

   197

   198

   199

static Vehicle *InitializeVehicle(Vehicle *v)

   200

{

   201

	VehicleID index = v->index;

   202

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

   203

	v->index = index;

   204

   205

	assert(v->orders == NULL);

   206

   207

	v->left_coord = INVALID_COORD;

   208

	v->next = NULL;

   209

	v->next_hash = 0xffff;

   210

	v->string_id = 0;

   211

	v->next_shared = NULL;

   212

	v->prev_shared = NULL;

   213

	v->set_for_replacement = false;

   214

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

   215

	    which are technical the same (newgrf stuff).

   216

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

   217

	    not really matter that one client has other visual vehicles than

   218

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

   219

	*/

   220

	v->random_bits = InteractiveRandomRange(256);

   221

	return v;

   222

}

   223

   224

Vehicle *ForceAllocateSpecialVehicle(void)

   225

{

   226

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

   227

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

   228

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

   229

	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only

   230

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

   231

   232

	Vehicle *v;

   233

   234

	FOR_ALL_VEHICLES(v) {

   235

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

   236

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

   237

			return NULL;

   238

   239

		if (v->type == 0)

   240

			return InitializeVehicle(v);

   241

	}

   242

   243

	return NULL;

   244

}

   245

   246

Vehicle *AllocateVehicle(void)

   247

{

   248

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

   249

	 * first blocks */

   250

	Vehicle *v;

   251

   252

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

   253

		if (v->type == 0)

   254

			return InitializeVehicle(v);

   255

	}

   256

   257

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

   258

	if (AddBlockToPool(&_vehicle_pool))

   259

		return AllocateVehicle();

   260

   261

	return NULL;

   262

}

   263

   264

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

   265

{

   266

	int x,y,x2,y2;

   267

	VehicleID veh;

   268

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

   269

   270

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

   271

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

   272

   273

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

   274

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

   275

   276

	for(;;) {

   277

		int xb = x;

   278

		for(;;) {

   279

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

   280

			while (veh != INVALID_VEHICLE) {

   281

				Vehicle *v = GetVehicle(veh);

   282

				void *a;

   283

   284

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

   285

					return a;

   286

				veh = v->next_hash;

   287

			}

   288

   289

			if (x == x2)

   290

				break;

   291

   292

			x = (x + 1) & 0x3F;

   293

		}

   294

		x = xb;

   295

   296

		if (y == y2)

   297

			break;

   298

   299

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

   300

	}

   301

	return NULL;

   302

}

   303

   304

   305

   306

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

   307

{

   308

	VehicleID *old_hash, *new_hash;

   309

	int old_x = v->left_coord;

   310

	int old_y = v->top_coord;

   311

	Vehicle *u;

   312

   313

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

   314

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

   315

   316

	if (old_hash == new_hash)

   317

		return;

   318

   319

	/* remove from hash table? */

   320

	if (old_hash != NULL) {

   321

		Vehicle *last = NULL;

   322

		int idx = *old_hash;

   323

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

   324

			idx = u->next_hash;

   325

			assert(idx != INVALID_VEHICLE);

   326

			last = u;

   327

		}

   328

   329

		if (last == NULL)

   330

			*old_hash = v->next_hash;

   331

		else

   332

			last->next_hash = v->next_hash;

   333

	}

   334

   335

	/* insert into hash table? */

   336

	if (new_hash != NULL) {

   337

		v->next_hash = *new_hash;

   338

		*new_hash = v->index;

   339

	}

   340

}

   341

   342

void InitializeVehicles(void)

   343

{

   344

	int i;

   345

   346

	/* Clean the vehicle pool, and reserve enough blocks

   347

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

   348

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

   349

	CleanPool(&_vehicle_pool);

   350

	AddBlockToPool(&_vehicle_pool);

   351

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

   352

		AddBlockToPool(&_vehicle_pool);

   353

   354

	// clear it...

   355

	memset(&_waypoints, 0, sizeof(_waypoints));

   356

	memset(&_depots, 0, sizeof(_depots));

   357

   358

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

   359

}

   360

   361

Vehicle *GetLastVehicleInChain(Vehicle *v)

   362

{

   363

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

   364

	return v;

   365

}

   366

   367

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   368

{

   369

	Vehicle *org = v;

   370

   371

	FOR_ALL_VEHICLES(v) {

   372

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

   373

			return v;

   374

	}

   375

   376

	return NULL;

   377

}

   378

   379

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   380

{

   381

	Vehicle *u;

   382

   383

	while (true) {

   384

		u = v;

   385

		v = GetPrevVehicleInChain(v);

   386

		/* If there is no such vehicle,

   387

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

   388

		if (v == NULL)

   389

			return u;

   390

	}

   391

}

   392

   393

int CountVehiclesInChain(Vehicle *v)

   394

{

   395

	int count = 0;

   396

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

   397

	return count;

   398

}

   399

   400

   401

Depot *AllocateDepot(void)

   402

{

   403

	Depot *dep, *free_dep = NULL;

   404

	int num_free = 0;

   405

   406

	for(dep = _depots; dep != endof(_depots); dep++) {

   407

		if (dep->xy == 0) {

   408

			num_free++;

   409

			if (free_dep==NULL)

   410

				free_dep = dep;

   411

		}

   412

	}

   413

   414

	if (free_dep == NULL ||

   415

			(num_free < 30 && IS_HUMAN_PLAYER(_current_player))) {

   416

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   417

		return NULL;

   418

	}

   419

   420

	return free_dep;

   421

}

   422

   423

Waypoint *AllocateWaypoint(void)

   424

{

   425

	Waypoint *cp;

   426

   427

	for(cp = _waypoints; cp != endof(_waypoints); cp++) {

   428

		if (cp->xy == 0)

   429

			return cp;

   430

	}

   431

   432

	return NULL;

   433

}

   434

   435

uint GetWaypointByTile(uint tile)

   436

{

   437

	Waypoint *cp;

   438

	int i=0;

   439

	for(cp=_waypoints; cp->xy != (TileIndex)tile; cp++) { i++; }

   440

	return i;

   441

}

   442

   443

void DoDeleteDepot(uint tile)

   444

{

   445

	Order order;

   446

	byte dep_index;

   447

	Depot *d;

   448

   449

	// Clear it

   450

	DoClearSquare(tile);

   451

   452

	// Nullify the depot struct

   453

	for(d=_depots,dep_index=0; d->xy != (TileIndex)tile; d++) {dep_index++;}

   454

	d->xy = 0;

   455

   456

	order.type = OT_GOTO_DEPOT;

   457

	order.station = dep_index;

   458

	DeleteDestinationFromVehicleOrder(order);

   459

   460

	// Delete the depot

   461

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   462

}

   463

   464

void DeleteVehicle(Vehicle *v)

   465

{

   466

	DeleteName(v->string_id);

   467

	v->type = 0;

   468

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   469

	v->next_hash = 0xffff;

   470

   471

	if (v->orders != NULL)

   472

		DeleteVehicleOrders(v);

   473

}

   474

   475

void DeleteVehicleChain(Vehicle *v)

   476

{

   477

	do {

   478

		Vehicle *u = v;

   479

		v = v->next;

   480

		DeleteVehicle(u);

   481

	} while (v);

   482

}

   483

   484

   485

void Aircraft_Tick(Vehicle *v);

   486

void RoadVeh_Tick(Vehicle *v);

   487

void Ship_Tick(Vehicle *v);

   488

void Train_Tick(Vehicle *v);

   489

static void EffectVehicle_Tick(Vehicle *v);

   490

void DisasterVehicle_Tick(Vehicle *v);

   491

   492

VehicleTickProc *_vehicle_tick_procs[] = {

   493

	Train_Tick,

   494

	RoadVeh_Tick,

   495

	Ship_Tick,

   496

	Aircraft_Tick,

   497

	EffectVehicle_Tick,

   498

	DisasterVehicle_Tick,

   499

};

   500

   501

void CallVehicleTicks(void)

   502

{

   503

	Vehicle *v;

   504

   505

	FOR_ALL_VEHICLES(v) {

   506

		if (v->type != 0)

   507

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

   508

	}

   509