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

Order UnpackOldOrder(uint16 packed)

    37

{

    38

	Order order;

    39

	order.type    = (packed & 0x000f);

    40

	order.flags   = (packed & 0x00f0) >> 4;

    41

	order.station = (packed & 0xff00) >> 8;

    42

    43

	// Sanity check

    44

	// TTD stores invalid orders as OT_NOTHING with non-zero flags/station

    45

	if (order.type == OT_NOTHING && (order.flags != 0 || order.station != 0)) {

    46

		order.type = OT_DUMMY;

    47

		order.flags = 0;

    48

	}

    49

    50

	return order;

    51

}

    52

    53

    54

void VehicleInTheWayErrMsg(Vehicle *v)

    55

{

    56

	StringID id;

    57

    58

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

    59

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

    60

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

    61

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    62

    63

	_error_message = id;

    64

}

    65

    66

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

    67

{

    68

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

    69

		return NULL;

    70

    71

	VehicleInTheWayErrMsg(v);

    72

	return v;

    73

}

    74

    75

bool EnsureNoVehicle(TileIndex tile)

    76

{

    77

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

    78

}

    79

    80

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

    81

{

    82

	const TileInfo *ti = data;

    83

    84

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

    85

		return NULL;

    86

    87

	VehicleInTheWayErrMsg(v);

    88

	return v;

    89

}

    90

    91

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    92

{

    93

	TileInfo ti;

    94

    95

	FindLandscapeHeightByTile(&ti, tile);

    96

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

    97

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

    98

	if (CORRECT_Z(ti.tileh))

    99

		z += 8;

   100

   101

	ti.z = z;

   102

   103

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

   104

}

   105

   106

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

   107

{

   108

	int x1 = TileX(from);

   109

	int y1 = TileY(from);

   110

	int x2 = TileX(to);

   111

	int y2 = TileY(to);

   112

	Vehicle *veh;

   113

   114

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

   115

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

   116

		intswap(x1,x2);

   117

		intswap(y1,y2);

   118

	}

   119

	FOR_ALL_VEHICLES(veh) {

   120

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

   121

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

   122

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

   123

				return veh;

   124

			}

   125

		}

   126

	}

   127

	return NULL;

   128

}

   129

   130

void VehiclePositionChanged(Vehicle *v)

   131

{

   132

	int img = v->cur_image;

   133

	const SpriteDimension *sd;

   134

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

   135

   136

	sd = GetSpriteDimension(img);

   137

   138

	pt.x += sd->xoffs;

   139

	pt.y += sd->yoffs;

   140

   141

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

   142

   143

	v->left_coord = pt.x;

   144

	v->top_coord = pt.y;

   145

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

   146

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

   147

}

   148

   149

void UpdateWaypointSign(Waypoint *cp)

   150

{

   151

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

   152

	SetDParam(0, cp - _waypoints);

   153

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

   154

}

   155

   156

void RedrawWaypointSign(Waypoint *cp)

   157

{

   158

	MarkAllViewportsDirty(

   159

		cp->sign.left - 6,

   160

		cp->sign.top,

   161

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

   162

		cp->sign.top + 48);

   163

}

   164

   165

// Called after load to update coordinates

   166

void AfterLoadVehicles()

   167

{

   168

	Vehicle *v;

   169

	Waypoint *cp;

   170

   171

	FOR_ALL_VEHICLES(v) {

   172

		if (v->type != 0) {

   173

			v->left_coord = INVALID_COORD;

   174

			VehiclePositionChanged(v);

   175

   176

			if (v->type == VEH_Train) {

   177

				if (v->subtype == 0)

   178

					UpdateTrainAcceleration(v);

   179

			}

   180

   181

#if defined(_DEBUG)

   182

			if (!(v->schedule_ptr == NULL || (v->schedule_ptr >= _order_array && v->schedule_ptr < _ptr_to_next_order)))

   183

				v->schedule_ptr = NULL;

   184

#endif

   185

		}

   186

	}

   187

   188

	// update waypoint signs

   189

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

   190

}

   191

   192

   193

static Vehicle *InitializeVehicle(Vehicle *v)

   194

{

   195

	VehicleID index = v->index;

   196

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

   197

	v->index = index;

   198

   199

	assert(v->schedule_ptr == NULL);

   200

   201

	v->left_coord = INVALID_COORD;

   202

	v->next = NULL;

   203

	v->next_hash = 0xffff;

   204

	v->string_id = 0;

   205

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

   206

	    which are technical the same (newgrf stuff).

   207

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

   208

	    not really matter that one client has other visual vehicles than

   209

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

   210

	*/

   211

	v->random_bits = InteractiveRandomRange(256);

   212

	return v;

   213

}

   214

   215

Vehicle *ForceAllocateSpecialVehicle()

   216

{

   217

	Vehicle *v;

   218

	FOR_ALL_VEHICLES_FROM(v, NUM_NORMAL_VEHICLES) {

   219

		if (v->type == 0)

   220

			return InitializeVehicle(v);

   221

	}

   222

	return NULL;

   223

   224

}

   225

   226

Vehicle *ForceAllocateVehicle()

   227

{

   228

	Vehicle *v;

   229

	FOR_ALL_VEHICLES(v) {

   230

		if (v->index >= NUM_NORMAL_VEHICLES)

   231

			return NULL;

   232

   233

		if (v->type == 0)

   234

			return InitializeVehicle(v);

   235

	}

   236

	return NULL;

   237

}

   238

   239

Vehicle *AllocateVehicle()

   240

{

   241

	Vehicle *v;

   242

	int num;

   243

   244

	if (IS_HUMAN_PLAYER(_current_player)) {

   245

		num = 0;

   246

   247

		FOR_ALL_VEHICLES(v) {

   248

			if (v->index >= NUM_NORMAL_VEHICLES)

   249

				break;

   250

   251

			if (v->type == 0)

   252

				num++;

   253

		}

   254

   255

		if (num <= VEHICLES_MIN_FREE_FOR_AI)

   256

			return NULL;

   257

	}

   258

   259

	return ForceAllocateVehicle();

   260

}

   261

   262

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

   263

{

   264

	int x,y,x2,y2;

   265

	VehicleID veh;

   266

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

   267

   268

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

   269

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

   270

   271

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

   272

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

   273

   274

	for(;;) {

   275

		int xb = x;

   276

		for(;;) {

   277

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

   278

			while (veh != INVALID_VEHICLE) {

   279

				Vehicle *v = GetVehicle(veh);

   280

				void *a;

   281

   282

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

   283

					return a;

   284

				veh = v->next_hash;

   285

			}

   286

   287

			if (x == x2)

   288

				break;

   289

   290

			x = (x + 1) & 0x3F;

   291

		}

   292

		x = xb;

   293

   294

		if (y == y2)

   295

			break;

   296

   297

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

   298

	}

   299

	return NULL;

   300

}

   301

   302

   303

   304

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

   305

{

   306

	VehicleID *old_hash, *new_hash;

   307

	int old_x = v->left_coord;

   308

	int old_y = v->top_coord;

   309

	Vehicle *u;

   310

   311

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

   312

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

   313

   314

	if (old_hash == new_hash)

   315

		return;

   316

   317

	/* remove from hash table? */

   318

	if (old_hash != NULL) {

   319

		Vehicle *last = NULL;

   320

		int idx = *old_hash;

   321

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

   322

			idx = u->next_hash;

   323

			assert(idx != INVALID_VEHICLE);

   324

			last = u;

   325

		}

   326

   327

		if (last == NULL)

   328

			*old_hash = v->next_hash;

   329

		else

   330

			last->next_hash = v->next_hash;

   331

	}

   332

   333

	/* insert into hash table? */

   334

	if (new_hash != NULL) {

   335

		v->next_hash = *new_hash;

   336

		*new_hash = v->index;

   337

	}

   338

}

   339

   340

void InitializeVehicles()

   341

{

   342

	Vehicle *v;

   343

	int i;

   344

   345

	// clear it...

   346

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

   347

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

   348

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

   349

   350

	// setup indexes..

   351

	i = 0;

   352

	FOR_ALL_VEHICLES(v)

   353

		v->index = i++;

   354

   355

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

   356

   357

	_ptr_to_next_order = _order_array;

   358

}

   359

   360

Vehicle *GetLastVehicleInChain(Vehicle *v)

   361

{

   362

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

   363

	return v;

   364

}

   365

   366

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   367

{

   368

	Vehicle *org = v;

   369

   370

	FOR_ALL_VEHICLES(v) {

   371

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

   372

			return v;

   373

	}

   374

   375

	return NULL;

   376

}

   377

   378

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   379

{

   380

	Vehicle *u;

   381

   382

	while (true) {

   383

		u = v;

   384

		v = GetPrevVehicleInChain(v);

   385

		/* If there is no such vehicle,

   386

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

   387

		if (v == NULL)

   388

			return u;

   389

	}

   390

}

   391

   392

int CountVehiclesInChain(Vehicle *v)

   393

{

   394

	int count = 0;

   395

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

   396

	return count;

   397

}

   398

   399

   400

Depot *AllocateDepot()

   401

{

   402

	Depot *dep, *free_dep = NULL;

   403

	int num_free = 0;

   404

   405

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

   406

		if (dep->xy == 0) {

   407

			num_free++;

   408

			if (free_dep==NULL)

   409

				free_dep = dep;

   410

		}

   411

	}

   412

   413

	if (free_dep == NULL ||

   414

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

   415

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   416

		return NULL;

   417

	}

   418

   419

	return free_dep;

   420

}

   421

   422

Waypoint *AllocateWaypoint()

   423

{

   424

	Waypoint *cp;

   425

   426

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

   427

		if (cp->xy == 0)

   428

			return cp;

   429

	}

   430

   431

	return NULL;

   432

}

   433

   434

uint GetWaypointByTile(uint tile)

   435

{

   436

	Waypoint *cp;

   437

	int i=0;

   438

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

   439

	return i;

   440

}

   441

   442

   443

Vehicle *IsScheduleShared(Vehicle *u)

   444

{

   445

	const Order *sched = u->schedule_ptr;

   446

	Vehicle *v;

   447

   448

	FOR_ALL_VEHICLES(v) {

   449

		if (v->schedule_ptr == sched && u != v && v->type != 0)

   450

			return v;

   451

	}

   452

	return NULL;

   453

}

   454

   455

void DeleteVehicleSchedule(Vehicle *v)

   456

{

   457

	Order *sched;

   458

	Order *cur;

   459

	int num;

   460

	Vehicle *u;

   461

   462

	// if the schedule is shared, don't delete it.

   463

	if ((u = IsScheduleShared(v)) != NULL) {

   464

		v->schedule_ptr = NULL;

   465

		InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   466

		return;

   467

	}

   468

   469

	sched = v->schedule_ptr;

   470

	v->schedule_ptr = NULL;

   471

   472

	num = v->num_orders + 1;

   473

   474

	_ptr_to_next_order -= num;

   475

   476

	cur = sched;

   477

	while (cur != _ptr_to_next_order) {

   478

		assert(cur < _ptr_to_next_order);

   479

		cur[0] = cur[num];

   480

		cur++;

   481

	}

   482

   483

	FOR_ALL_VEHICLES(v) {

   484

		if (v->schedule_ptr != NULL && sched < v->schedule_ptr) {

   485

			v->schedule_ptr -= num;

   486

		}

   487

	}

   488

}

   489

   490

void DeleteCommandFromVehicleSchedule(Order cmd)

   491

{

   492

	Vehicle *v;

   493

	bool need_invalidate;

   494

   495

	FOR_ALL_VEHICLES(v) {

   496

		if (v->type != 0 && v->schedule_ptr != NULL) {

   497

			Order *sched;

   498

   499

			// clear last station visited

   500

			if (v->last_station_visited == cmd.station && cmd.type == OT_GOTO_STATION)

   501

				v->last_station_visited = 0xFFFF;

   502

   503

			// check the next order

   504

			if (v->current_order.type == cmd.type &&

   505

					v->current_order.station == cmd.station) {

   506

				v->current_order.type = OT_DUMMY;

   507

				v->current_order.flags = 0;

   508

				InvalidateWindow(WC_VEHICLE_VIEW, v->index);

   509

			}

   510

   511

			// clear the order list

   512

			need_invalidate = false;

   513

			for (sched = v->schedule_ptr; sched->type != OT_NOTHING; ++sched) {

   514