00001
00002
00005 #include "stdafx.h"
00006 #include "openttd.h"
00007 #include "debug.h"
00008 #include "engine.h"
00009 #include "player_base.h"
00010 #include "player_func.h"
00011 #include "command_func.h"
00012 #include "news.h"
00013 #include "saveload.h"
00014 #include "variables.h"
00015 #include "train.h"
00016 #include "aircraft.h"
00017 #include "newgrf_cargo.h"
00018 #include "group.h"
00019 #include "strings_func.h"
00020 #include "gfx_func.h"
00021 #include "functions.h"
00022 #include "window_func.h"
00023 #include "date_func.h"
00024 #include "autoreplace_base.h"
00025 #include "autoreplace_gui.h"
00026 #include "string_func.h"
00027 #include "settings_type.h"
00028
00029 #include "table/strings.h"
00030 #include "table/engines.h"
00031
00032 Engine _engines[TOTAL_NUM_ENGINES];
00033 EngineInfo _engine_info[TOTAL_NUM_ENGINES];
00034 RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];
00035 ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];
00036 AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];
00037 RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];
00038
00039 enum {
00040 YEAR_ENGINE_AGING_STOPS = 2050,
00041 };
00042
00043
00044 void SetupEngines()
00045 {
00046
00047 memcpy(&_engine_info, &_orig_engine_info, sizeof(_orig_engine_info));
00048 memcpy(&_rail_vehicle_info, &_orig_rail_vehicle_info, sizeof(_orig_rail_vehicle_info));
00049 memcpy(&_ship_vehicle_info, &_orig_ship_vehicle_info, sizeof(_orig_ship_vehicle_info));
00050 memcpy(&_aircraft_vehicle_info, &_orig_aircraft_vehicle_info, sizeof(_orig_aircraft_vehicle_info));
00051 memcpy(&_road_vehicle_info, &_orig_road_vehicle_info, sizeof(_orig_road_vehicle_info));
00052
00053
00054 Engine* e = _engines;
00055 do e->type = VEH_TRAIN; while (++e < &_engines[ROAD_ENGINES_INDEX]);
00056 do e->type = VEH_ROAD; while (++e < &_engines[SHIP_ENGINES_INDEX]);
00057 do e->type = VEH_SHIP; while (++e < &_engines[AIRCRAFT_ENGINES_INDEX]);
00058 do e->type = VEH_AIRCRAFT; while (++e < &_engines[TOTAL_NUM_ENGINES]);
00059
00060
00061 for (EngineID engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {
00062 EngineInfo *ei = &_engine_info[engine];
00063 ei->string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + engine;
00064 }
00065 }
00066
00067
00068 void ShowEnginePreviewWindow(EngineID engine);
00069
00070 void DeleteCustomEngineNames()
00071 {
00072 Engine *e;
00073 FOR_ALL_ENGINES(e) {
00074 free(e->name);
00075 e->name = NULL;
00076 }
00077
00078 _vehicle_design_names &= ~1;
00079 }
00080
00081 void LoadCustomEngineNames()
00082 {
00083
00084 DEBUG(misc, 1, "LoadCustomEngineNames: not done");
00085 }
00086
00087 static void CalcEngineReliability(Engine *e)
00088 {
00089 uint age = e->age;
00090
00091
00092 if (e->player_avail != 0 && !_patches.never_expire_vehicles) {
00093 int retire_early = EngInfo(e - _engines)->retire_early;
00094 uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);
00095 if (retire_early != 0 && age >= retire_early_max_age) {
00096
00097 e->player_avail = 0;
00098 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
00099 }
00100 }
00101
00102 if (age < e->duration_phase_1) {
00103 uint start = e->reliability_start;
00104 e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;
00105 } else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _patches.never_expire_vehicles) {
00106
00107
00108 e->reliability = e->reliability_max;
00109 } else if ((age -= e->duration_phase_2) < e->duration_phase_3) {
00110 uint max = e->reliability_max;
00111 e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;
00112 } else {
00113
00114
00115 e->player_avail = 0;
00116 e->reliability = e->reliability_final;
00117
00118 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
00119 }
00120 InvalidateWindowClasses(WC_BUILD_VEHICLE);
00121 InvalidateWindowClasses(WC_REPLACE_VEHICLE);
00122 }
00123
00124 void StartupEngines()
00125 {
00126 Engine *e;
00127 const EngineInfo *ei;
00128
00129 const Date aging_date = min(_date, ConvertYMDToDate(YEAR_ENGINE_AGING_STOPS, 0, 1));
00130
00131 for (e = _engines, ei = _engine_info; e != endof(_engines); e++, ei++) {
00132 uint32 r;
00133
00134 e->age = 0;
00135 e->flags = 0;
00136 e->player_avail = 0;
00137
00138
00139
00140
00141 r = Random();
00142 e->intro_date = ei->base_intro <= ConvertYMDToDate(1922, 0, 1) ? ei->base_intro : (Date)GB(r, 0, 9) + ei->base_intro;
00143 if (e->intro_date <= _date) {
00144 e->age = (aging_date - e->intro_date) >> 5;
00145 e->player_avail = (byte)-1;
00146 e->flags |= ENGINE_AVAILABLE;
00147 }
00148
00149 e->reliability_start = GB(r, 16, 14) + 0x7AE0;
00150 r = Random();
00151 e->reliability_max = GB(r, 0, 14) + 0xBFFF;
00152 e->reliability_final = GB(r, 16, 14) + 0x3FFF;
00153
00154 r = Random();
00155 e->duration_phase_1 = GB(r, 0, 5) + 7;
00156 e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;
00157 e->duration_phase_3 = GB(r, 9, 7) + 120;
00158
00159 e->reliability_spd_dec = (ei->unk2&0x7F) << 2;
00160
00161
00162 if (ei->unk2 & 0x80) {
00163 e->age = 0xFFFF;
00164 } else {
00165 CalcEngineReliability(e);
00166 }
00167
00168 e->lifelength = ei->lifelength + _patches.extend_vehicle_life;
00169
00170
00171 if (!HasBit(ei->climates, _opt.landscape)) {
00172 e->flags |= ENGINE_AVAILABLE;
00173 e->player_avail = 0;
00174 }
00175 }
00176
00177
00178 Player *p;
00179 FOR_ALL_PLAYERS(p) {
00180 p->avail_railtypes = GetPlayerRailtypes(p->index);
00181 p->avail_roadtypes = GetPlayerRoadtypes(p->index);
00182 }
00183 }
00184
00185 static void AcceptEnginePreview(EngineID eid, PlayerID player)
00186 {
00187 Engine *e = GetEngine(eid);
00188 Player *p = GetPlayer(player);
00189
00190 SetBit(e->player_avail, player);
00191 if (e->type == VEH_TRAIN) {
00192 const RailVehicleInfo *rvi = RailVehInfo(eid);
00193
00194 assert(rvi->railtype < RAILTYPE_END);
00195 SetBit(p->avail_railtypes, rvi->railtype);
00196 } else if (e->type == VEH_ROAD) {
00197 SetBit(p->avail_roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);
00198 }
00199
00200 e->preview_player_rank = 0xFF;
00201 if (player == _local_player) {
00202 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
00203 }
00204 }
00205
00206 static PlayerID GetBestPlayer(uint8 pp)
00207 {
00208 const Player *p;
00209 int32 best_hist;
00210 PlayerID best_player;
00211 uint mask = 0;
00212
00213 do {
00214 best_hist = -1;
00215 best_player = PLAYER_SPECTATOR;
00216 FOR_ALL_PLAYERS(p) {
00217 if (p->is_active && p->block_preview == 0 && !HasBit(mask, p->index) &&
00218 p->old_economy[0].performance_history > best_hist) {
00219 best_hist = p->old_economy[0].performance_history;
00220 best_player = p->index;
00221 }
00222 }
00223
00224 if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;
00225
00226 SetBit(mask, best_player);
00227 } while (--pp != 0);
00228
00229 return best_player;
00230 }
00231
00232 void EnginesDailyLoop()
00233 {
00234 EngineID i;
00235
00236 if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;
00237
00238 for (i = 0; i != lengthof(_engines); i++) {
00239 Engine *e = &_engines[i];
00240
00241 if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {
00242 if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {
00243 if (e->preview_player_rank != 0xFF && !--e->preview_wait) {
00244 e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;
00245 DeleteWindowById(WC_ENGINE_PREVIEW, i);
00246 e->preview_player_rank++;
00247 }
00248 } else if (e->preview_player_rank != 0xFF) {
00249 PlayerID best_player = GetBestPlayer(e->preview_player_rank);
00250
00251 if (best_player == PLAYER_SPECTATOR) {
00252 e->preview_player_rank = 0xFF;
00253 continue;
00254 }
00255
00256 if (!IsHumanPlayer(best_player)) {
00257
00258 AcceptEnginePreview(i, best_player);
00259 } else {
00260 e->flags |= ENGINE_OFFER_WINDOW_OPEN;
00261 e->preview_wait = 20;
00262 if (IsInteractivePlayer(best_player)) ShowEnginePreviewWindow(i);
00263 }
00264 }
00265 }
00266 }
00267 }
00268
00276 CommandCost CmdWantEnginePreview(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
00277 {
00278 Engine *e;
00279
00280 if (!IsEngineIndex(p1)) return CMD_ERROR;
00281 e = GetEngine(p1);
00282 if (GetBestPlayer(e->preview_player_rank) != _current_player) return CMD_ERROR;
00283
00284 if (flags & DC_EXEC) AcceptEnginePreview(p1, _current_player);
00285
00286 return CommandCost();
00287 }
00288
00289
00290 static bool IsWagon(EngineID index)
00291 {
00292 return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->railveh_type == RAILVEH_WAGON;
00293 }
00294
00295 static void NewVehicleAvailable(Engine *e)
00296 {
00297 Vehicle *v;
00298 Player *p;
00299 EngineID index = e - _engines;
00300
00301
00302
00303 if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {
00304 FOR_ALL_PLAYERS(p) {
00305 uint block_preview = p->block_preview;
00306
00307 if (!HasBit(e->player_avail, p->index)) continue;
00308
00309
00310 p->block_preview = 20;
00311
00312 FOR_ALL_VEHICLES(v) {
00313 if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP ||
00314 (v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) {
00315 if (v->owner == p->index && v->engine_type == index) {
00316
00317 p->block_preview = block_preview;
00318 break;
00319 }
00320 }
00321 }
00322 }
00323 }
00324
00325 e->flags = (e->flags & ~ENGINE_EXCLUSIVE_PREVIEW) | ENGINE_AVAILABLE;
00326 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
00327
00328
00329 e->player_avail = (byte)-1;
00330
00331
00332 if (IsWagon(index)) return;
00333
00334 if (e->type == VEH_TRAIN) {
00335
00336 RailType railtype = RailVehInfo(index)->railtype;
00337 assert(railtype < RAILTYPE_END);
00338 FOR_ALL_PLAYERS(p) {
00339 if (p->is_active) SetBit(p->avail_railtypes, railtype);
00340 }
00341 } else if (e->type == VEH_ROAD) {
00342
00343 FOR_ALL_PLAYERS(p) {
00344 if (p->is_active) SetBit(p->avail_roadtypes, HasBit(EngInfo(index)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);
00345 }
00346 }
00347 AddNewsItem(index, NEWS_FLAGS(NM_CALLBACK, 0, NT_NEW_VEHICLES, DNC_VEHICLEAVAIL), 0, 0);
00348 }
00349
00350 void EnginesMonthlyLoop()
00351 {
00352 if (_cur_year < YEAR_ENGINE_AGING_STOPS) {
00353 Engine *e;
00354 FOR_ALL_ENGINES(e) {
00355
00356 if (e->flags & ENGINE_AVAILABLE && e->age != 0xFFFF) {
00357 e->age++;
00358 CalcEngineReliability(e);
00359 }
00360
00361 if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + 365)) {
00362
00363 NewVehicleAvailable(e);
00364 } else if (!(e->flags & (ENGINE_AVAILABLE|ENGINE_EXCLUSIVE_PREVIEW)) && _date >= e->intro_date) {
00365
00366 e->flags |= ENGINE_EXCLUSIVE_PREVIEW;
00367
00368
00369 if (!IsWagon(e - _engines))
00370 e->preview_player_rank = 1;
00371 }
00372 }
00373 }
00374 }
00375
00376 static bool IsUniqueEngineName(const char *name)
00377 {
00378 char buf[512];
00379
00380 for (EngineID i = 0; i < TOTAL_NUM_ENGINES; i++) {
00381 SetDParam(0, i);
00382 GetString(buf, STR_ENGINE_NAME, lastof(buf));
00383 if (strcmp(buf, name) == 0) return false;
00384 }
00385
00386 return true;
00387 }
00388
00395 CommandCost CmdRenameEngine(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
00396 {
00397 if (!IsEngineIndex(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;
00398
00399 if (!IsUniqueEngineName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);
00400
00401 if (flags & DC_EXEC) {
00402 Engine *e = GetEngine(p1);
00403 free(e->name);
00404 e->name = strdup(_cmd_text);
00405 _vehicle_design_names |= 3;
00406 MarkWholeScreenDirty();
00407 }
00408
00409 return CommandCost();
00410 }
00411
00412
00420 bool IsEngineBuildable(EngineID engine, VehicleType type, PlayerID player)
00421 {
00422
00423 if (!IsEngineIndex(engine)) return false;
00424
00425 const Engine *e = GetEngine(engine);
00426
00427
00428 if (e->type != type) return false;
00429
00430
00431 if (!HasBit(e->player_avail, player)) return false;
00432
00433 if (type == VEH_TRAIN) {
00434
00435 const Player *p = GetPlayer(player);
00436 if (!HasBit(p->avail_railtypes, RailVehInfo(engine)->railtype)) return false;
00437 }
00438
00439 return true;
00440 }
00441
00446 CargoID GetEngineCargoType(EngineID engine)
00447 {
00448 assert(IsEngineIndex(engine));
00449
00450 switch (GetEngine(engine)->type) {
00451 case VEH_TRAIN:
00452 if (RailVehInfo(engine)->capacity == 0) return CT_INVALID;
00453 return RailVehInfo(engine)->cargo_type;
00454
00455 case VEH_ROAD:
00456 if (RoadVehInfo(engine)->capacity == 0) return CT_INVALID;
00457 return RoadVehInfo(engine)->cargo_type;
00458
00459 case VEH_SHIP:
00460 if (ShipVehInfo(engine)->capacity == 0) return CT_INVALID;
00461 return ShipVehInfo(engine)->cargo_type;
00462
00463 case VEH_AIRCRAFT:
00464
00465 return CT_PASSENGERS;
00466
00467 default: NOT_REACHED(); return CT_INVALID;
00468 }
00469 }
00470
00471
00472
00473
00474
00475 DEFINE_OLD_POOL_GENERIC(EngineRenew, EngineRenew)
00476
00477
00480 static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)
00481 {
00482 EngineRenew *er = (EngineRenew *)erl;
00483
00484 while (er) {
00485 if (er->from == engine && er->group_id == group) return er;
00486 er = er->next;
00487 }
00488 return NULL;
00489 }
00490
00491 void RemoveAllEngineReplacement(EngineRenewList *erl)
00492 {
00493 EngineRenew *er = (EngineRenew *)(*erl);
00494 EngineRenew *next;
00495
00496 while (er != NULL) {
00497 next = er->next;
00498 delete er;
00499 er = next;
00500 }
00501 *erl = NULL;
00502 }
00503
00504 EngineID EngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)
00505 {
00506 const EngineRenew *er = GetEngineReplacement(erl, engine, group);
00507 if (er == NULL && (group == DEFAULT_GROUP || (IsValidGroupID(group) && !GetGroup(group)->replace_protection))) {
00508
00509 er = GetEngineReplacement(erl, engine, ALL_GROUP);
00510 }
00511 return er == NULL ? INVALID_ENGINE : er->to;
00512 }
00513
00514 CommandCost AddEngineReplacement(EngineRenewList *erl, EngineID old_engine, EngineID new_engine, GroupID group, uint32 flags)
00515 {
00516 EngineRenew *er;
00517
00518
00519 er = GetEngineReplacement(*erl, old_engine, group);
00520 if (er != NULL) {
00521 if (flags & DC_EXEC) er->to = new_engine;
00522 return CommandCost();
00523 }
00524
00525 if (!EngineRenew::CanAllocateItem()) return CMD_ERROR;
00526
00527 if (flags & DC_EXEC) {
00528 er = new EngineRenew(old_engine, new_engine);
00529 er->group_id = group;
00530
00531
00532 er->next = (EngineRenew *)(*erl);
00533 *erl = (EngineRenewList)er;
00534 }
00535
00536 return CommandCost();
00537 }
00538
00539 CommandCost RemoveEngineReplacement(EngineRenewList *erl, EngineID engine, GroupID group, uint32 flags)
00540 {
00541 EngineRenew *er = (EngineRenew *)(*erl);
00542 EngineRenew *prev = NULL;
00543
00544 while (er)
00545 {
00546 if (er->from == engine && er->group_id == group) {
00547 if (flags & DC_EXEC) {
00548 if (prev == NULL) {
00549
00550 *erl = (EngineRenewList)er->next;
00551 } else {
00552
00553 prev->next = er->next;
00554 }
00555 delete er;
00556 }
00557 return CommandCost();
00558 }
00559 prev = er;
00560 er = er->next;
00561 }
00562
00563 return CMD_ERROR;
00564 }
00565
00566 static const SaveLoad _engine_renew_desc[] = {
00567 SLE_VAR(EngineRenew, from, SLE_UINT16),
00568 SLE_VAR(EngineRenew, to, SLE_UINT16),
00569
00570 SLE_REF(EngineRenew, next, REF_ENGINE_RENEWS),
00571 SLE_CONDVAR(EngineRenew, group_id, SLE_UINT16, 60, SL_MAX_VERSION),
00572 SLE_END()
00573 };
00574
00575 static void Save_ERNW()
00576 {
00577 EngineRenew *er;
00578
00579 FOR_ALL_ENGINE_RENEWS(er) {
00580 SlSetArrayIndex(er->index);
00581 SlObject(er, _engine_renew_desc);
00582 }
00583 }
00584
00585 static void Load_ERNW()
00586 {
00587 int index;
00588
00589 while ((index = SlIterateArray()) != -1) {
00590 EngineRenew *er = new (index) EngineRenew();
00591 SlObject(er, _engine_renew_desc);
00592
00593
00594 if (CheckSavegameVersion(60)) {
00595 er->group_id = ALL_GROUP;
00596 } else if (CheckSavegameVersion(71)) {
00597 if (er->group_id == DEFAULT_GROUP) er->group_id = ALL_GROUP;
00598 }
00599 }
00600 }
00601
00602 static const SaveLoad _engine_desc[] = {
00603 SLE_CONDVAR(Engine, intro_date, SLE_FILE_U16 | SLE_VAR_I32, 0, 30),
00604 SLE_CONDVAR(Engine, intro_date, SLE_INT32, 31, SL_MAX_VERSION),
00605 SLE_CONDVAR(Engine, age, SLE_FILE_U16 | SLE_VAR_I32, 0, 30),
00606 SLE_CONDVAR(Engine, age, SLE_INT32, 31, SL_MAX_VERSION),
00607 SLE_VAR(Engine, reliability, SLE_UINT16),
00608 SLE_VAR(Engine, reliability_spd_dec, SLE_UINT16),
00609 SLE_VAR(Engine, reliability_start, SLE_UINT16),
00610 SLE_VAR(Engine, reliability_max, SLE_UINT16),
00611 SLE_VAR(Engine, reliability_final, SLE_UINT16),
00612 SLE_VAR(Engine, duration_phase_1, SLE_UINT16),
00613 SLE_VAR(Engine, duration_phase_2, SLE_UINT16),
00614 SLE_VAR(Engine, duration_phase_3, SLE_UINT16),
00615
00616 SLE_VAR(Engine, lifelength, SLE_UINT8),
00617 SLE_VAR(Engine, flags, SLE_UINT8),
00618 SLE_VAR(Engine, preview_player_rank, SLE_UINT8),
00619 SLE_VAR(Engine, preview_wait, SLE_UINT8),
00620 SLE_CONDNULL(1, 0, 44),
00621 SLE_VAR(Engine, player_avail, SLE_UINT8),
00622 SLE_CONDSTR(Engine, name, SLE_STR, 0, 84, SL_MAX_VERSION),
00623
00624
00625 SLE_CONDNULL(16, 2, SL_MAX_VERSION),
00626
00627 SLE_END()
00628 };
00629
00630 static void Save_ENGN()
00631 {
00632 uint i;
00633
00634 for (i = 0; i != lengthof(_engines); i++) {
00635 SlSetArrayIndex(i);
00636 SlObject(&_engines[i], _engine_desc);
00637 }
00638 }
00639
00640 static void Load_ENGN()
00641 {
00642 int index;
00643 while ((index = SlIterateArray()) != -1) {
00644 SlObject(GetEngine(index), _engine_desc);
00645 }
00646 }
00647
00648 static void Load_ENGS()
00649 {
00650 StringID names[TOTAL_NUM_ENGINES];
00651
00652 SlArray(names, lengthof(names), SLE_STRINGID);
00653
00654 for (EngineID engine = 0; engine < lengthof(names); engine++) {
00655 Engine *e = GetEngine(engine);
00656 e->name = CopyFromOldName(names[engine]);
00657 }
00658 }
00659
00660 extern const ChunkHandler _engine_chunk_handlers[] = {
00661 { 'ENGN', Save_ENGN, Load_ENGN, CH_ARRAY },
00662 { 'ENGS', NULL, Load_ENGS, CH_RIFF },
00663 { 'ERNW', Save_ERNW, Load_ERNW, CH_ARRAY | CH_LAST},
00664 };
00665
00666 void InitializeEngines()
00667 {
00668
00669 _EngineRenew_pool.CleanPool();
00670 _EngineRenew_pool.AddBlockToPool();
00671
00672 Engine *e;
00673 FOR_ALL_ENGINES(e) {
00674 free(e->name);
00675 e->name = NULL;
00676 }
00677 }