1

/* $Id$ */

     2

     3

/** @file train_cmd.cpp Handling of trains. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "bridge_map.h"

     8

#include "debug.h"

     9

#include "tile_cmd.h"

    10

#include "landscape.h"

    11

#include "gui.h"

    12

#include "station_map.h"

    13

#include "tunnel_map.h"

    14

#include "articulated_vehicles.h"

    15

#include "command_func.h"

    16

#include "pathfind.h"

    17

#include "npf.h"

    18

#include "station_base.h"

    19

#include "news_func.h"

    20

#include "engine_func.h"

    21

#include "engine_base.h"

    22

#include "player_func.h"

    23

#include "player_base.h"

    24

#include "depot_base.h"

    25

#include "depot_func.h"

    26

#include "waypoint.h"

    27

#include "vehicle_gui.h"

    28

#include "train.h"

    29

#include "bridge.h"

    30

#include "newgrf_callbacks.h"

    31

#include "newgrf_engine.h"

    32

#include "newgrf_sound.h"

    33

#include "newgrf_text.h"

    34

#include "direction_func.h"

    35

#include "yapf/yapf.h"

    36

#include "yapf/follow_track.hpp"

    37

#include "cargotype.h"

    38

#include "group.h"

    39

#include "table/sprites.h"

    40

#include "tunnelbridge_map.h"

    41

#include "strings_func.h"

    42

#include "functions.h"

    43

#include "window_func.h"

    44

#include "date_func.h"

    45

#include "vehicle_func.h"

    46

#include "sound_func.h"

    47

#include "signal_func.h"

    48

#include "variables.h"

    49

#include "autoreplace_gui.h"

    50

#include "gfx_func.h"

    51

#include "settings_type.h"

    52

#include "order_func.h"

    53

#include "newgrf_station.h"

    54

#include "effectvehicle_func.h"

    55

#include "gamelog.h"

    56

#include "network/network.h"

    57

#include "pbs.h"

    58

    59

#include "table/strings.h"

    60

#include "table/train_cmd.h"

    61

    62

static Track ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir, TrackBits tracks, bool force_res, bool *got_reservation, bool mark_stuck);

    63

static bool TrainCheckIfLineEnds(Vehicle *v);

    64

static void TrainController(Vehicle *v, Vehicle *nomove, bool update_image);

    65

static TileIndex TrainApproachingCrossingTile(const Vehicle *v);

    66

static void CheckIfTrainNeedsService(Vehicle *v);

    67

static void CheckNextTrainTile(Vehicle *v);

    68

    69

static const byte _vehicle_initial_x_fract[4] = {10, 8, 4,  8};

    70

static const byte _vehicle_initial_y_fract[4] = { 8, 4, 8, 10};

    71

    72

    73

/**

    74

 * Determine the side in which the train will leave the tile

    75

 *

    76

 * @param direction vehicle direction

    77

 * @param track vehicle track bits

    78

 * @return side of tile the train will leave

    79

 */

    80

static inline DiagDirection TrainExitDir(Direction direction, TrackBits track)

    81

{

    82

	static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };

    83

    84

	DiagDirection diagdir = DirToDiagDir(direction);

    85

    86

	/* Determine the diagonal direction in which we will exit this tile */

    87

	if (!HasBit(direction, 0) && track != state_dir_table[diagdir]) {

    88

		diagdir = ChangeDiagDir(diagdir, DIAGDIRDIFF_90LEFT);

    89

	}

    90

    91

	return diagdir;

    92

}

    93

    94

    95

/** Return the cargo weight multiplier to use for a rail vehicle

    96

 * @param cargo Cargo type to get multiplier for

    97

 * @return Cargo weight multiplier

    98

 */

    99

byte FreightWagonMult(CargoID cargo)

   100

{

   101

	if (!GetCargo(cargo)->is_freight) return 1;

   102

	return _settings_game.vehicle.freight_trains;

   103

}

   104

   105

   106

/**

   107

 * Recalculates the cached total power of a train. Should be called when the consist is changed

   108

 * @param v First vehicle of the consist.

   109

 */

   110

void TrainPowerChanged(Vehicle *v)

   111

{

   112

	uint32 total_power = 0;

   113

	uint32 max_te = 0;

   114

   115

	for (const Vehicle *u = v; u != NULL; u = u->Next()) {

   116

		RailType railtype = GetRailType(u->tile);

   117

   118

		/* Power is not added for articulated parts */

   119

		if (!IsArticulatedPart(u)) {

   120

			bool engine_has_power = HasPowerOnRail(u->u.rail.railtype, railtype);

   121

   122

			const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

   123

   124

			if (engine_has_power) {

   125

				uint16 power = GetVehicleProperty(u, 0x0B, rvi_u->power);

   126

				if (power != 0) {

   127

					/* Halve power for multiheaded parts */

   128

					if (IsMultiheaded(u)) power /= 2;

   129

   130

					total_power += power;

   131

					/* Tractive effort in (tonnes * 1000 * 10 =) N */

   132

					max_te += (u->u.rail.cached_veh_weight * 10000 * GetVehicleProperty(u, 0x1F, rvi_u->tractive_effort)) / 256;

   133

				}

   134

			}

   135

		}

   136

   137

		if (HasBit(u->u.rail.flags, VRF_POWEREDWAGON) && HasPowerOnRail(v->u.rail.railtype, railtype)) {

   138

			total_power += RailVehInfo(u->u.rail.first_engine)->pow_wag_power;

   139

		}

   140

	}

   141

   142

	if (v->u.rail.cached_power != total_power || v->u.rail.cached_max_te != max_te) {

   143

		/* If it has no power (no catenary), stop the train */

   144

		if (total_power == 0) v->vehstatus |= VS_STOPPED;

   145

   146

		v->u.rail.cached_power = total_power;

   147

		v->u.rail.cached_max_te = max_te;

   148

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   149

		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);

   150

	}

   151

}

   152

   153

   154

/**

   155

 * Recalculates the cached weight of a train and its vehicles. Should be called each time the cargo on

   156

 * the consist changes.

   157

 * @param v First vehicle of the consist.

   158

 */

   159

static void TrainCargoChanged(Vehicle *v)

   160

{

   161

	uint32 weight = 0;

   162

   163

	for (Vehicle *u = v; u != NULL; u = u->Next()) {

   164

		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo.Count() * FreightWagonMult(u->cargo_type) / 16;

   165

   166

		/* Vehicle weight is not added for articulated parts. */

   167

		if (!IsArticulatedPart(u)) {

   168

			/* vehicle weight is the sum of the weight of the vehicle and the weight of its cargo */

   169

			vweight += GetVehicleProperty(u, 0x16, RailVehInfo(u->engine_type)->weight);

   170

		}

   171

   172

		/* powered wagons have extra weight added */

   173

		if (HasBit(u->u.rail.flags, VRF_POWEREDWAGON)) {

   174

			vweight += RailVehInfo(u->u.rail.first_engine)->pow_wag_weight;

   175

		}

   176

   177

		/* consist weight is the sum of the weight of all vehicles in the consist */

   178

		weight += vweight;

   179

   180

		/* store vehicle weight in cache */

   181

		u->u.rail.cached_veh_weight = vweight;

   182

	}

   183

   184

	/* store consist weight in cache */

   185

	v->u.rail.cached_weight = weight;

   186

   187

	/* Now update train power (tractive effort is dependent on weight) */

   188

	TrainPowerChanged(v);

   189

}

   190

   191

   192

/** Logs a bug in GRF and shows a warning message if this

   193

 * is for the first time this happened.

   194

 * @param u first vehicle of chain

   195

 */

   196

static void RailVehicleLengthChanged(const Vehicle *u)

   197

{

   198

	/* show a warning once for each engine in whole game and once for each GRF after each game load */

   199

	const Engine *engine = GetEngine(u->engine_type);

   200

	uint32 grfid = engine->grffile->grfid;

   201

	GRFConfig *grfconfig = GetGRFConfig(grfid);

   202

	if (GamelogGRFBugReverse(grfid, engine->internal_id) || !HasBit(grfconfig->grf_bugs, GBUG_VEH_LENGTH)) {

   203

		SetBit(grfconfig->grf_bugs, GBUG_VEH_LENGTH);

   204

		SetDParamStr(0, grfconfig->name);

   205

		SetDParam(1, u->engine_type);

   206

		ShowErrorMessage(STR_NEWGRF_BROKEN_VEHICLE_LENGTH, STR_NEWGRF_BROKEN, 0, 0);

   207

   208

		/* debug output */

   209

		char buffer[512];

   210

   211

		SetDParamStr(0, grfconfig->name);

   212

		GetString(buffer, STR_NEWGRF_BROKEN, lastof(buffer));

   213

		DEBUG(grf, 0, "%s", buffer + 3);

   214

   215

		SetDParam(1, u->engine_type);

   216

		GetString(buffer, STR_NEWGRF_BROKEN_VEHICLE_LENGTH, lastof(buffer));

   217

		DEBUG(grf, 0, "%s", buffer + 3);

   218

   219

		if (!_networking) _pause_game = -1;

   220

	}

   221

}

   222

   223

/** Checks if lengths of all rail vehicles are valid. If not, shows an error message. */

   224

void CheckTrainsLengths()

   225

{

   226

	const Vehicle *v;

   227

   228

	FOR_ALL_VEHICLES(v) {

   229

		if (v->type == VEH_TRAIN && v->First() == v && !(v->vehstatus & VS_CRASHED)) {

   230

			for (const Vehicle *u = v, *w = v->Next(); w != NULL; u = w, w = w->Next()) {

   231

				if (u->u.rail.track != TRACK_BIT_DEPOT) {

   232

					if ((w->u.rail.track != TRACK_BIT_DEPOT &&

   233

							max(abs(u->x_pos - w->x_pos), abs(u->y_pos - w->y_pos)) != u->u.rail.cached_veh_length) ||

   234

							(w->u.rail.track == TRACK_BIT_DEPOT && TicksToLeaveDepot(u) <= 0)) {

   235

						SetDParam(0, v->index);

   236

						SetDParam(1, v->owner);

   237

						ShowErrorMessage(INVALID_STRING_ID, STR_BROKEN_VEHICLE_LENGTH, 0, 0);

   238

   239

						if (!_networking) _pause_game = -1;

   240

					}

   241

				}

   242

			}

   243

		}

   244

	}

   245

}

   246

   247

/**

   248

 * Recalculates the cached stuff of a train. Should be called each time a vehicle is added

   249

 * to/removed from the chain, and when the game is loaded.

   250

 * Note: this needs to be called too for 'wagon chains' (in the depot, without an engine)

   251

 * @param v First vehicle of the chain.

   252

 * @param same_length should length of vehicles stay the same?

   253

 */

   254

void TrainConsistChanged(Vehicle *v, bool same_length)

   255

{

   256

	uint16 max_speed = UINT16_MAX;

   257

   258

	assert(v->type == VEH_TRAIN);

   259

	assert(IsFrontEngine(v) || IsFreeWagon(v));

   260

   261

	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);

   262

	EngineID first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;

   263

	v->u.rail.cached_total_length = 0;

   264

	v->u.rail.compatible_railtypes = RAILTYPES_NONE;

   265

   266

	bool train_can_tilt = true;

   267

   268

	for (Vehicle *u = v; u != NULL; u = u->Next()) {

   269

		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

   270

   271

		/* Check the v->first cache. */

   272

		assert(u->First() == v);

   273

   274

		/* update the 'first engine' */

   275

		u->u.rail.first_engine = v == u ? INVALID_ENGINE : first_engine;

   276

		u->u.rail.railtype = rvi_u->railtype;

   277

   278

		if (IsTrainEngine(u)) first_engine = u->engine_type;

   279

   280

		/* Set user defined data to its default value */

   281

		u->u.rail.user_def_data = rvi_u->user_def_data;

   282

	}

   283

   284

	for (Vehicle *u = v; u != NULL; u = u->Next()) {

   285

		/* Update user defined data (must be done before other properties) */

   286

		u->u.rail.user_def_data = GetVehicleProperty(u, 0x25, u->u.rail.user_def_data);

   287

	}

   288

   289

	for (Vehicle *u = v; u != NULL; u = u->Next()) {

   290

		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);

   291

   292

		if (!HasBit(EngInfo(u->engine_type)->misc_flags, EF_RAIL_TILTS)) train_can_tilt = false;

   293

   294

		/* Cache wagon override sprite group. NULL is returned if there is none */

   295

		u->u.rail.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->u.rail.first_engine);

   296

   297

		/* Reset color map */

   298

		u->colormap = PAL_NONE;

   299

   300

		if (rvi_u->visual_effect != 0) {

   301

			u->u.rail.cached_vis_effect = rvi_u->visual_effect;

   302

		} else {

   303

			if (IsTrainWagon(u) || IsArticulatedPart(u)) {

   304

				/* Wagons and articulated parts have no effect by default */

   305

				u->u.rail.cached_vis_effect = 0x40;

   306

			} else if (rvi_u->engclass == 0) {

   307

				/* Steam is offset by -4 units */

   308

				u->u.rail.cached_vis_effect = 4;

   309

			} else {

   310

				/* Diesel fumes and sparks come from the centre */

   311

				u->u.rail.cached_vis_effect = 8;

   312

			}

   313

		}

   314

   315

		/* Check powered wagon / visual effect callback */

   316

		if (HasBit(EngInfo(u->engine_type)->callbackmask, CBM_TRAIN_WAGON_POWER)) {

   317

			uint16 callback = GetVehicleCallback(CBID_TRAIN_WAGON_POWER, 0, 0, u->engine_type, u);

   318

   319

			if (callback != CALLBACK_FAILED) u->u.rail.cached_vis_effect = GB(callback, 0, 8);

   320

		}

   321

   322

		if (rvi_v->pow_wag_power != 0 && rvi_u->railveh_type == RAILVEH_WAGON &&

   323

			UsesWagonOverride(u) && !HasBit(u->u.rail.cached_vis_effect, 7)) {

   324

			/* wagon is powered */

   325

			SetBit(u->u.rail.flags, VRF_POWEREDWAGON); // cache 'powered' status

   326

		} else {

   327

			ClrBit(u->u.rail.flags, VRF_POWEREDWAGON);

   328

		}

   329

   330

		if (!IsArticulatedPart(u)) {

   331

			/* Do not count powered wagons for the compatible railtypes, as wagons always

   332

			   have railtype normal */

   333

			if (rvi_u->power > 0) {

   334

				v->u.rail.compatible_railtypes |= GetRailTypeInfo(u->u.rail.railtype)->powered_railtypes;

   335

			}

   336

   337

			/* Some electric engines can be allowed to run on normal rail. It happens to all

   338

			 * existing electric engines when elrails are disabled and then re-enabled */

   339

			if (HasBit(u->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL)) {

   340

				u->u.rail.railtype = RAILTYPE_RAIL;

   341

				u->u.rail.compatible_railtypes |= RAILTYPES_RAIL;

   342

			}

   343

   344

			/* max speed is the minimum of the speed limits of all vehicles in the consist */

   345

			if ((rvi_u->railveh_type != RAILVEH_WAGON || _settings_game.vehicle.wagon_speed_limits) && !UsesWagonOverride(u)) {

   346

				uint16 speed = GetVehicleProperty(u, 0x09, rvi_u->max_speed);

   347

				if (speed != 0) max_speed = min(speed, max_speed);

   348

			}

   349

		}

   350

   351

		if (u->cargo_type == rvi_u->cargo_type && u->cargo_subtype == 0) {

   352

			/* Set cargo capacity if we've not been refitted */

   353

			u->cargo_cap = GetVehicleProperty(u, 0x14, rvi_u->capacity);

   354

		}

   355

   356

		/* check the vehicle length (callback) */

   357

		uint16 veh_len = CALLBACK_FAILED;

   358

		if (HasBit(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {

   359

			veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, u->engine_type, u);

   360

		}

   361

		if (veh_len == CALLBACK_FAILED) veh_len = rvi_u->shorten_factor;

   362

		veh_len = 8 - Clamp(veh_len, 0, u->Next() == NULL ? 7 : 5); // the clamp on vehicles not the last in chain is stricter, as too short wagons can break the 'follow next vehicle' code

   363

   364

		/* verify length hasn't changed */

   365

		if (same_length && veh_len != u->u.rail.cached_veh_length) RailVehicleLengthChanged(u);

   366

   367

		/* update vehicle length? */

   368

		if (!same_length) u->u.rail.cached_veh_length = veh_len;

   369

   370

		v->u.rail.cached_total_length += u->u.rail.cached_veh_length;

   371

	}

   372

   373

	/* store consist weight/max speed in cache */

   374

	v->u.rail.cached_max_speed = max_speed;

   375

	v->u.rail.cached_tilt = train_can_tilt;

   376

   377

	/* recalculate cached weights and power too (we do this *after* the rest, so it is known which wagons are powered and need extra weight added) */

   378

	TrainCargoChanged(v);

   379

   380

	if (IsFrontEngine(v)) {

   381

		UpdateTrainAcceleration(v);

   382

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

   383

	}

   384

}

   385

   386

enum AccelType {

   387

	AM_ACCEL,

   388

	AM_BRAKE

   389

};

   390

   391

/** new acceleration*/

   392

static int GetTrainAcceleration(Vehicle *v, bool mode)

   393

{

   394

	static const int absolute_max_speed = UINT16_MAX;

   395

	int max_speed = absolute_max_speed;

   396

	int speed = v->cur_speed * 10 / 16; // km-ish/h -> mp/h

   397

	int curvecount[2] = {0, 0};

   398

   399

	/*first find the curve speed limit */

   400

	int numcurve = 0;

   401

	int sum = 0;

   402

	int pos = 0;

   403

	int lastpos = -1;

   404

	for (const Vehicle *u = v; u->Next() != NULL; u = u->Next(), pos++) {

   405

		Direction this_dir = u->direction;

   406

		Direction next_dir = u->Next()->direction;

   407

   408

		DirDiff dirdiff = DirDifference(this_dir, next_dir);

   409

		if (dirdiff == DIRDIFF_SAME) continue;

   410

   411

		if (dirdiff == DIRDIFF_45LEFT) curvecount[0]++;

   412

		if (dirdiff == DIRDIFF_45RIGHT) curvecount[1]++;

   413

		if (dirdiff == DIRDIFF_45LEFT || dirdiff == DIRDIFF_45RIGHT) {

   414

			if (lastpos != -1) {

   415

				numcurve++;

   416

				sum += pos - lastpos;

   417

				if (pos - lastpos == 1) {

   418

					max_speed = 88;

   419

				}

   420

			}

   421

			lastpos = pos;

   422

		}

   423

   424

		/*if we have a 90 degree turn, fix the speed limit to 60 */

   425

		if (dirdiff == DIRDIFF_90LEFT || dirdiff == DIRDIFF_90RIGHT) {

   426

			max_speed = 61;

   427

		}

   428

	}

   429

   430

	if ((curvecount[0] != 0 || curvecount[1] != 0) && max_speed > 88) {

   431

		int total = curvecount[0] + curvecount[1];

   432

   433

		if (curvecount[0] == 1 && curvecount[1] == 1) {

   434

			max_speed = absolute_max_speed;

   435

		} else if (total > 1) {

   436

			if (numcurve > 0) sum /= numcurve;

   437

			max_speed = 232 - (13 - Clamp(sum, 1, 12)) * (13 - Clamp(sum, 1, 12));

   438

		}

   439

	}

   440

   441

	if (max_speed != absolute_max_speed) {

   442

		/* Apply the engine's rail type curve speed advantage, if it slowed by curves */

   443

		const RailtypeInfo *rti = GetRailTypeInfo(v->u.rail.railtype);

   444

		max_speed += (max_speed / 2) * rti->curve_speed;

   445

   446

		if (v->u.rail.cached_tilt) {

   447

			/* Apply max_speed bonus of 20% for a tilting train */

   448

			max_speed += max_speed / 5;

   449

		}

   450

	}

   451

   452

	if (IsTileType(v->tile, MP_STATION) && IsFrontEngine(v)) {

   453

		if (v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) {

   454

			int station_length = GetStationByTile(v->tile)->GetPlatformLength(v->tile, DirToDiagDir(v->direction));

   455

   456

			int st_max_speed = 120;

   457

   458

			int delta_v = v->cur_speed / (station_length + 1);

   459

			if (v->max_speed > (v->cur_speed - delta_v)) {

   460

				st_max_speed = v->cur_speed - (delta_v / 10);

   461

			}

   462

   463

			st_max_speed = max(st_max_speed, 25 * station_length);

   464

			max_speed = min(max_speed, st_max_speed);

   465

		}

   466

	}

   467

   468

	int mass = v->u.rail.cached_weight;

   469

	int power = v->u.rail.cached_power * 746;

   470

	max_speed = min(max_speed, v->u.rail.cached_max_speed);

   471

   472

	int num = 0; //number of vehicles, change this into the number of axles later

   473

	int incl = 0;

   474

	int drag_coeff = 20; //[1e-4]

   475

	for (const Vehicle *u = v; u != NULL; u = u->Next()) {

   476

		num++;

   477

		drag_coeff += 3;

   478

   479

		if (u->u.rail.track == TRACK_BIT_DEPOT) max_speed = min(max_speed, 61);

   480

   481

		if (HasBit(u->u.rail.flags, VRF_GOINGUP)) {

   482

			incl += u->u.rail.cached_veh_weight * 60; //3% slope, quite a bit actually