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

	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;

   247

   248

			v->spritenum = img;

   249

   250

			u = _vehicles;

   251

			for(;;) {

   252

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

   253

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

   254

					u = GetLastVehicleInChain(u);

   255

					break;

   256

				}

   257

   258

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

   259

					u = NULL;

   260

					break;

   261

				}

   262

			}

   263

   264

			v->engine_type = engine;

   265

   266

			dir = _map5[tile] & 3;

   267

   268

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

   269

			v->tile = (TileIndex)tile;

   270

   271

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

   272

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

   273

   274

			v->x_pos = x;

   275

			v->y_pos = y;

   276

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

   277

			v->owner = _current_player;

   278

			v->z_height = 6;

   279

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

   280

			v->vehstatus = VS_HIDDEN | VS_DEFPAL;

   281

   282

			v->subtype = 4;

   283

			if (u != NULL) {

   284

				u->next = v;

   285

				v->subtype = 2;

   286

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

   287

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

   288

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

   289

			} else {

   290

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

   291

			}

   292

   293

			v->cargo_type = rvi->cargo_type;

   294

			v->cargo_cap = rvi->capacity;

   295

			v->value = value;

   296

//			v->day_counter = 0;

   297

   298

			e = &_engines[engine];

   299

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

   300

   301

			v->build_year = _cur_year;

   302

			v->type = VEH_Train;

   303

			v->cur_image = 0xAC2;

   304

   305

			_new_wagon_id = v->index;

   306

   307

			VehiclePositionChanged(v);

   308

   309

			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

   310

		}

   311

	}

   312

   313

	return value;

   314

}

   315

   316

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

   317

static void NormalizeTrainVehInDepot(Vehicle *u)

   318

{

   319

	Vehicle *v;

   320

	FOR_ALL_VEHICLES(v) {

   321

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

   322

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

   323

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

   324

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

   325

				break;

   326

		}

   327

	}

   328

}

   329

   330

static const byte _railveh_unk1[] = {

   331

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

   332

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

   333

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

   334

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

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

   344

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

   345

	0, 0, 0, 0,

   346

};

   347

   348

static const byte _railveh_score[] = {

   349

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

   350

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

   351

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

   352

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

   356

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

   360

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

   361

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

   362

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

   363

	0, 0, 0, 0,

   364

};

   365

   366

   367

static int32 EstimateTrainCost(const RailVehicleInfo *rvi)

   368

{

   369

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

   370

}

   371

   372

/* Build a railroad vehicle

   373

 * p1 = vehicle type id

   374

 */

   375

   376

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

   377

{

   378

	const RailVehicleInfo *rvi;

   379

	int value,dir;

   380

	Vehicle *v, *u;

   381

	byte unit_num;

   382

	Engine *e;

   383

	uint tile;

   384

   385

	_cmd_build_rail_veh_var1 = 0;

   386

   387

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

   388

   389

	tile = TILE_FROM_XY(x,y);

   390

	rvi = RailVehInfo(p1);

   391

   392

	if (rvi->flags & RVI_WAGON) {

   393

		return CmdBuildRailWagon(p1, tile, flags);

   394

	}

   395

   396

	value = EstimateTrainCost(rvi);

   397

   398

	if (!(flags & DC_QUERY_COST)) {

   399

		v = AllocateVehicle();

   400

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

   401

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   402

   403

		unit_num = GetFreeUnitNumber(VEH_Train);

   404

		if (unit_num > _patches.max_trains)

   405

			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

   406

   407

		if (flags & DC_EXEC) {

   408

			v->unitnumber = unit_num;

   409

   410

			dir = _map5[tile] & 3;

   411

   412

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

   413

			v->tile = (TileIndex)tile;

   414

			v->owner = _current_player;

   415

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

   416

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

   417

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

   418

			v->z_height = 6;

   419

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

   420

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

   421

			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

   422

//			v->subtype = 0;

   423

			v->spritenum = rvi->image_index;

   424

			v->cargo_type = rvi->cargo_type;

   425

			v->cargo_cap = rvi->capacity;

   426

			v->max_speed = rvi->max_speed;

   427

//			v->cargo_count = 0;

   428

			v->value = value;

   429

//			v->day_counter = 0;

   430

//			v->current_order = 0;

   431

//			v->next_station = 0;

   432

//			v->load_unload_time_rem = 0;

   433

//			v->progress = 0;

   434

//			v->targetairport = 0;

   435

//			v->crash_anim_pos = 0;

   436

			v->last_station_visited = 0xff;

   437

			v->dest_tile = 0;

   438

//			v->profit_last_year = 0;

   439

//			v->profit_this_year = 0;

   440

   441

			v->engine_type = (byte)p1;

   442

			e = &_engines[p1];

   443

   444

			v->reliability = e->reliability;

   445

			v->reliability_spd_dec = e->reliability_spd_dec;

   446

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

   447

   448

			v->string_id = STR_SV_TRAIN_NAME;

   449

//			v->cur_speed = 0;

   450

//			v->subspeed = 0;

   451

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

   452

			_new_train_id = v->index;

   453

//			v->cur_order_index = 0;

   454

//			v->num_orders = 0;

   455

   456

			_ptr_to_next_order->type = OT_NOTHING;

   457

			_ptr_to_next_order->flags = 0;

   458

			v->schedule_ptr = _ptr_to_next_order++;

   459

//			v->next_in_chain = 0xffff;

   460

//			v->next = NULL;

   461

   462

			v->service_interval = _patches.servint_trains;

   463

//			v->breakdown_ctr = 0;

   464

//			v->breakdowns_since_last_service = 0;

   465

//			v->unk4D = 0;

   466

			v->date_of_last_service = _date;

   467

			v->build_year = _cur_year;

   468

			v->type = VEH_Train;

   469

			v->cur_image = 0xAC2;

   470

   471

			VehiclePositionChanged(v);

   472

   473

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

   474

				u->direction = v->direction;

   475

				u->owner = v->owner;

   476

				u->tile = v->tile;

   477

				u->x_pos = v->x_pos;

   478

				u->y_pos = v->y_pos;

   479

				u->z_pos = v->z_pos;

   480

				u->z_height = 6;

   481

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

   482

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

   483

				u->vehstatus = VS_HIDDEN | VS_DEFPAL;

   484

				u->subtype = 2;

   485

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

   486

				u->cargo_type = v->cargo_type;

   487

				u->cargo_cap = v->cargo_cap;

   488

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

   489

//				u->next_in_chain = 0xffff;

   490

				v->next = u;

   491

				u->engine_type = v->engine_type;

   492

				u->build_year = v->build_year;

   493

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

   494

//				u->day_counter = 0;

   495

				u->type = VEH_Train;

   496

				u->cur_image = 0xAC2;

   497

				VehiclePositionChanged(u);

   498

			}

   499

   500

			UpdateTrainAcceleration(v);

   501

			NormalizeTrainVehInDepot(v);

   502

   503

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

   504

			RebuildVehicleLists();

   505

			InvalidateWindow(WC_COMPANY, v->owner);

   506

		}

   507

	}

   508

	_cmd_build_rail_veh_var1 = _railveh_unk1[p1];

   509

	_cmd_build_rail_veh_score = _railveh_score[p1];

   510

	return value;

   511

}

   512

   513

   514

bool IsTrainDepotTile(TileIndex tile)

   515

{

   516

	return IS_TILETYPE(tile, MP_RAILWAY) &&

   517

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

   518

}

   519

   520

static bool IsTunnelTile(TileIndex tile)

   521

{