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

	return _patches.servint_ispercent ?

    32

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

    33

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

    34

}

    35

    36

void VehicleInTheWayErrMsg(Vehicle *v)

    37

{

    38

	StringID id;

    39

    40

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

    41

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

    42

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

    43

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    44

    45

	_error_message = id;

    46

}

    47

    48

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

    49

{

    50

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

    51

		return NULL;

    52

    53

	VehicleInTheWayErrMsg(v);

    54

	return v;

    55

}

    56

    57

bool EnsureNoVehicle(TileIndex tile)

    58

{

    59

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

    60

}

    61

    62

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

    63

{

    64

	const TileInfo *ti = data;

    65

    66

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

    67

		return NULL;

    68

    69

	VehicleInTheWayErrMsg(v);

    70

	return v;

    71

}

    72

    73

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    74

{

    75

	TileInfo ti;

    76

    77

	FindLandscapeHeightByTile(&ti, tile);

    78

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

    79

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

    80

	if (CORRECT_Z(ti.tileh))

    81

		z += 8;

    82

    83

	ti.z = z;

    84

    85

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

    86

}

    87

    88

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

    89

{

    90

	int x1 = TileX(from);

    91

	int y1 = TileY(from);

    92

	int x2 = TileX(to);

    93

	int y2 = TileY(to);

    94

	Vehicle *veh;

    95

    96

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

    97

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

    98

		intswap(x1,x2);

    99

		intswap(y1,y2);

   100

	}

   101

	FOR_ALL_VEHICLES(veh) {

   102

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

   103

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

   104

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

   105

				return veh;

   106

			}

   107

		}

   108

	}

   109

	return NULL;

   110

}

   111

   112

void VehiclePositionChanged(Vehicle *v)

   113

{

   114

	int img = v->cur_image;

   115

	const SpriteDimension *sd;

   116

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

   117

   118

	sd = GetSpriteDimension(img);

   119

   120

	pt.x += sd->xoffs;

   121

	pt.y += sd->yoffs;

   122

   123

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

   124

   125

	v->left_coord = pt.x;

   126

	v->top_coord = pt.y;

   127

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

   128

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

   129

}

   130

   131

void UpdateWaypointSign(Waypoint *cp)

   132

{

   133

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

   134

	SetDParam(0, cp - _waypoints);

   135

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

   136

}

   137

   138

void RedrawWaypointSign(Waypoint *cp)

   139

{

   140

	MarkAllViewportsDirty(

   141

		cp->sign.left - 6,

   142

		cp->sign.top,

   143

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

   144

		cp->sign.top + 48);

   145

}

   146

   147

// Called after load to update coordinates

   148

void AfterLoadVehicles()

   149

{

   150

	Vehicle *v;

   151

	Waypoint *cp;

   152

   153

	FOR_ALL_VEHICLES(v) {

   154

		if (v->type != 0) {

   155

			v->left_coord = INVALID_COORD;

   156

			VehiclePositionChanged(v);

   157

   158

			if (v->type == VEH_Train) {

   159

				if (v->subtype == 0)

   160

					UpdateTrainAcceleration(v);

   161

			}

   162

		}

   163

	}

   164

   165

	// update waypoint signs

   166

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

   167

}

   168

   169

   170

static Vehicle *InitializeVehicle(Vehicle *v)

   171

{

   172

	VehicleID index = v->index;

   173

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

   174

	v->index = index;

   175

   177

   178

	v->left_coord = INVALID_COORD;

   179

	v->next = NULL;

   180

	v->next_hash = 0xffff;

   181

	v->string_id = 0;

   182

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

   183

	    which are technical the same (newgrf stuff).

   184

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

   185

	    not really matter that one client has other visual vehicles than

   186

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

   187

	*/

   188

	v->random_bits = InteractiveRandomRange(256);

   189

	return v;

   190

}

   191

   192

Vehicle *ForceAllocateSpecialVehicle()

   193

{

   194

	Vehicle *v;

   195

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   196

		if (v->type == 0)

   197

			return InitializeVehicle(v);

   198

	}

   199

	return NULL;

   200

   201

}

   202

   203

Vehicle *ForceAllocateVehicle()

   204

{

   205

	Vehicle *v;

   206

	FOR_ALL_VEHICLES(v) {

   207

		if (v->index >= NUM_NORMAL_VEHICLES)

   208

			return NULL;

   209

   210

		if (v->type == 0)

   211

			return InitializeVehicle(v);

   212

	}

   213

	return NULL;

   214

}

   215

   216

Vehicle *AllocateVehicle()

   217

{

   218

	Vehicle *v;

   219

	int num;

   220

   221

	if (IS_HUMAN_PLAYER(_current_player)) {

   222

		num = 0;

   223

   224

		FOR_ALL_VEHICLES(v) {

   225

			if (v->index >= NUM_NORMAL_VEHICLES)

   226

				break;

   227

   228

			if (v->type == 0)

   229

				num++;

   230

		}

   231

   232

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   233

			return NULL;

   234

	}

   235

   236

	return ForceAllocateVehicle();

   237

}

   238

   239

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

   240

{

   241

	int x,y,x2,y2;

   242

	VehicleID veh;

   243

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

   244

   245

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

   246

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

   247

   248

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

   249

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

   250

   251

	for(;;) {

   252

		int xb = x;

   253

		for(;;) {

   254

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

   255

			while (veh != INVALID_VEHICLE) {

   256

				Vehicle *v = GetVehicle(veh);

   257

				void *a;

   258

   259

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

   260

					return a;

   261

				veh = v->next_hash;

   262

			}

   263

   264

			if (x == x2)

   265

				break;

   266

   267

			x = (x + 1) & 0x3F;

   268

		}

   269

		x = xb;

   270

   271

		if (y == y2)

   272

			break;

   273

   274

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

   275

	}

   276

	return NULL;

   277

}

   278

   279

   280

   281

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

   282

{

   283

	VehicleID *old_hash, *new_hash;

   284

	int old_x = v->left_coord;

   285

	int old_y = v->top_coord;

   286

	Vehicle *u;

   287

   288

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

   289

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

   290

   291

	if (old_hash == new_hash)

   292

		return;

   293

   294

	/* remove from hash table? */

   295

	if (old_hash != NULL) {

   296

		Vehicle *last = NULL;

   297

		int idx = *old_hash;

   298

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

   299

			idx = u->next_hash;

   300

			assert(idx != INVALID_VEHICLE);

   301

			last = u;

   302

		}

   303

   304

		if (last == NULL)

   305

			*old_hash = v->next_hash;

   306

		else

   307

			last->next_hash = v->next_hash;

   308

	}

   309

   310

	/* insert into hash table? */

   311

	if (new_hash != NULL) {

   312

		v->next_hash = *new_hash;

   313

		*new_hash = v->index;

   314

	}

   315

}

   316

   317

void InitializeVehicles()

   318

{

   319

	Vehicle *v;

   320

	int i;

   321

   322

	// clear it...

   323

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

   324

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

   325

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

   326

   327

	// setup indexes..

   328

	i = 0;

   329

	FOR_ALL_VEHICLES(v)

   330

		v->index = i++;

   331

   332

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

   333

}

   334

   335

Vehicle *GetLastVehicleInChain(Vehicle *v)

   336

{

   337

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

   338

	return v;

   339

}

   340

   341

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   342

{

   343

	Vehicle *org = v;

   344

   345

	FOR_ALL_VEHICLES(v) {

   346

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

   347

			return v;

   348

	}

   349

   350

	return NULL;

   351

}

   352

   353

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   354

{

   355

	Vehicle *u;

   356

   357

	while (true) {

   358

		u = v;

   359

		v = GetPrevVehicleInChain(v);

   360

		/* If there is no such vehicle,

   361

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

   362

		if (v == NULL)

   363

			return u;

   364

	}

   365

}

   366

   367

int CountVehiclesInChain(Vehicle *v)

   368

{

   369

	int count = 0;

   370

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

   371

	return count;

   372

}

   373

   374

   375

Depot *AllocateDepot()

   376

{

   377

	Depot *dep, *free_dep = NULL;

   378

	int num_free = 0;

   379

   380

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

   381

		if (dep->xy == 0) {

   382

			num_free++;

   383

			if (free_dep==NULL)

   384

				free_dep = dep;

   385

		}

   386

	}

   387

   388

	if (free_dep == NULL ||

   389

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

   390

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   391

		return NULL;

   392

	}

   393

   394

	return free_dep;

   395

}

   396

   397

Waypoint *AllocateWaypoint()

   398

{

   399

	Waypoint *cp;

   400

   401

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

   402

		if (cp->xy == 0)

   403

			return cp;

   404

	}

   405

   406

	return NULL;

   407

}

   408

   409

uint GetWaypointByTile(uint tile)

   410

{

   411

	Waypoint *cp;

   412

	int i=0;

   413

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

   414

	return i;

   415

}

   416

   417

void DoDeleteDepot(uint tile)

   418

{

   419

	Order order;

   420

	byte dep_index;

   421

	Depot *d;

   422

   423

	// Clear it

   424

	DoClearSquare(tile);

   425

   426

	// Nullify the depot struct

   427

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

   428

	d->xy = 0;

   429

   430

	order.type = OT_GOTO_DEPOT;

   431

	order.station = dep_index;

   433

   434

	// Delete the depot

   435

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   436

}

   437

   438

void DeleteVehicle(Vehicle *v)

   439

{

   440

	DeleteName(v->string_id);

   441

	v->type = 0;

   442

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   443

	v->next_hash = 0xffff;

   444

   447

}

   448

   449

void DeleteVehicleChain(Vehicle *v)

   450

{

   451

	do {

   452

		Vehicle *u = v;

   453

		v = v->next;

   454

		DeleteVehicle(u);

   455

	} while (v);

   456

}

   457

   458

   459

void Aircraft_Tick(Vehicle *v);

   460

void RoadVeh_Tick(Vehicle *v);

   461

void Ship_Tick(Vehicle *v);

   462

void Train_Tick(Vehicle *v);

   463

static void EffectVehicle_Tick(Vehicle *v);

   464

void DisasterVehicle_Tick(Vehicle *v);

   465

   466

VehicleTickProc *_vehicle_tick_procs[] = {

   467

	Train_Tick,

   468

	RoadVeh_Tick,

   469

	Ship_Tick,

   470

	Aircraft_Tick,

   471

	EffectVehicle_Tick,

   472

	DisasterVehicle_Tick,

   473

};

   474

   475

void CallVehicleTicks()

   476

{

   477

	Vehicle *v;

   478

   479

	FOR_ALL_VEHICLES(v) {

   480

		if (v->type != 0)

   481

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

   482

	}

   483

}

   484

   485

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   486

{

   487

	uint32 full = 0, not_full = 0;

   488

   489

	//special handling of aircraft

   490

   491

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

   492

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

   493

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

   494

		return true;

   495

	}

   496

   497

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

   498

	do {

   499

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

   500

		assert(v->cargo_type<32);

   501

   502

		if (v->cargo_cap != 0) {

   503

			uint32 mask = 1 << v->cargo_type;

   504

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

   505

		}

   506

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

   507

   508

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

   509

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

   510

}

   511

   512

bool CanFillVehicle(Vehicle *v)

   513

{

   514

	byte *t = &_map_type_and_height[v->tile];