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 bool IsTunnelTile(TileIndex tile);

    89

    90

static int GetRealisticAcceleration(Vehicle *v)

    91

{

    92

	uint emass = 0;

    93

	Vehicle *u = v;

    94

	float f = 0.0f, spd;

    95

	int curves = 0;

    96

    97

	assert(v->subtype == 0);

    98

    99

	// compute inclination force and number of curves.

   100

	do {

   101

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

   102

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

   103

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

   104

   105

		if (u->u.rail.flags & VRF_GOINGUP) {

   106

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

   107

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

   108

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

   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;

   249

   250

			v->spritenum = img;

   251

   252

			u = _vehicles;

   253

			for(;;) {

   254

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

   255

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

   256

					u = GetLastVehicleInChain(u);

   257

					break;

   258

				}

   259

   260

				if (++u == endof(_vehicles)) {

   261

					u = NULL;

   262

					break;

   263

				}

   264

			}

   265

   266

			v->engine_type = engine;

   267

   268

			dir = _map5[tile] & 3;

   269

   270

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

   271

			v->tile = (TileIndex)tile;

   272

   273

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

   274

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

   275

   276

			v->x_pos = x;

   277

			v->y_pos = y;

   278

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

   279

			v->owner = _current_player;

   280

			v->z_height = 6;

   281

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

   282

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   283

   284

			v->subtype = 4;

   285

			if (u != NULL) {

   286

				u->next = v;

   287

				v->subtype = 2;

   288

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

   289

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

   290

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

   291

			} else {

   292

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

   293

			}

   294

   295

			v->cargo_type = rvi->cargo_type;

   296

			v->cargo_cap = rvi->capacity;

   297

			v->value = value;

   298

//			v->day_counter = 0;

   299

   300

			e = &_engines[engine];

   301

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

   302

   303

			v->build_year = _cur_year;

   304

			v->type = VEH_Train;

   305

			v->cur_image = 0xAC2;

   306

   307

			_new_wagon_id = v->index;

   308

   309

			VehiclePositionChanged(v);

   310

   311

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   312

		}

   313

	}

   314

   315

	return value;

   316

}

   317

   318

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

   319

static void NormalizeTrainVehInDepot(Vehicle *u)

   320

{

   321

	Vehicle *v;

   322

	FOR_ALL_VEHICLES(v) {

   323

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

   324

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

   325

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

   326

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

   327

				break;

   328

		}

   329

	}

   330

}

   331

   332

static const byte _railveh_unk1[] = {

   333

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

   334

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

   335

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

   336

	0, 1, 1, 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, 1,

   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, 0, 0, 0, 0,

   344

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

   345

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

   346

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

   347

	0, 0, 0, 0,

   348

};

   349

   350

static const byte _railveh_score[] = {

   351

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

   352

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

   353

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

   354

	41, 51, 52, 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, 0, 0, 60, 62,

   358

	63, 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, 70, 71, 72, 73,

   362

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

   363

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

   364

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

   365

	0, 0, 0, 0,

   366

};

   367

   368

   369

int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   370

{

   371

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

   372

}

   373

   374

/* Build a railroad vehicle

   375

 * p1 = vehicle type id

   376

 */

   377

   378

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

   379

{

   380

	const RailVehicleInfo *rvi;

   381

	int value,dir;

   382

	Vehicle *v, *u;

   383

	byte unit_num;

   384

	Engine *e;

   385

	uint tile;

   386

   387

	_cmd_build_rail_veh_var1 = 0;

   388

   389

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   390

   391

	tile = TILE_FROM_XY(x,y);

   392

	rvi = RailVehInfo(p1);

   393

   394

	if (rvi->flags & RVI_WAGON) {

   395

		return CmdBuildRailWagon(p1, tile, flags);

   396

	}

   397

   398

	value = EstimateTrainCost(rvi);

   399

   400

	if (!(flags & DC_QUERY_COST)) {

   401

		v = AllocateVehicle();

   402

		if (v == NULL || _ptr_to_next_order >= endof(_order_array))

   403

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   404

   405

		unit_num = GetFreeUnitNumber(VEH_Train);

   406

		if (unit_num > _patches.max_trains)

   407

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   408

   409

		if (flags & DC_EXEC) {

   410

			v->unitnumber = unit_num;

   411

   412

			dir = _map5[tile] & 3;

   413

   414

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

   415

			v->tile = (TileIndex)tile;

   416

			v->owner = _current_player;

   417

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

   418

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

   419

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

   420

			v->z_height = 6;

   421

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

   422

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

   423

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   424

//			v->subtype = 0;

   425

			v->spritenum = rvi->image_index;

   426

			v->cargo_type = rvi->cargo_type;

   427

			v->cargo_cap = rvi->capacity;

   428

			v->max_speed = rvi->max_speed;

   429

//			v->cargo_count = 0;

   430

			v->value = value;

   431

//			v->day_counter = 0;

   432

//			v->current_order = 0;

   433

//			v->next_station = 0;

   434

//			v->load_unload_time_rem = 0;

   435

//			v->progress = 0;

   436

//			v->targetairport = 0;

   437

//			v->crash_anim_pos = 0;

   438

			v->last_station_visited = 0xFFFF;

   439

			v->dest_tile = 0;

   440

//			v->profit_last_year = 0;

   441

//			v->profit_this_year = 0;

   442

   443

			v->engine_type = (byte)p1;

   444

			e = &_engines[p1];

   445

   446

			v->reliability = e->reliability;

   447

			v->reliability_spd_dec = e->reliability_spd_dec;

   448

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

   449

   450

			v->string_id = STR_SV_TRAIN_NAME;

   451

//			v->cur_speed = 0;

   452

//			v->subspeed = 0;

   453

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

   454

			_new_train_id = v->index;

   455

//			v->cur_order_index = 0;

   456

//			v->num_orders = 0;

   457

   458

			_ptr_to_next_order->type = OT_NOTHING;

   459

			_ptr_to_next_order->flags = 0;

   460

			v->schedule_ptr = _ptr_to_next_order++;

   461

//			v->next_in_chain = 0xffff;

   462

//			v->next = NULL;

   463

   464

			v->service_interval = _patches.servint_trains;

   465

//			v->breakdown_ctr = 0;

   466

//			v->breakdowns_since_last_service = 0;

   467

//			v->unk4D = 0;

   468

			v->date_of_last_service = _date;

   469

			v->build_year = _cur_year;

   470

			v->type = VEH_Train;

   471

			v->cur_image = 0xAC2;

   472

   473

			VehiclePositionChanged(v);

   474

   475

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

   476

				u->direction = v->direction;

   477

				u->owner = v->owner;

   478

				u->tile = v->tile;

   479

				u->x_pos = v->x_pos;

   480

				u->y_pos = v->y_pos;

   481

				u->z_pos = v->z_pos;

   482

				u->z_height = 6;

   483

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

   484

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

   485

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   486

				u->subtype = 2;

   487

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

   488

				u->cargo_type = v->cargo_type;

   489

				u->cargo_cap = v->cargo_cap;

   490

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

   491

//				u->next_in_chain = 0xffff;

   492

				v->next = u;

   493

				u->engine_type = v->engine_type;

   494

				u->build_year = v->build_year;

   495

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

   496

//				u->day_counter = 0;

   497

				u->type = VEH_Train;

   498

				u->cur_image = 0xAC2;

   499

				VehiclePositionChanged(u);

   500

			}

   501

   502

			UpdateTrainAcceleration(v);

   503

			NormalizeTrainVehInDepot(v);

   504

   505

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   506

			RebuildVehicleLists();

   507

			InvalidateWindow(WC_COMPANY, v->owner);

   508

		}

   509

	}

   510

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   511

	_cmd_build_rail_veh_score = _railveh_score[p1];

   512

	return value;

   513

}

   514

   515

   516

bool IsTrainDepotTile(TileIndex tile)

   517

{

   518

	return IS_TILETYPE(tile, MP_RAILWAY) &&

   519

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

   520

}

   521