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 "station.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

void VehicleServiceInDepot(Vehicle *v)

    20

{

    21

	v->date_of_last_service = _date;

    22

	v->breakdowns_since_last_service = 0;

    23

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

    24

}

    25

    26

bool VehicleNeedsService(const Vehicle *v)

    27

{

    28

	return _patches.servint_ispercent ?

    29

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

    30

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

    31

}

    32

    33

Order UnpackOldOrder(uint16 packed)

    34

{

    35

	Order order;

    36

	order.type    = (packed & 0x000f);

    37

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

    38

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

    39

    40

	// Sanity check

    41

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

    42

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

    43

		order.type = OT_DUMMY;

    44

		order.flags = 0;

    45

	}

    46

    47

	return order;

    48

}

    49

    50

    51

void VehicleInTheWayErrMsg(Vehicle *v)

    52

{

    53

	StringID id;

    54

    55

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

    56

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

    57

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

    58

		(id = STR_980E_SHIP_IN_THE_WAY, true);

    59

    60

	_error_message = id;

    61

}

    62

    63

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

    64

{

    65

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

    66

		return NULL;

    67

    68

	VehicleInTheWayErrMsg(v);

    69

	return v;

    70

}

    71

    72

bool EnsureNoVehicle(TileIndex tile)

    73

{

    74

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

    75

}

    76

    77

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

    78

{

    79

	const TileInfo *ti = data;

    80

    81

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

    82

		return NULL;

    83

    84

	VehicleInTheWayErrMsg(v);

    85

	return v;

    86

}

    87

    88

bool EnsureNoVehicleZ(TileIndex tile, byte z)

    89

{

    90

	TileInfo ti;

    91

    92

	FindLandscapeHeightByTile(&ti, tile);

    93

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

    94

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

    95

	if (CORRECT_Z(ti.tileh))

    96

		z += 8;

    97

    98

	ti.z = z;

    99

   100

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

   101

}

   102

   103

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

   104

{

   105

	int x1 = GET_TILE_X(from);

   106

	int y1 = GET_TILE_Y(from);

   107

	int x2 = GET_TILE_X(to);

   108

	int y2 = GET_TILE_Y(to);

   109

	Vehicle *veh;

   110

	uint count;

   111

   112

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

   113

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

   114

		intswap(x1,x2);

   115

		intswap(y1,y2);

   116

	}

   117

	for(veh = _vehicles, count=lengthof(_vehicles); count != 0; count--, veh++) {

   118

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

   119

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

   120

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

   121

				return veh;

   122

			}

   123

		}

   124

	}

   125

	return NULL;

   126

}

   127

   128

void VehiclePositionChanged(Vehicle *v)

   129

{

   130

	int img = v->cur_image;

   131

	const SpriteDimension *sd;

   132

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

   133

   134

	sd = GetSpriteDimension(img);

   135

   136

	pt.x += sd->xoffs;

   137

	pt.y += sd->yoffs;

   138

   139

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

   140

   141

	v->left_coord = pt.x;

   142

	v->top_coord = pt.y;

   143

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

   144

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

   145

}

   146

   147

void UpdateWaypointSign(Waypoint *cp)

   148

{

   149

	Point pt = RemapCoords2(GET_TILE_X(cp->xy)*16, GET_TILE_Y(cp->xy)*16);

   150

	SetDParam(0, cp - _waypoints);

   151

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

   152

}

   153

   154

void RedrawWaypointSign(Waypoint *cp)

   155

{

   156

	MarkAllViewportsDirty(

   157

		cp->sign.left - 6,

   158

		cp->sign.top,

   159

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

   160

		cp->sign.top + 48);

   161

}

   162

   163

// Called after load to update coordinates

   164

void AfterLoadVehicles()

   165

{

   166

	Vehicle *v;

   167

	Waypoint *cp;

   168

   169

	FOR_ALL_VEHICLES(v) {

   170

		if (v->type != 0) {

   171

			v->left_coord = INVALID_COORD;

   172

			VehiclePositionChanged(v);

   173

   174

			if (v->type == VEH_Train) {

   175

				if (v->subtype == 0)

   176

					UpdateTrainAcceleration(v);

   177

			}

   178

   179

#if defined(_DEBUG)

   180

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

   181

				v->schedule_ptr = NULL;

   182

#endif

   183

		}

   184

	}

   185

   186

	// update waypoint signs

   187

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

   188

}

   189

   190

   191

static Vehicle *InitializeVehicle(Vehicle *v)

   192

{

   193

	VehicleID index = v->index;

   194

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

   195

	v->index = index;

   196

   197

	assert(v->schedule_ptr == NULL);

   198

   199

	v->left_coord = INVALID_COORD;

   200

	v->next = NULL;

   201

	v->next_hash = 0xffff;

   202

	v->string_id = 0;

   203

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

   204

	    which are technical the same (newgrf stuff).

   205

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

   206

	    not really matter that one client has other visual vehicles then

   207

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

   208

	*/

   209

	v->random_bits = InteractiveRandomRange(256);

   210

	return v;

   211

}

   212

   213

Vehicle *ForceAllocateSpecialVehicle()

   214

{

   215

	Vehicle *v;

   216

	for(v=_vehicles + NUM_NORMAL_VEHICLES;

   217

			v!=&_vehicles[NUM_NORMAL_VEHICLES+NUM_SPECIAL_VEHICLES]; v++) {

   218

		if (v->type == 0)

   219

			return InitializeVehicle(v);

   220

	}

   221

	return NULL;

   222

   223

}

   224

   225

Vehicle *ForceAllocateVehicle()

   226

{

   227

	Vehicle *v;

   228

	for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   229

		if (v->type == 0)

   230

			return InitializeVehicle(v);

   231

	}

   232

	return NULL;

   233

}

   234

   235

Vehicle *AllocateVehicle()

   236

{

   237

	Vehicle *v;

   238

	int num;

   239

   240

	if (IS_HUMAN_PLAYER(_current_player)) {

   241

		num = 0;

   242

   243

		for(v=_vehicles; v!=&_vehicles[NUM_NORMAL_VEHICLES]; v++) {

   244

			if (v->type == 0)

   245

				num++;

   246

		}

   247

   248

		if (num <= 90)

   249

			return NULL;

   250

	}

   251

   252

	return ForceAllocateVehicle();

   253

}

   254

   255

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

   256

{

   257

	int x,y,x2,y2;

   258

	VehicleID veh;

   259

	Point pt = RemapCoords(GET_TILE_X(tile) * 16, GET_TILE_Y(tile) * 16, 0);

   260

   261

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

   262

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

   263

   264

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

   265

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

   266

   267

	for(;;) {

   268

		int xb = x;

   269

		for(;;) {

   270

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

   271

			while (veh != INVALID_VEHICLE) {

   272

				Vehicle *v = &_vehicles[veh];

   273

				void *a;

   274

   275

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

   276

					return a;

   277

				veh = v->next_hash;

   278

			}

   279

   280

			if (x == x2)

   281

				break;

   282

   283

			x = (x + 1) & 0x3F;

   284

		}

   285

		x = xb;

   286

   287

		if (y == y2)

   288

			break;

   289

   290

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

   291

	}

   292

	return NULL;

   293

}

   294

   295

   296

   297

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

   298

{

   299

	VehicleID *old_hash, *new_hash;

   300

	int old_x = v->left_coord;

   301

	int old_y = v->top_coord;

   302

	Vehicle *u;

   303

   304

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

   305

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

   306

   307

	if (old_hash == new_hash)

   308

		return;

   309

   310

	/* remove from hash table? */

   311

	if (old_hash != NULL) {

   312

		Vehicle *last = NULL;

   313

		int idx = *old_hash;

   314

		while((u = &_vehicles[idx]) != v) {

   315

			idx = u->next_hash;

   316

			assert(idx != INVALID_VEHICLE);

   317

			last = u;

   318

		}

   319

   320

		if (last == NULL)

   321

			*old_hash = v->next_hash;

   322

		else

   323

			last->next_hash = v->next_hash;

   324

	}

   325

   326

	/* insert into hash table? */

   327

	if (new_hash != NULL) {

   328

		v->next_hash = *new_hash;

   329

		*new_hash = v->index;

   330

	}

   331

}

   332

   333

void InitializeVehicles()

   334

{

   335

	Vehicle *v;

   336

	int i;

   337

   338

	// clear it...

   339

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

   340

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

   341

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

   342

   343

	// setup indexes..

   344

	i = 0;

   345

	FOR_ALL_VEHICLES(v)

   346

		v->index = i++;

   347

   348

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

   349

   350

	_ptr_to_next_order = _order_array;

   351

}

   352

   353

Vehicle *GetLastVehicleInChain(Vehicle *v)

   354

{

   355

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

   356

	return v;

   357

}

   358

   359

Vehicle *GetPrevVehicleInChain(Vehicle *v)

   360

{

   361

	Vehicle *org = v;

   362

   363

	v = _vehicles;

   364

	while (v->type != VEH_Train || org != v->next) {

   365

		if (++v == endof(_vehicles))

   366

			return NULL;

   367

	}

   368

   369

	return v;

   370

}

   371

   372

Vehicle *GetFirstVehicleInChain(Vehicle *v)

   373

{

   374

	for(;;) {

   375

		Vehicle *u = v;

   376

		v = _vehicles;

   377

		while (v->type != VEH_Train || u != v->next) {

   378

			if (++v == endof(_vehicles))

   379

				return u;

   380

		}

   381

	}

   382

}

   383

   384

int CountVehiclesInChain(Vehicle *v)

   385

{

   386

	int count = 0;

   387

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

   388

	return count;

   389

}

   390

   391

   392

Depot *AllocateDepot()

   393

{

   394

	Depot *dep, *free_dep = NULL;

   395

	int num_free = 0;

   396

   397

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

   398

		if (dep->xy == 0) {

   399

			num_free++;

   400

			if (free_dep==NULL)

   401

				free_dep = dep;

   402

		}

   403

	}

   404

   405

	if (free_dep == NULL ||

   406

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

   407

		_error_message = STR_1009_TOO_MANY_DEPOTS;

   408

		return NULL;

   409

	}

   410

   411

	return free_dep;

   412

}

   413

   414

Waypoint *AllocateWaypoint()

   415

{

   416

	Waypoint *cp;

   417

   418

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

   419

		if (cp->xy == 0)

   420

			return cp;

   421

	}

   422

   423

	return NULL;

   424

}

   425

   426

uint GetWaypointByTile(uint tile)

   427

{

   428

	Waypoint *cp;

   429

	int i=0;

   430

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

   431

	return i;

   432

}

   433

   434

   435

Vehicle *IsScheduleShared(Vehicle *u)

   436

{

   437

	const Order *sched = u->schedule_ptr;

   438

	Vehicle *v;

   439

   440

	FOR_ALL_VEHICLES(v) {

   441

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

   442

			return v;

   443

	}

   444

	return NULL;

   445

}

   446

   447

void DeleteVehicleSchedule(Vehicle *v)

   448

{

   449

	Order *sched;

   450

	Order *cur;

   451

	int num;

   452

	Vehicle *u;

   453

   454

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

   455

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

   456

		v->schedule_ptr = NULL;

   457

		InvalidateWindow(WC_VEHICLE_ORDERS, u->index);

   458

		return;

   459

	}

   460

   461

	sched = v->schedule_ptr;

   462

	v->schedule_ptr = NULL;

   463

   464

	num = v->num_orders + 1;

   465

   466

	_ptr_to_next_order -= num;

   467

   468

	cur = sched;

   469

	while (cur != _ptr_to_next_order) {

   470

		assert(cur < _ptr_to_next_order);

   471

		cur[0] = cur[num];

   472

		cur++;

   473

	}

   474

   475

	FOR_ALL_VEHICLES(v) {

   476

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

   477

			v->schedule_ptr -= num;

   478

		}

   479

	}

   480

}

   481

   482

void DeleteCommandFromVehicleSchedule(Order cmd)

   483

{

   484

	Vehicle *v;

   485

	bool need_invalidate;

   486

   487

	FOR_ALL_VEHICLES(v) {

   488

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

   489

			Order *sched;

   490

   491

			// clear last station visited

   492

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

   494

   495

			// check the next order

   496

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

   497

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

   498

				v->current_order.type = OT_DUMMY;

   499

				v->current_order.flags = 0;

   500

				InvalidateWindow(WC_VEHICLE_VIEW, v->index);

   501

			}

   502

   503

			// clear the order list

   504

			need_invalidate = false;

   505

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

   506

				if (sched->type == cmd.type && sched->station == cmd.station) {

   507

					sched->type = OT_DUMMY;

   508

					sched->flags = 0;

   509

					need_invalidate = true;

   510

				}

   511

			}

   512

   513

			if (need_invalidate)

   514

				InvalidateWindow(WC_VEHICLE_ORDERS, v->index);

   515

		}

   516

	}

   517

}