1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "map.h"

     5

#include "vehicle.h"

     6

#include "command.h"

     7

#include "pathfind.h"

     8

#include "station.h"

     9

#include "table/train_cmd.h"

    10

#include "gfx.h"

    11

#include "news.h"

    12

#include "engine.h"

    13

#include "player.h"

    14

#include "sound.h"

    15

    16

#define is_firsthead_sprite(spritenum) \

    17

	(is_custom_sprite(spritenum) \

    18

		? is_custom_firsthead_sprite(spritenum) \

    19

		: _engine_sprite_add[spritenum] == 0)

    20

    21

static bool TrainCheckIfLineEnds(Vehicle *v);

    22

    23

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

    24

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

    25

static const byte _state_dir_table[4] = { 0x20, 8, 0x10, 4 };

    26

    27

static const byte _signal_onedir[14] = {

    28

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10, 0, 0,

    29

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20

    30

};

    31

    32

static const byte _signal_otherdir[14] = {

    33

	0x40, 0x40, 0x40, 0x10, 0x80, 0x20, 0, 0,

    34

	0x80, 0x80, 0x80, 0x20, 0x40, 0x10

    35

};

    36

    37

void UpdateTrainAcceleration(Vehicle *v)

    38

{

    39

	uint acc, power=0, max_speed=5000, weight=0;

    40

	Vehicle *u = v;

    41

    42

	assert(v->subtype == TS_Front_Engine);

    43

    44

	// compute stuff like max speed, power, and weight.

    45

	do {

    46

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

    47

    48

		// power is sum of the power for all engines

    49

		power += rvi->power;

    50

    51

		// limit the max speed to the speed of the slowest vehicle.

    52

		if (rvi->max_speed && rvi->max_speed <= max_speed) max_speed = rvi->max_speed;

    53

    54

		// weight is the sum of the weight of the wagon and the weight of the cargo.

    55

		weight += rvi->weight;

    56

		weight += (_cargoc.weights[u->cargo_type] * u->cargo_count) >> 4;

    57

    58

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

    59

    60

	// these are shown in the UI

    61

	v->u.rail.cached_weight = weight;

    62

	v->u.rail.cached_power = power;

    63

	v->max_speed = max_speed;

    64

    65

	assert(weight != 0);

    66

    67

	// compute acceleration

    68

	acc = power / weight * 4;

    69

    70

	if (acc >= 255) acc=255;

    71

	if (acc == 0) acc++;

    72

    73

	v->acceleration = (byte)acc;

    74

}

    75

    76

#define F_GRAV 9.82f

    77

#define F_THETA 0.05f

    78

    79

#define F_HP_KW 0.74569f

    80

#define F_KPH_MS 0.27778f

    81

#define F_MU 0.3f

    82

    83

#define F_COEF_FRIC 0.04f

    84

#define F_COEF_ROLL 0.18f

    85

    86

#define F_CURVE_FACTOR (1/96.f)

    87

    88

static int GetRealisticAcceleration(Vehicle *v)

    89

{

    90

	uint emass = 0;

    91

	Vehicle *u = v;

    92

	float f = 0.0f, spd;

    93

	int curves = 0;

    94

    95

	assert(v->subtype == TS_Front_Engine);

    96

    97

	// compute inclination force and number of curves.

    98

	do {

    99

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

   100

		uint mass = rvi->weight + ((_cargoc.weights[u->cargo_type] * u->cargo_count) >> 4);

   101

		if (rvi->power) emass += mass;

   102

   103

		if (!IsTileType(u->tile, MP_TUNNELBRIDGE)) {

   104

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

   105

				f += (float)mass * ( -F_GRAV * F_THETA);

   106

			} else if (HASBIT(u->u.rail.flags, VRF_GOINGDOWN)) {

   107

				f += (float)mass * ( F_GRAV * F_THETA);

   108

			}

   109

		}

   110

   111

		// compute curve penalty..

   112

		if (u->next != NULL) {

   113

			uint diff = (u->direction - u->next->direction) & 7;

   114

			if (diff) {

   115

				curves += (diff == 1 || diff == 7) ? 1 : 3;

   116

			}

   117

		}

   118

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

   119

   120

	spd = (float)(v->cur_speed ? v->cur_speed : 1);

   121

   122

	// compute tractive effort

   123

	{

   124

		float te = (float)v->u.rail.cached_power * (F_HP_KW/F_KPH_MS) / spd;

   125

		float te2 = (float)emass * (F_MU * F_GRAV);

   126

		if (te > te2) te = te2;

   127

		f += te;

   128

	}

   129

   130

	// add air resistance

   131

	{

   132

		float cx = 1.0f; // NOT DONE

   133

   134

		// air resistance is doubled in tunnels.

   135

		if (v->vehstatus == 0x40) cx *= 2;

   136

   137

		f -= cx * spd * spd * (F_KPH_MS * F_KPH_MS * 0.001f);

   138

	}

   139

   140

	// after this f contains the acceleration.

   141

	f /= (float)v->u.rail.cached_weight;

   142

   143

	// add friction to sum of forces (avoid mul by weight). (0.001 because we want kN)

   144

	f -= (F_COEF_FRIC * F_GRAV * 0.001f + (F_COEF_ROLL * F_KPH_MS * F_GRAV * 0.001f) * spd);

   145

   146

	// penalty for curves?

   147

	if (curves)

   148

		 f -= (float)min(curves, 8) * F_CURVE_FACTOR;

   149

   150

	return (int)(f  * (1.0/(F_KPH_MS * 0.015f)) + 0.5f);

   151

}

   152

   153

   154

int GetTrainImage(Vehicle *v, byte direction)

   155

{

   156

	int img = v->spritenum;

   157

	int base;

   158

   159

	if (is_custom_sprite(img)) {

   160

		base = GetCustomVehicleSprite(v, direction + 4 * is_custom_secondhead_sprite(img));

   161

		if (base) return base;

   162

		img = _engine_original_sprites[v->engine_type];

   163

	}

   164

   165

	base = _engine_sprite_base[img] + ((direction + _engine_sprite_add[img]) & _engine_sprite_and[img]);

   166

   167

	if (v->cargo_count >= (v->cargo_cap >> 1))

   168

		base += _wagon_full_adder[img];

   169

	return base;

   170

}

   171

   172

void DrawTrainEngine(int x, int y, int engine, uint32 image_ormod)

   173

{

   174

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   175

   176

	int img = rvi->image_index;

   177

	uint32 image = 0;

   178

   179

	if (is_custom_sprite(img)) {

   180

		image = GetCustomVehicleIcon(engine, 6);

   181

		if (!image) img = _engine_original_sprites[engine];

   182

	}

   183

	if (!image) {

   184

		image = (6 & _engine_sprite_and[img]) + _engine_sprite_base[img];

   185

	}

   186

   187

	if (rvi->flags & RVI_MULTIHEAD) {

   188

		DrawSprite(image | image_ormod, x-14, y);

   189

		x += 15;

   190

		image = 0;

   191

		if (is_custom_sprite(img)) {

   192

			image = GetCustomVehicleIcon(engine, 2);

   193

			if (!image) img = _engine_original_sprites[engine];

   194

		}

   195

		if (!image) {

   196

			image = ((6 + _engine_sprite_add[img+1]) & _engine_sprite_and[img+1]) + _engine_sprite_base[img+1];

   197

		}

   198

	}

   199

	DrawSprite(image | image_ormod, x, y);

   200

}

   201

   202

void DrawTrainEngineInfo(int engine, int x, int y, int maxw)

   203

{

   204

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   205

	int cap;

   206

	uint multihead = ((rvi->flags & RVI_MULTIHEAD) ? 1 : 0);

   207

   208

	SetDParam(0, ((_price.build_railvehicle >> 3) * rvi->base_cost) >> 5);

   209

	SetDParam(2, rvi->max_speed * 10 >> 4);

   210

	SetDParam(3, rvi->power << multihead);

   211

	SetDParam(1, rvi->weight << multihead);

   212

   213

	SetDParam(4, (rvi->running_cost_base * _price.running_rail[rvi->engclass] >> 8) << multihead);

   214

   215

	cap = rvi->capacity;

   216

	SetDParam(5, STR_8838_N_A);

   217

	if (cap != 0) {

   218

		SetDParam(6, cap << multihead);

   219

		SetDParam(5, _cargoc.names_long_p[rvi->cargo_type]);

   220

	}

   221

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   222

}

   223

   224

   225

static int32 CmdBuildRailWagon(uint engine, uint tile, uint32 flags)

   226

{

   227

	int32 value;

   228

	Vehicle *v;

   229

	const RailVehicleInfo *rvi;

   230

	int dir;

   231

	const Engine *e;

   232

	int x,y;

   233

   234

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   235

   236

	rvi = RailVehInfo(engine);

   237

	value = (rvi->base_cost * _price.build_railwagon) >> 8;

   238

   239

	if (!(flags & DC_QUERY_COST)) {

   240

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   241

   242

		v = AllocateVehicle();

   243

		if (v == NULL)

   244

			return CMD_ERROR;

   245

   246

		if (flags & DC_EXEC) {

   247

			byte img = rvi->image_index;

   248

			Vehicle *u, *w;

   249

   250

			v->spritenum = img;

   251

   252

			u = NULL;

   253

   254

			FOR_ALL_VEHICLES(w) {

   255

				if (w->type == VEH_Train && w->tile == (TileIndex)tile &&

   256

				    w->subtype == TS_Free_Car && w->engine_type == engine) {

   257

					u = GetLastVehicleInChain(w);

   258

					break;

   259

				}

   260

			}

   261

   262

			v->engine_type = engine;

   263

   264

			dir = _map5[tile] & 3;

   265

   266

			v->direction = (byte)(dir*2+1);

   267

			v->tile = (TileIndex)tile;

   268

   269

			x = TileX(tile) * 16 | _vehicle_initial_x_fract[dir];

   270

			y = TileY(tile) * 16 | _vehicle_initial_y_fract[dir];

   271

   272

			v->x_pos = x;

   273

			v->y_pos = y;

   274

			v->z_pos = GetSlopeZ(x,y);

   275

			v->owner = _current_player;

   276

			v->z_height = 6;

   277

			v->u.rail.track = 0x80;

   278

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   279

   280

			v->subtype = TS_Free_Car;

   281

			if (u != NULL) {

   282

				u->next = v;

   283

				v->subtype = TS_Not_First;

   284

				v->u.rail.first_engine = u->u.rail.first_engine;

   285

				if (v->u.rail.first_engine == 0xffff && u->subtype == TS_Front_Engine )

   286

					v->u.rail.first_engine = u->engine_type;

   287

			} else {

   288

				v->u.rail.first_engine = 0xffff;

   289

			}

   290

   291

			v->cargo_type = rvi->cargo_type;

   292

			v->cargo_cap = rvi->capacity;

   293

			v->value = value;

   294

//			v->day_counter = 0;

   295

   296

			e = &_engines[engine];

   297

			v->u.rail.railtype = e->railtype;

   298

   299

			v->build_year = _cur_year;

   300

			v->type = VEH_Train;

   301

			v->cur_image = 0xAC2;

   302

   303

			_new_wagon_id = v->index;

   304

   305

			VehiclePositionChanged(v);

   306

   307

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   308

		}

   309

	}

   310

   311

	return value;

   312

}

   313

   314

// Move all free vehicles in the depot to the train

   315

static void NormalizeTrainVehInDepot(Vehicle *u)

   316

{

   317

	Vehicle *v;

   318

	FOR_ALL_VEHICLES(v) {

   319

		if (v->type == VEH_Train && v->subtype == TS_Free_Car &&

   320

				v->tile == u->tile &&

   321

				v->u.rail.track == 0x80) {

   322

			if (DoCommandByTile(0,v->index | (u->index<<16), 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE) == CMD_ERROR)

   323

				break;

   324

		}

   325

	}

   326

}

   327

   328

static const byte _railveh_unk1[] = {

   329

	0, 0, 0, 0, 0, 0, 0, 0,

   330

	0, 0, 0, 1, 1, 0, 0, 0,

   331

	0, 0, 0, 0, 1, 0, 1, 0,

   332

	0, 1, 1, 0, 0, 0, 0, 0,

   333

	0, 0, 0, 0, 0, 0, 0, 0,

   334

	0, 0, 0, 0, 0, 0, 0, 0,

   335

	0, 0, 0, 0, 0, 0, 0, 1,

   336

	0, 0, 0, 0, 0, 0, 0, 0,

   337

	0, 0, 0, 0, 0, 0, 0, 0,

   338

	0, 0, 0, 0, 0, 0, 0, 0,

   339

	0, 0, 0, 0, 0, 0, 0, 0,

   340

	0, 0, 0, 0, 0, 0, 0, 0,

   341

	0, 0, 0, 0, 0, 0, 0, 0,

   342

	0, 0, 0, 0, 0, 0, 0, 0,

   343

	0, 0, 0, 0,

   344

};

   345

   346

static const byte _railveh_score[] = {

   347

	1, 4, 7, 19, 20, 30, 31, 19,

   348

	20, 21, 22, 10, 11, 30, 31, 32,

   349

	33, 34, 35, 29, 45, 32, 50, 40,

   350

	41, 51, 52, 0, 0, 0, 0, 0,

   351

	0, 0, 0, 0, 0, 0, 0, 0,

   352

	0, 0, 0, 0, 0, 0, 0, 0,

   353

	0, 0, 0, 0, 0, 0, 60, 62,

   354

	63, 0, 0, 0, 0, 0, 0, 0,

   355

	0, 0, 0, 0, 0, 0, 0, 0,

   356

	0, 0, 0, 0, 0, 0, 0, 0,

   357

	0, 0, 0, 0, 70, 71, 72, 73,

   358

	74, 0, 0, 0, 0, 0, 0, 0,

   359

	0, 0, 0, 0, 0, 0, 0, 0,

   360

	0, 0, 0, 0, 0, 0, 0, 0,

   361

	0, 0, 0, 0,

   362

};

   363

   364

   365

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   366

{

   367

	return (rvi->base_cost * (_price.build_railvehicle >> 3)) >> 5;

   368

}

   369

   370

void AddRearEngineToMultiheadedTrain(Vehicle *v, Vehicle *u, bool building) 

   371

{

   372

	u->direction = v->direction;

   373

	u->owner = v->owner;

   374

	u->tile = v->tile;

   375

	u->x_pos = v->x_pos;

   376

	u->y_pos = v->y_pos;

   377

	u->z_pos = v->z_pos;

   378

	u->z_height = 6;

   379

	u->u.rail.track = 0x80;

   380

	v->u.rail.first_engine = 0xffff;

   381

	u->vehstatus = v->vehstatus & ~VS_STOPPED;

   382

	u->subtype = TS_Not_First;

   383

	u->spritenum = v->spritenum + 1;

   384

	u->cargo_type = v->cargo_type;

   385

	u->cargo_cap = v->cargo_cap;

   386

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

   387

	if (building) v->next = u;

   388

	u->engine_type = v->engine_type;

   389

	u->build_year = v->build_year;

   390

	if (building) 

   391

		v->value = u->value = v->value >> 1;

   392

	else

   393

		u->value = v->value;

   394

	u->type = VEH_Train;

   395

	u->cur_image = 0xAC2;

   396

	VehiclePositionChanged(u);

   397

}

   398

   399

/* Build a railroad vehicle

   400

 * p1 = vehicle type id

   401

 */

   402

   403

int32 CmdBuildRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)

   404

{

   405

	const RailVehicleInfo *rvi;

   406

	int value,dir;

   407

	Vehicle *v, *u;

   408

	byte unit_num;

   409

	Engine *e;

   410

	uint tile;

   411

   412

	_cmd_build_rail_veh_var1 = 0;

   413

   414

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   415

   416

	tile = TILE_FROM_XY(x,y);

   417

	rvi = RailVehInfo(p1);

   418

   419

	if (rvi->flags & RVI_WAGON) {

   420

		return CmdBuildRailWagon(p1, tile, flags);

   421

	}

   422

   423

	value = EstimateTrainCost(rvi);

   424

   425

	if (!(flags & DC_QUERY_COST)) {

   426

		v = AllocateVehicle();

   427

		if (v == NULL || IsOrderPoolFull())

   428

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   429

   430

		unit_num = GetFreeUnitNumber(VEH_Train);

   431

		if (unit_num > _patches.max_trains)

   432

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   433

   434

		if (flags & DC_EXEC) {

   435

			v->unitnumber = unit_num;

   436

   437

			dir = _map5[tile] & 3;

   438

   439

			v->direction = (byte)(dir*2+1);

   440

			v->tile = (TileIndex)tile;

   441

			v->owner = _current_player;

   442

			v->x_pos = (x |= _vehicle_initial_x_fract[dir]);

   443

			v->y_pos = (y |= _vehicle_initial_y_fract[dir]);

   444

			v->z_pos = GetSlopeZ(x,y);

   445

			v->z_height = 6;

   446

			v->u.rail.track = 0x80;

   447

			v->u.rail.first_engine = 0xffff;

   448

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   449

			v->spritenum = rvi->image_index;

   450

			v->cargo_type = rvi->cargo_type;

   451

			v->cargo_cap = rvi->capacity;

   452

			v->max_speed = rvi->max_speed;

   453

			v->value = value;

   454

			v->last_station_visited = 0xFFFF;

   455

			v->dest_tile = 0;

   456

   457

			v->engine_type = (byte)p1;

   458

			e = &_engines[p1];

   459

   460

			v->reliability = e->reliability;

   461

			v->reliability_spd_dec = e->reliability_spd_dec;

   462

			v->max_age = e->lifelength * 366;

   463

   464

			v->string_id = STR_SV_TRAIN_NAME;

   465

			v->u.rail.railtype = e->railtype;

   466

			_new_train_id = v->index;

   467

   468

			v->service_interval = _patches.servint_trains;

   469

			v->date_of_last_service = _date;

   470

			v->build_year = _cur_year;

   471

			v->type = VEH_Train;

   472

			v->cur_image = 0xAC2;

   473

   474

			VehiclePositionChanged(v);

   475

   476

			if (rvi->flags&RVI_MULTIHEAD && (u = AllocateVehicle()) != NULL)

   477

				AddRearEngineToMultiheadedTrain(v, u, true);

   478

   479

			UpdateTrainAcceleration(v);

   480

			NormalizeTrainVehInDepot(v);

   481

   482

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   483

			RebuildVehicleLists();

   484

			InvalidateWindow(WC_COMPANY, v->owner);

   485

		}

   486

	}

   487

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   488

	_cmd_build_rail_veh_score = _railveh_score[p1];

   489

	return value;

   490

}

   491

   492

   493

bool IsTrainDepotTile(TileIndex tile)

   494

{

   495

	return IsTileType(tile, MP_RAILWAY) &&

   496

					(_map5[tile] & 0xFC) == 0xC0;

   497

}

   498

   499

static bool IsTunnelTile(TileIndex tile)

   500

{

   501

	return IsTileType(tile, MP_TUNNELBRIDGE) &&

   502

				 (_map5[tile]&0x80) == 0;

   503

}

   504

   505

   506

int CheckStoppedInDepot(Vehicle *v)

   507

{

   508

	int count;

   509

	TileIndex tile = v->tile;

   510

   511

	/* check if stopped in a depot */

   512

	if (!IsTrainDepotTile(tile) || v->cur_speed != 0) {

   513

errmsg:

   514

		_error_message = STR_881A_TRAINS_CAN_ONLY_BE_ALTERED;

   515

		return -1;