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

	VEHICLES_MIN_FREE_FOR_AI = 90

    21

};

    22

    23

void VehicleServiceInDepot(Vehicle *v)

    24

{

    25

	v->date_of_last_service = _date;

    26

	v->breakdowns_since_last_service = 0;

    27

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

    28

}

    29

    30

bool VehicleNeedsService(const Vehicle *v)

    31

{

    32

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

    33

		return false;

    34

    35

	return _patches.servint_ispercent ?

    36

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

    37

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

    38

}

    39

    40

void VehicleInTheWayErrMsg(Vehicle *v)

    41

{

    42

	StringID id;

    43

    44

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

    45

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

    46

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

    47

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    48

    49

	_error_message = id;

    50

}

    51

    52

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

    53

{

    54

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

    55

		return NULL;

    56

    57

	VehicleInTheWayErrMsg(v);

    58

	return v;

    59

}

    60

    61

bool EnsureNoVehicle(TileIndex tile)

    62

{

    63

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

    64

}

    65

    66

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

    67

{

    68

	const TileInfo *ti = data;

    69

    70

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

    71

		return NULL;

    72

    73

	VehicleInTheWayErrMsg(v);

    74

	return v;

    75

}

    76

    77

static inline uint Correct_Z(uint tileh)

    78

{

    79

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

    80

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

    81

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

    82

}

    83

    84

uint GetCorrectTileHeight(TileIndex tile)

    85

{

    86

	return Correct_Z(GetTileSlope(tile, NULL));

    87

}

    88

    89

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    90

{

    91

	TileInfo ti;

    92

    93

	FindLandscapeHeightByTile(&ti, tile);

    94

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

    95

    96

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

    97

}

    98

    99

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

   100

{

   101

	int x1 = TileX(from);

   102

	int y1 = TileY(from);

   103

	int x2 = TileX(to);

   104

	int y2 = TileY(to);

   105

	Vehicle *veh;

   106

   107

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

   108

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

   109

		intswap(x1,x2);

   110

		intswap(y1,y2);

   111

	}

   112

	FOR_ALL_VEHICLES(veh) {

   113

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

   114

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

   115

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

   116

				return veh;

   117

			}

   118

		}

   119

	}

   120

	return NULL;

   121

}

   122

   123

void VehiclePositionChanged(Vehicle *v)

   124

{

   125

	int img = v->cur_image;

   126

	const SpriteDimension *sd;

   127

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

   128

   129

	sd = GetSpriteDimension(img);

   130

   131

	pt.x += sd->xoffs;

   132

	pt.y += sd->yoffs;

   133

   134

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

   135

   136

	v->left_coord = pt.x;

   137

	v->top_coord = pt.y;

   138

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

   139

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

   140

}

   141

   142

void UpdateWaypointSign(Waypoint *cp)

   143

{

   144

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

   145

	SetDParam(0, cp - _waypoints);

   146

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

   147

}

   148

   149

void RedrawWaypointSign(Waypoint *cp)

   150

{

   151

	MarkAllViewportsDirty(

   152

		cp->sign.left - 6,

   153

		cp->sign.top,

   154

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

   155

		cp->sign.top + 48);

   156

}

   157

   158

// Called after load to update coordinates

   159

void AfterLoadVehicles(void)

   160

{

   161

	Vehicle *v;

   162

	Waypoint *cp;

   163

   164

	FOR_ALL_VEHICLES(v) {

   165

		if (v->type != 0) {

   166

			v->left_coord = INVALID_COORD;

   167

			VehiclePositionChanged(v);

   168

   169

			if (v->type == VEH_Train) {

   170

				if (v->subtype == TS_Front_Engine)

   171

					UpdateTrainAcceleration(v);

   172

			}

   173

		}

   174

	}

   175

   176

	// update waypoint signs

   177

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

   178

}

   179

   180

   181

static Vehicle *InitializeVehicle(Vehicle *v)

   182

{

   183

	VehicleID index = v->index;

   184

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

   185

	v->index = index;

   186

   187

	assert(v->orders == NULL);

   188

   189

	v->left_coord = INVALID_COORD;

   190

	v->next = NULL;

   191

	v->next_hash = 0xffff;

   192

	v->string_id = 0;

   193

	v->next_shared = NULL;

   194

	v->prev_shared = NULL;

   195

	v->set_for_replacement = false;

   196

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

   197

	    which are technical the same (newgrf stuff).

   198

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

   199

	    not really matter that one client has other visual vehicles than

   200

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

   201

	*/

   202

	v->random_bits = InteractiveRandomRange(256);

   203

	return v;

   204

}

   205

   206

Vehicle *ForceAllocateSpecialVehicle(void)

   207

{

   208

	Vehicle *v;

   209

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   210

		if (v->type == 0)

   211

			return InitializeVehicle(v);

   212

	}

   213

	return NULL;

   214

   215

}

   216

   217

Vehicle *ForceAllocateVehicle(void)

   218

{

   219

	Vehicle *v;

   220

	FOR_ALL_VEHICLES(v) {

   221

		if (v->index >= NUM_NORMAL_VEHICLES)

   222

			return NULL;

   223

   224

		if (v->type == 0)

   225

			return InitializeVehicle(v);

   226

	}

   227

	return NULL;

   228

}

   229

   230

Vehicle *AllocateVehicle(void)

   231

{

   232

	Vehicle *v;

   233

	int num;

   234

   235

	if (IS_HUMAN_PLAYER(_current_player)) {

   236

		num = 0;

   237

   238

		FOR_ALL_VEHICLES(v) {

   239

			if (v->index >= NUM_NORMAL_VEHICLES)

   240

				break;

   241

   242

			if (v->type == 0)

   243

				num++;

   244

		}

   245

   246

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   247

			return NULL;

   248

	}

   249

   250

	return ForceAllocateVehicle();

   251

}

   252

   253

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

   254

{

   255

	int x,y,x2,y2;

   256

	VehicleID veh;

   257

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

   258

   259

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

   260

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

   261

   262

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

   263

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

   264

   265

	for(;;) {

   266

		int xb = x;

   267

		for(;;) {

   268

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

   269

			while (veh != INVALID_VEHICLE) {

   270

				Vehicle *v = GetVehicle(veh);

   271

				void *a;

   272

   273

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

   274

					return a;

   275

				veh = v->next_hash;

   276

			}

   277

   278

			if (x == x2)

   279

				break;

   280

   281

			x = (x + 1) & 0x3F;

   282

		}

   283

		x = xb;

   284

   285

		if (y == y2)

   286

			break;

   287

   288

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

   289

	}

   290

	return NULL;

   291

}

   292

   293

   294

   295

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

   296

{

   297

	VehicleID *old_hash, *new_hash;

   298

	int old_x = v->left_coord;

   299

	int old_y = v->top_coord;

   300

	Vehicle *u;

   301

   302

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

   303

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

   304

   305

	if (old_hash == new_hash)

   306

		return;

   307

   308

	/* remove from hash table? */

   309

	if (old_hash != NULL) {

   310

		Vehicle *last = NULL;

   311

		int idx = *old_hash;

   312

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

   313

			idx = u->next_hash;

   314

			assert(idx != INVALID_VEHICLE);

   315

			last = u;

   316

		}

   317

   318

		if (last == NULL)

   319

			*old_hash = v->next_hash;

   320

		else

   321

			last->next_hash = v->next_hash;

   322

	}

   323

   324

	/* insert into hash table? */

   325

	if (new_hash != NULL) {

   326

		v->next_hash = *new_hash;

   327

		*new_hash = v->index;

   328

	}

   329

}

   330

   331

void InitializeVehicles(void)

   332

{

   333

	Vehicle *v;

   334

	int i;

   335

   336

	// clear it...

   337

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

   338

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

   339

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

   340

   341

	// setup indexes..

   342

	i = 0;

   343

	FOR_ALL_VEHICLES(v)

   344

		v->index = i++;

   345

   346

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

   347

}

   348

   349

Vehicle *GetLastVehicleInChain(Vehicle *v)

   350

{

   351

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

   352

	return v;

   353

}

   354

   355

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   356

{

   357

	Vehicle *org = v;

   358

   359

	FOR_ALL_VEHICLES(v) {

   360

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

   361

			return v;

   362

	}

   363

   364

	return NULL;

   365

}

   366

   367

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   368

{

   369

	Vehicle *u;

   370

   371

	while (true) {

   372

		u = v;

   373

		v = GetPrevVehicleInChain(v);

   374

		/* If there is no such vehicle,

   375

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

   376

		if (v == NULL)

   377

			return u;

   378

	}

   379

}

   380

   381

int CountVehiclesInChain(Vehicle *v)

   382

{

   383

	int count = 0;

   384

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

   385

	return count;

   386

}

   387

   388

   389

Depot *AllocateDepot(void)

   390

{

   391

	Depot *dep, *free_dep = NULL;

   392

	int num_free = 0;

   393

   394

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

   395

		if (dep->xy == 0) {

   396

			num_free++;

   397

			if (free_dep==NULL)

   398

				free_dep = dep;

   399

		}

   400

	}

   401

   402

	if (free_dep == NULL ||

   403

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

   404

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   405

		return NULL;

   406

	}

   407

   408

	return free_dep;

   409

}

   410

   411

Waypoint *AllocateWaypoint(void)

   412

{

   413

	Waypoint *cp;

   414

   415

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

   416

		if (cp->xy == 0)

   417

			return cp;

   418

	}

   419

   420

	return NULL;

   421

}

   422

   423

uint GetWaypointByTile(uint tile)

   424

{

   425

	Waypoint *cp;

   426

	int i=0;

   427

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

   428

	return i;

   429

}

   430

   431

void DoDeleteDepot(uint tile)

   432

{

   433

	Order order;

   434

	byte dep_index;

   435

	Depot *d;

   436

   437

	// Clear it

   438

	DoClearSquare(tile);

   439

   440

	// Nullify the depot struct

   441

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

   442

	d->xy = 0;

   443

   444

	order.type = OT_GOTO_DEPOT;

   445

	order.station = dep_index;

   446

	DeleteDestinationFromVehicleOrder(order);

   447

   448

	// Delete the depot

   449

	DeleteWindowById(WC_VEHICLE_DEPOT, tile);

   450

}

   451

   452

void DeleteVehicle(Vehicle *v)

   453

{

   454

	DeleteName(v->string_id);

   455

	v->type = 0;

   456

	UpdateVehiclePosHash(v, INVALID_COORD, 0);

   457

	v->next_hash = 0xffff;

   458

   459

	if (v->orders != NULL)

   460

		DeleteVehicleOrders(v);

   461

}

   462

   463

void DeleteVehicleChain(Vehicle *v)

   464

{

   465

	do {

   466

		Vehicle *u = v;

   467

		v = v->next;

   468

		DeleteVehicle(u);

   469

	} while (v);

   470

}

   471

   472

   473

void Aircraft_Tick(Vehicle *v);

   474

void RoadVeh_Tick(Vehicle *v);

   475

void Ship_Tick(Vehicle *v);

   476

void Train_Tick(Vehicle *v);

   477

static void EffectVehicle_Tick(Vehicle *v);

   478

void DisasterVehicle_Tick(Vehicle *v);

   479

   480

VehicleTickProc *_vehicle_tick_procs[] = {

   481

	Train_Tick,

   482

	RoadVeh_Tick,

   483

	Ship_Tick,

   484

	Aircraft_Tick,

   485

	EffectVehicle_Tick,

   486

	DisasterVehicle_Tick,

   487

};

   488

   489

void CallVehicleTicks(void)

   490

{

   491

	Vehicle *v;

   492

   493

	FOR_ALL_VEHICLES(v) {

   494

		if (v->type != 0)

   495

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

   496

	}

   497

}

   498

   499

static bool CanFillVehicle_FullLoadAny(Vehicle *v)

   500

{

   501

	uint32 full = 0, not_full = 0;

   502

   503

	//special handling of aircraft

   504

   505

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

   506

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

   507

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

   508

		return true;

   509

	}

   510

   511

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