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 == 0);

    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 == 0);

    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 (HASBIT(u->u.rail.flags, VRF_GOINGUP)) {

   104

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

   105

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

   106

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

   107

		}

   108

   109

		// compute curve penalty..

   110

		if (u->next != NULL) {

   111

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

   112

			if (diff) {

   113

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

   114

			}

   115

		}

   116

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

   117

   118

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

   119

   120

	// compute tractive effort

   121

	{

   122

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

   123

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

   124

		if (te > te2) te = te2;

   125

		f += te;

   126

	}

   127

   128

	// add air resistance

   129

	{

   130

		float cx = 1.0f; // NOT DONE

   131

   132

		// air resistance is doubled in tunnels.

   133

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

   134

   135

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

   136

	}

   137

   138

	// after this f contains the acceleration.

   139

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

   140

   141

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

   142

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

   143

   144

	// penalty for curves?

   145

	if (curves)

   146

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

   147

   148

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

   149

}

   150

   151

   152

int GetTrainImage(Vehicle *v, byte direction)

   153

{

   154

	int img = v->spritenum;

   155

	int base;

   156

   157

	if (is_custom_sprite(img)) {

   158

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

   159

		if (base) return base;

   160

		img = _engine_original_sprites[v->engine_type];

   161

	}

   162

   163

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

   164

   165

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

   166

		base += _wagon_full_adder[img];

   167

	return base;

   168

}

   169

   170

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

   171

{

   172

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   173

   174

	int img = rvi->image_index;

   175

	uint32 image = 0;

   176

   177

	if (is_custom_sprite(img)) {

   178

		image = GetCustomVehicleIcon(engine, 6);

   179

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

   180

	}

   181

	if (!image) {

   182

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

   183

	}

   184

   185

	if (rvi->flags & RVI_MULTIHEAD) {

   186

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

   187

		x += 15;

   188

		image = 0;

   189

		if (is_custom_sprite(img)) {

   190

			image = GetCustomVehicleIcon(engine, 2);

   191

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

   192

		}

   193

		if (!image) {

   194

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

   195

		}

   196

	}

   197

	DrawSprite(image | image_ormod, x, y);

   198

}

   199

   200

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

   201

{

   202

	const RailVehicleInfo *rvi = RailVehInfo(engine);

   203

	int cap;

   204

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

   205

   206

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

   207

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

   208

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

   209

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

   210

   211

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

   212

   213

	cap = rvi->capacity;

   214

	SetDParam(5, STR_8838_N_A);

   215

	if (cap != 0) {

   216

		SetDParam(6, cap << multihead);

   217

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

   218

	}

   219

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

   220

}

   221

   222

   223

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

   224

{

   225

	int32 value;

   226

	Vehicle *v;

   227

	const RailVehicleInfo *rvi;

   228

	int dir;

   229

	const Engine *e;

   230

	int x,y;

   231

   232

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   233

   234

	rvi = RailVehInfo(engine);

   235

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

   236

   237

	if (!(flags & DC_QUERY_COST)) {

   238

		_error_message = STR_00E1_TOO_MANY_VEHICLES_IN_GAME;

   239

   240

		v = AllocateVehicle();

   241

		if (v == NULL)

   242

			return CMD_ERROR;

   243

   244

		if (flags & DC_EXEC) {

   245

			byte img = rvi->image_index;

   246

			Vehicle *u, *w;

   247

   248

			v->spritenum = img;

   249

   250

			u = NULL;

   251

   252

			FOR_ALL_VEHICLES(w) {

   253

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

   254

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

   255

					u = GetLastVehicleInChain(w);

   256

					break;

   257

				}

   258

			}

   259

   260

			v->engine_type = engine;

   261

   262

			dir = _map5[tile] & 3;

   263

   264

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

   265

			v->tile = (TileIndex)tile;

   266

   267

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

   268

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

   269

   270

			v->x_pos = x;

   271

			v->y_pos = y;

   272

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

   273

			v->owner = _current_player;

   274

			v->z_height = 6;

   275

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

   276

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   277

   278

			v->subtype = 4;

   279

			if (u != NULL) {

   280

				u->next = v;

   281

				v->subtype = 2;

   282

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

   283

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

   284

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

   285

			} else {

   286

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

   287

			}

   288

   289

			v->cargo_type = rvi->cargo_type;

   290

			v->cargo_cap = rvi->capacity;

   291

			v->value = value;

   292

//			v->day_counter = 0;

   293

   294

			e = &_engines[engine];

   295

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

   296

   297

			v->build_year = _cur_year;

   298

			v->type = VEH_Train;

   299

			v->cur_image = 0xAC2;

   300

   301

			_new_wagon_id = v->index;

   302

   303

			VehiclePositionChanged(v);

   304

   305

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   306

		}

   307

	}

   308

   309

	return value;

   310

}

   311

   312

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

   313

static void NormalizeTrainVehInDepot(Vehicle *u)

   314

{

   315

	Vehicle *v;

   316

	FOR_ALL_VEHICLES(v) {

   317

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

   318

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

   319

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

   320

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

   321

				break;

   322

		}

   323

	}

   324

}

   325

   326

static const byte _railveh_unk1[] = {

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

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

   334

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

   335

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

   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,

   342

};

   343

   344

static const byte _railveh_score[] = {

   345

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

   346

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

   347

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

   348

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

   349

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

   350

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

   351

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

   352

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

   353

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

   354

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

   355

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

   356

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

   357

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

   358

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

   359

	0, 0, 0, 0,

   360

};

   361

   362

   363

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   364

{

   365

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

   366

}

   367

   368

/* Build a railroad vehicle

   369

 * p1 = vehicle type id

   370

 */

   371

   372

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

   373

{

   374

	const RailVehicleInfo *rvi;

   375

	int value,dir;

   376

	Vehicle *v, *u;

   377

	byte unit_num;

   378

	Engine *e;

   379

	uint tile;

   380

   381

	_cmd_build_rail_veh_var1 = 0;

   382

   383

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   384

   385

	tile = TILE_FROM_XY(x,y);

   386

	rvi = RailVehInfo(p1);

   387

   388

	if (rvi->flags & RVI_WAGON) {

   389

		return CmdBuildRailWagon(p1, tile, flags);

   390

	}

   391

   392

	value = EstimateTrainCost(rvi);

   393

   394

	if (!(flags & DC_QUERY_COST)) {

   395

		v = AllocateVehicle();

   396

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

   397

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   398

   399

		unit_num = GetFreeUnitNumber(VEH_Train);

   400

		if (unit_num > _patches.max_trains)

   401

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   402

   403

		if (flags & DC_EXEC) {

   404

			v->unitnumber = unit_num;

   405

   406

			dir = _map5[tile] & 3;

   407

   408

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

   409

			v->tile = (TileIndex)tile;

   410

			v->owner = _current_player;

   411

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

   412

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

   413

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

   414

			v->z_height = 6;

   415

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

   416

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

   417

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   418

			v->spritenum = rvi->image_index;

   419

			v->cargo_type = rvi->cargo_type;

   420

			v->cargo_cap = rvi->capacity;

   421

			v->max_speed = rvi->max_speed;

   422

			v->value = value;

   423

			v->last_station_visited = 0xFFFF;

   424

			v->dest_tile = 0;

   425

   426

			v->engine_type = (byte)p1;

   427

			e = &_engines[p1];

   428

   429

			v->reliability = e->reliability;

   430

			v->reliability_spd_dec = e->reliability_spd_dec;

   431

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

   432

   433

			v->string_id = STR_SV_TRAIN_NAME;

   434

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

   435

			_new_train_id = v->index;

   436

   437

			v->service_interval = _patches.servint_trains;

   438

			v->date_of_last_service = _date;

   439

			v->build_year = _cur_year;

   440

			v->type = VEH_Train;

   441

			v->cur_image = 0xAC2;

   442

   443

			VehiclePositionChanged(v);

   444

   445

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

   446

				u->direction = v->direction;

   447

				u->owner = v->owner;

   448

				u->tile = v->tile;

   449

				u->x_pos = v->x_pos;

   450

				u->y_pos = v->y_pos;

   451

				u->z_pos = v->z_pos;

   452

				u->z_height = 6;

   453

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

   454

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

   455

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   456

				u->subtype = 2;

   457

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

   458

				u->cargo_type = v->cargo_type;

   459

				u->cargo_cap = v->cargo_cap;

   460

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

   461

//				u->next_in_chain = 0xffff;

   462

				v->next = u;

   463

				u->engine_type = v->engine_type;

   464

				u->build_year = v->build_year;

   465

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

   466

//				u->day_counter = 0;

   467

				u->type = VEH_Train;

   468

				u->cur_image = 0xAC2;

   469

				VehiclePositionChanged(u);

   470

			}

   471

   472

			UpdateTrainAcceleration(v);

   473

			NormalizeTrainVehInDepot(v);

   474

   475

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   476

			RebuildVehicleLists();

   477

			InvalidateWindow(WC_COMPANY, v->owner);

   478

		}

   479

	}

   480

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   481

	_cmd_build_rail_veh_score = _railveh_score[p1];

   482

	return value;

   483

}

   484

   485

   486

bool IsTrainDepotTile(TileIndex tile)

   487

{

   488

	return IsTileType(tile, MP_RAILWAY) &&

   489

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

   490

}

   491

   492

static bool IsTunnelTile(TileIndex tile)

   493

{

   494

	return IsTileType(tile, MP_TUNNELBRIDGE) &&

   495

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

   496

}

   497

   498

   499

int CheckStoppedInDepot(Vehicle *v)

   500

{

   501

	int count;

   502

	TileIndex tile = v->tile;

   503

   504

	/* check if stopped in a depot */

   505

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

   506

errmsg:

   507

		_error_message = STR_881A_TRAINS_CAN_ONLY_BE_ALTERED;

   508

		return -1;

   509

	}

   510

   511

	count = 0;

   512

	do {

   513

		count++;

   514

		if (v->u.rail.track != 0x80 || v->tile != (TileIndex)tile ||

   515

				(v->subtype==0 && !(v->vehstatus&VS_STOPPED)))

   516

			goto errmsg;

   517

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

   518

   519

	return count;