1

/* $Id$ */

     2

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "player_base.h"

     9

#include "player_func.h"

    10

#include "command_func.h"

    11

#include "news_func.h"

    12

#include "saveload.h"

    13

#include "variables.h"

    14

#include "train.h"

    15

#include "aircraft.h"

    16

#include "newgrf_cargo.h"

    18

#include "group.h"

    19

#include "strings_func.h"

    20

#include "gfx_func.h"

    21

#include "functions.h"

    22

#include "window_func.h"

    23

#include "date_func.h"

    24

#include "autoreplace_base.h"

    25

#include "autoreplace_gui.h"

    26

#include "string_func.h"

    27

#include "settings_type.h"

    28

#include "oldpool_func.h"

    29

#include "ai/ai.h"

    32

    33

#include "table/strings.h"

    34

#include "table/engines.h"

    35

    37

    38

enum {

    39

	YEAR_ENGINE_AGING_STOPS = 2050,

    40

};

    41

    42

   140

void SetupEngines()

   141

{

   144

   149

}

   150

   151

   152

void ShowEnginePreviewWindow(EngineID engine);

   153

   154

void DeleteCustomEngineNames()

   155

{

   156

	Engine *e;

   157

	FOR_ALL_ENGINES(e) {

   158

		free(e->name);

   159

		e->name = NULL;

   160

	}

   161

   162

	_vehicle_design_names &= ~1;

   163

}

   164

   165

void LoadCustomEngineNames()

   166

{

   167

	/* XXX: not done */

   168

	DEBUG(misc, 1, "LoadCustomEngineNames: not done");

   169

}

   170

   171

static void CalcEngineReliability(Engine *e)

   172

{

   173

	uint age = e->age;

   174

   175

	/* Check for early retirement */

   176

	if (e->player_avail != 0 && !_patches.never_expire_vehicles) {

   178

		uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);

   179

		if (retire_early != 0 && age >= retire_early_max_age) {

   180

			/* Early retirement is enabled and we're past the date... */

   181

			e->player_avail = 0;

   182

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   183

		}

   184

	}

   185

   186

	if (age < e->duration_phase_1) {

   187

		uint start = e->reliability_start;

   188

		e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;

   189

	} else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _patches.never_expire_vehicles) {

   190

		/* We are at the peak of this engines life. It will have max reliability.

   191

		 * This is also true if the engines never expire. They will not go bad over time */

   192

		e->reliability = e->reliability_max;

   193

	} else if ((age -= e->duration_phase_2) < e->duration_phase_3) {

   194

		uint max = e->reliability_max;

   195

		e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;

   196

	} else {

   197

		/* time's up for this engine.

   198

		 * We will now completely retire this design */

   199

		e->player_avail = 0;

   200

		e->reliability = e->reliability_final;

   201

		/* Kick this engine out of the lists */

   202

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   203

	}

   204

	InvalidateWindowClasses(WC_BUILD_VEHICLE); // Update to show the new reliability

   205

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   206

}

   207

   208

void StartupEngines()

   209

{

   210

	Engine *e;

   211

	/* Aging of vehicles stops, so account for that when starting late */

   212

	const Date aging_date = min(_date, ConvertYMDToDate(YEAR_ENGINE_AGING_STOPS, 0, 1));

   213

   216

		uint32 r;

   217

   218

		e->age = 0;

   219

		e->flags = 0;

   220

		e->player_avail = 0;

   221

   222

		/* The magic value of 729 days below comes from the NewGRF spec. If the

   223

		 * base intro date is before 1922 then the random number of days is not

   224

		 * added. */

   225

		r = Random();

   226

		e->intro_date = ei->base_intro <= ConvertYMDToDate(1922, 0, 1) ? ei->base_intro : (Date)GB(r, 0, 9) + ei->base_intro;

   227

		if (e->intro_date <= _date) {

   228

			e->age = (aging_date - e->intro_date) >> 5;

   229

			e->player_avail = (byte)-1;

   230

			e->flags |= ENGINE_AVAILABLE;

   231

		}

   232

   233

		e->reliability_start = GB(r, 16, 14) + 0x7AE0;

   234

		r = Random();

   235

		e->reliability_max   = GB(r,  0, 14) + 0xBFFF;

   236

		e->reliability_final = GB(r, 16, 14) + 0x3FFF;

   237

   238

		r = Random();

   239

		e->duration_phase_1 = GB(r, 0, 5) + 7;

   240

		e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;

   241

		e->duration_phase_3 = GB(r, 9, 7) + 120;

   242

   243

		e->reliability_spd_dec = (ei->unk2&0x7F) << 2;

   244

   245

		/* my invented flag for something that is a wagon */

   246

		if (ei->unk2 & 0x80) {

   247

			e->age = 0xFFFF;

   248

		} else {

   249

			CalcEngineReliability(e);

   250

		}

   251

   252

		e->lifelength = ei->lifelength + _patches.extend_vehicle_life;

   253

   254

		/* prevent certain engines from ever appearing. */

   255

		if (!HasBit(ei->climates, _opt.landscape)) {

   256

			e->flags |= ENGINE_AVAILABLE;

   257

			e->player_avail = 0;

   258

		}

   259

	}

   260

}

   261

   262

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   263

{

   264

	Engine *e = GetEngine(eid);

   265

	Player *p = GetPlayer(player);

   266

   267

	SetBit(e->player_avail, player);

   268

	if (e->type == VEH_TRAIN) {

   269

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   270

   271

		assert(rvi->railtype < RAILTYPE_END);

   272

		SetBit(p->avail_railtypes, rvi->railtype);

   273

	} else if (e->type == VEH_ROAD) {

   274

		SetBit(p->avail_roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   275

	}

   276

   277

	e->preview_player_rank = 0xFF;

   278

	if (player == _local_player) {

   279

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   280

	}

   281

}

   282

   283

static PlayerID GetBestPlayer(uint8 pp)

   284

{

   285

	const Player *p;

   286

	int32 best_hist;

   287

	PlayerID best_player;

   288

	uint mask = 0;

   289

   290

	do {

   291

		best_hist = -1;

   292

		best_player = PLAYER_SPECTATOR;

   293

		FOR_ALL_PLAYERS(p) {

   294

			if (p->is_active && p->block_preview == 0 && !HasBit(mask, p->index) &&

   295

					p->old_economy[0].performance_history > best_hist) {

   296

				best_hist = p->old_economy[0].performance_history;

   297

				best_player = p->index;

   298

			}

   299

		}

   300

   301

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   302

   303

		SetBit(mask, best_player);

   304

	} while (--pp != 0);

   305

   306

	return best_player;

   307

}

   308

   309

void EnginesDailyLoop()

   310

{

   311

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   312

   316

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   317

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   318

				if (e->preview_player_rank != 0xFF && !--e->preview_wait) {

   319

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   320

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   321

					e->preview_player_rank++;

   322

				}

   323

			} else if (e->preview_player_rank != 0xFF) {

   324

				PlayerID best_player = GetBestPlayer(e->preview_player_rank);

   325

   326

				if (best_player == PLAYER_SPECTATOR) {

   327

					e->preview_player_rank = 0xFF;

   328

					continue;

   329

				}

   330

   331

				e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   332

				e->preview_wait = 20;

   333

				AI_Event(best_player, new AIEventEnginePreview(i));

   334

				if (IsInteractivePlayer(best_player)) ShowEnginePreviewWindow(i);

   335

			}

   336

		}

   337

	}

   338

}

   339

   340

/** Accept an engine prototype. XXX - it is possible that the top-player

   341

 * changes while you are waiting to accept the offer? Then it becomes invalid

   342

 * @param tile unused

   343

 * @param flags operation to perfom

   344

 * @param p1 engine-prototype offered

   345

 * @param p2 unused

   346

 */

   347

CommandCost CmdWantEnginePreview(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   348

{

   349

	Engine *e;

   350

   351

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   352

	e = GetEngine(p1);

   353

	if (GetBestPlayer(e->preview_player_rank) != _current_player) return CMD_ERROR;

   354

   355

	if (flags & DC_EXEC) AcceptEnginePreview(p1, _current_player);

   356

   357

	return CommandCost();

   358

}

   359

   360

/* Determine if an engine type is a wagon (and not a loco) */

   361

static bool IsWagon(EngineID index)

   362

{

   365

}

   366

   367

static void NewVehicleAvailable(Engine *e)

   368

{

   369

	Vehicle *v;

   370

	Player *p;

   372

   373

	/* In case the player didn't build the vehicle during the intro period,

   374

	 * prevent that player from getting future intro periods for a while. */

   375

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   376

		FOR_ALL_PLAYERS(p) {

   377

			uint block_preview = p->block_preview;

   378

   379

			if (!HasBit(e->player_avail, p->index)) continue;

   380

   381

			/* We assume the user did NOT build it.. prove me wrong ;) */

   382

			p->block_preview = 20;

   383

   384

			FOR_ALL_VEHICLES(v) {

   385

				if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP ||

   386

						(v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) {

   387

					if (v->owner == p->index && v->engine_type == index) {

   388

						/* The user did prove me wrong, so restore old value */

   389

						p->block_preview = block_preview;

   390

						break;

   391

					}

   392

				}

   393

			}

   394

		}

   395

	}

   396

   397

	e->flags = (e->flags & ~ENGINE_EXCLUSIVE_PREVIEW) | ENGINE_AVAILABLE;

   398

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   399

   400

	/* Now available for all players */

   401

	e->player_avail = (byte)-1;

   402

   403

	/* Do not introduce new rail wagons */

   404

	if (IsWagon(index)) return;

   405

   406

	if (e->type == VEH_TRAIN) {

   407

		/* maybe make another rail type available */

   409

		assert(railtype < RAILTYPE_END);

   410

		FOR_ALL_PLAYERS(p) {

   411

			if (p->is_active) SetBit(p->avail_railtypes, railtype);

   412

		}

   413

	} else if (e->type == VEH_ROAD) {

   414

		/* maybe make another road type available */

   415

		FOR_ALL_PLAYERS(p) {

   417

		}

   418

	}

   419

	AddNewsItem(index, NM_CALLBACK, NF_NONE, NT_NEW_VEHICLES, DNC_VEHICLEAVAIL, 0, 0);

   420

}

   421

   422

void EnginesMonthlyLoop()

   423

{

   424

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   425

		Engine *e;

   426

		FOR_ALL_ENGINES(e) {

   427

			/* Age the vehicle */

   428

			if (e->flags & ENGINE_AVAILABLE && e->age != 0xFFFF) {

   429

				e->age++;

   430

				CalcEngineReliability(e);

   431

			}

   432

   433

			if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + 365)) {

   434

				/* Introduce it to all players */

   435

				NewVehicleAvailable(e);

   436

			} else if (!(e->flags & (ENGINE_AVAILABLE|ENGINE_EXCLUSIVE_PREVIEW)) && _date >= e->intro_date) {

   437

				/* Introduction date has passed.. show introducing dialog to one player. */

   438

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   439

   440

				/* Do not introduce new rail wagons */

   442

					e->preview_player_rank = 1; // Give to the player with the highest rating.

   443

			}

   444

		}

   445

	}

   446

}

   447

   448

static bool IsUniqueEngineName(const char *name)

   449

{

   450

	char buf[512];

   451

   455

		GetString(buf, STR_ENGINE_NAME, lastof(buf));

   456

		if (strcmp(buf, name) == 0) return false;

   457

	}

   458

   459

	return true;

   460

}

   461

   462

/** Rename an engine.

   463

 * @param tile unused

   464

 * @param flags operation to perfom

   465

 * @param p1 engine ID to rename

   466

 * @param p2 unused

   467

 */

   468

CommandCost CmdRenameEngine(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   469

{

   470

	if (!IsEngineIndex(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;

   471

   472

	if (!IsUniqueEngineName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   473

   474

	if (flags & DC_EXEC) {

   475

		Engine *e = GetEngine(p1);

   476

		free(e->name);

   477

		e->name = strdup(_cmd_text);

   478

		_vehicle_design_names |= 3;

   479

		MarkWholeScreenDirty();

   480

	}

   481

   482

	return CommandCost();

   483

}

   484

   485

   486

/** Check if an engine is buildable.

   487

 * @param engine index of the engine to check.

   488

 * @param type   the type the engine should be.

   489

 * @param player index of the player.