1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "gfx.h"

     7

#include "viewport.h"

     8

#include "news.h"

     9

#include "command.h"

    10

#include "saveload.h"

    11

#include "player.h"

    12

#include "engine.h"

    13

#include "sound.h"

    14

    15

#define INVALID_COORD (-0x8000)

    16

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

    17

    18

enum {

    19

	VEHICLES_MIN_FREE_FOR_AI = 90

    20

};

    21

    22

void VehicleServiceInDepot(Vehicle *v)

    23

{

    24

	v->date_of_last_service = _date;

    25

	v->breakdowns_since_last_service = 0;

    26

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

    27

}

    28

    29

bool VehicleNeedsService(const Vehicle *v)

    30

{

    31

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

    32

		return false;

    33

    34

	return _patches.servint_ispercent ?

    35

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

    36

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

    37

}

    38

    39

void VehicleInTheWayErrMsg(Vehicle *v)

    40

{

    41

	StringID id;

    42

    43

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

    44

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

    45

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

    46

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    47

    48

	_error_message = id;

    49

}

    50

    51

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

    52

{

    53

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

    54

		return NULL;

    55

    56

	VehicleInTheWayErrMsg(v);

    57

	return v;

    58

}

    59

    60

bool EnsureNoVehicle(TileIndex tile)

    61

{

    62

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

    63

}

    64

    65

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

    66

{

    67

	const TileInfo *ti = data;

    68

    69

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

    70

		return NULL;

    71

    72

	VehicleInTheWayErrMsg(v);

    73

	return v;

    74

}

    75

    76

static inline uint Correct_Z(uint tileh)

    77

{

    78

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

    79

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

    80

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

    81

}

    82

    83

uint GetCorrectTileHeight(TileIndex tile)

    84

{

    85

	TileInfo ti;

    86

    87

	FindLandscapeHeightByTile(&ti, tile);

    88

	return Correct_Z(ti.tileh);

    89

}

    90

    91

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    92

{

    93

	TileInfo ti;

    94

    95

	FindLandscapeHeightByTile(&ti, tile);

    96

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

    97

    98

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

    99

}

   100

   101

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

   102

{

   103

	int x1 = TileX(from);

   104

	int y1 = TileY(from);

   105

	int x2 = TileX(to);

   106

	int y2 = TileY(to);

   107

	Vehicle *veh;

   108

   109

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

   110

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

   111

		intswap(x1,x2);

   112

		intswap(y1,y2);

   113

	}

   114

	FOR_ALL_VEHICLES(veh) {

   115

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

   116

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

   117

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

   118

				return veh;

   119

			}

   120

		}

   121

	}

   122

	return NULL;

   123

}

   124

   125

void VehiclePositionChanged(Vehicle *v)

   126

{

   127

	int img = v->cur_image;

   128

	const SpriteDimension *sd;

   129

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

   130

   131

	sd = GetSpriteDimension(img);

   132

   133

	pt.x += sd->xoffs;

   134

	pt.y += sd->yoffs;

   135

   136

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

   137

   138

	v->left_coord = pt.x;

   139

	v->top_coord = pt.y;

   140

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

   141

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

   142

}

   143

   144

void UpdateWaypointSign(Waypoint *cp)

   145

{

   146

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

   147

	SetDParam(0, cp - _waypoints);

   148

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

   149

}

   150

   151

void RedrawWaypointSign(Waypoint *cp)

   152

{

   153

	MarkAllViewportsDirty(

   154

		cp->sign.left - 6,

   155

		cp->sign.top,

   156

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

   157

		cp->sign.top + 48);

   158

}

   159

   160

// Called after load to update coordinates

   161

void AfterLoadVehicles(void)

   162

{

   163

	Vehicle *v;

   164

	Waypoint *cp;

   165

   166

	FOR_ALL_VEHICLES(v) {

   167

		if (v->type != 0) {

   168

			v->left_coord = INVALID_COORD;

   169

			VehiclePositionChanged(v);

   170

   171

			if (v->type == VEH_Train) {

   172

				if (v->subtype == TS_Front_Engine)

   173

					UpdateTrainAcceleration(v);

   174

			}

   175

		}

   176

	}

   177

   178

	// update waypoint signs

   179

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

   180

}

   181

   182

   183

static Vehicle *InitializeVehicle(Vehicle *v)

   184

{

   185

	VehicleID index = v->index;

   186

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

   187

	v->index = index;

   188

   189

	assert(v->orders == NULL);

   190

   191

	v->left_coord = INVALID_COORD;

   192

	v->next = NULL;

   193

	v->next_hash = 0xffff;

   194

	v->string_id = 0;

   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

	Vehicle *v;

   210

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   211

		if (v->type == 0)

   212

			return InitializeVehicle(v);

   213

	}

   214

	return NULL;

   215

   216

}

   217

   218

Vehicle *ForceAllocateVehicle(void)

   219

{

   220

	Vehicle *v;

   221

	FOR_ALL_VEHICLES(v) {

   222

		if (v->index >= NUM_NORMAL_VEHICLES)

   223

			return NULL;

   224

   225

		if (v->type == 0)

   226

			return InitializeVehicle(v);

   227

	}

   228

	return NULL;

   229

}

   230

   231

Vehicle *AllocateVehicle(void)

   232

{

   233

	Vehicle *v;

   234

	int num;

   235

   236

	if (IS_HUMAN_PLAYER(_current_player)) {

   237

		num = 0;

   238

   239

		FOR_ALL_VEHICLES(v) {

   240

			if (v->index >= NUM_NORMAL_VEHICLES)

   241

				break;

   242

   243

			if (v->type == 0)

   244

				num++;

   245

		}

   246

   247

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   248

			return NULL;

   249

	}

   250

   251

	return ForceAllocateVehicle();

   252

}

   253

   254

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

   255

{

   256

	int x,y,x2,y2;

   257

	VehicleID veh;

   258

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

   259

   260

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

   261

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

   262

   263

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

   264

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

   265

   266

	for(;;) {

   267

		int xb = x;

   268

		for(;;) {

   269

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

   270

			while (veh != INVALID_VEHICLE) {

   271

				Vehicle *v = GetVehicle(veh);

   272

				void *a;

   273

   274

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

   275

					return a;

   276

				veh = v->next_hash;

   277

			}

   278

   279

			if (x == x2)

   280

				break;

   281

   282

			x = (x + 1) & 0x3F;

   283

		}

   284

		x = xb;

   285

   286

		if (y == y2)

   287

			break;

   288

   289

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

   290

	}

   291

	return NULL;

   292

}

   293

   294

   295

   296

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

   297

{

   298

	VehicleID *old_hash, *new_hash;

   299

	int old_x = v->left_coord;

   300

	int old_y = v->top_coord;

   301

	Vehicle *u;

   302

   303

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

   304

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

   305

   306

	if (old_hash == new_hash)

   307

		return;

   308

   309

	/* remove from hash table? */

   310

	if (old_hash != NULL) {

   311

		Vehicle *last = NULL;

   312

		int idx = *old_hash;

   313

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

   314

			idx = u->next_hash;

   315

			assert(idx != INVALID_VEHICLE);

   316

			last = u;

   317

		}

   318

   319

		if (last == NULL)

   320

			*old_hash = v->next_hash;

   321

		else

   322

			last->next_hash = v->next_hash;

   323

	}

   324

   325

	/* insert into hash table? */

   326

	if (new_hash != NULL) {

   327

		v->next_hash = *new_hash;

   328

		*new_hash = v->index;

   329

	}

   330

}

   331

   332

void InitializeVehicles(void)

   333

{

   334

	Vehicle *v;

   335

	int i;

   336

   337

	// clear it...

   338

	memset(&_vehicles, 0, sizeof(_vehicles[0]) * _vehicles_size);

   339

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

   340

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

   341

   342

	// setup indexes..

   343

	i = 0;

   344

	FOR_ALL_VEHICLES(v)

   345

		v->index = i++;

   346

   347

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

   348

}

   349

   350

Vehicle *GetLastVehicleInChain(Vehicle *v)

   351

{

   352

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

   353

	return v;

   354

}

   355

   356

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   357

{

   358

	Vehicle *org = v;

   359

   360

	FOR_ALL_VEHICLES(v) {

   361

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

   362

			return v;

   363

	}

   364

   365

	return NULL;

   366

}

   367

   368

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   369

{

   370

	Vehicle *u;

   371

   372

	while (true) {

   373

		u = v;

   374

		v = GetPrevVehicleInChain(v);

   375

		/* If there is no such vehicle,

   376

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

   377

		if (v == NULL)

   378

			return u;

   379

	}

   380

}

   381

   382

int CountVehiclesInChain(Vehicle *v)

   383

{

   384

	int count = 0;

   385

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

   386

	return count;

   387

}

   388

   389

   390

Depot *AllocateDepot(void)

   391

{

   392

	Depot *dep, *free_dep = NULL;

   393

	int num_free = 0;

   394

   395

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

   396

		if (dep->xy == 0) {

   397

			num_free++;

   398

			if (free_dep==NULL)

   399

				free_dep = dep;

   400

		}

   401

	}

   402

   403

	if (free_dep == NULL ||

   404

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

   405

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   406

		return NULL;

   407

	}

   408

   409

	return free_dep;

   410

}

   411

   412

Waypoint *AllocateWaypoint(void)

   413

{

   414

	Waypoint *cp;

   415

   416

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

   417

		if (cp->xy == 0)

   418

			return cp;

   419

	}

   420

   421

	return NULL;

   422

}

   423

   424

uint GetWaypointByTile(uint tile)

   425

{

   426

	Waypoint *cp;

   427

	int i=0;

   428

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

   429

	return i;

   430

}

   431

   432

void DoDeleteDepot(uint tile)

   433

{

   434

	Order order;

   435

	byte dep_index;

   436

	Depot *d;

   437

   438

	// Clear it

   439

	DoClearSquare(tile);

   440

   441

	// Nullify the depot struct

   442

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

   443

	d->xy = 0;

   444

   445

	order.type = OT_GOTO_DEPOT;

   446

	order.station = dep_index;

   447

	DeleteDestinationFromVehicleOrder(order);

   448

   449

	// Delete the depot

   450

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   451

}

   452

   453

void DeleteVehicle(Vehicle *v)

   454

{

   455

	DeleteName(v->string_id);

   456

	v->type = 0;

   457

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   458

	v->next_hash = 0xffff;

   459

   460

	if (v->orders != NULL)

   461

		DeleteVehicleOrders(v);

   462

}

   463

   464

void DeleteVehicleChain(Vehicle *v)

   465

{

   466

	do {

   467

		Vehicle *u = v;

   468

		v = v->next;

   469

		DeleteVehicle(u);

   470

	} while (v);

   471

}

   472

   473

   474

void Aircraft_Tick(Vehicle *v);

   475

void RoadVeh_Tick(Vehicle *v);

   476

void Ship_Tick(Vehicle *v);

   477

void Train_Tick(Vehicle *v);

   478

static void EffectVehicle_Tick(Vehicle *v);

   479

void DisasterVehicle_Tick(Vehicle *v);

   480

   481

VehicleTickProc *_vehicle_tick_procs[] = {

   482

	Train_Tick,

   483

	RoadVeh_Tick,

   484

	Ship_Tick,

   485

	Aircraft_Tick,

   486

	EffectVehicle_Tick,

   487

	DisasterVehicle_Tick,

   488

};

   489

   490

void CallVehicleTicks(void)

   491

{

   492

	Vehicle *v;

   493

   494

	FOR_ALL_VEHICLES(v) {

   495

		if (v->type != 0)

   496

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

   497

	}

   498

}

   499

   500

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   501

{

   502

	uint32 full = 0, not_full = 0;

   503

   504

	//special handling of aircraft

   505

   506

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

   507

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

   508

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

   509

		return true;

   510

	}

   511