Archives/OpenTTD-patches
2
0
Fork 0
mirror of https://github.com/JGRennison/OpenTTD-patches.git synced 2024-11-11 13:10:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'improved_breakdowns' into improved_breakdowns-sx

Browse Source 
# Conflicts:
#	src/saveload/vehicle_sl.cpp
#	src/table/settings.ini
This commit is contained in:
Jonathan G Rennison 2016-01-31 23:40:17 +00:00
commit fe2277dfbc
17 changed files with 128 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/aircraft_cmd.cpp
View File

@ -308,7 +308,7 @@ CommandCost CmdBuildAircraft(TileIndex tile, DoCommandFlag flags, const Engine *
v->reliability_spd_dec = e->reliability_spd_dec;
/* higher speed means higher breakdown chance */
/* to somewhat compensate for the fact that fast aircraft spend less time in the air */
v->breakdown_chance = Clamp(64 + (AircraftVehInfo(v->engine_type)->max_speed >> 3), 0, 255);
v->breakdown_chance_factor = Clamp(64 + (AircraftVehInfo(v->engine_type)->max_speed >> 3), 0, 255);
v->max_age = e->GetLifeLengthInDays();
_new_vehicle_id = v->index;
@ -1333,18 +1333,18 @@ static void MaybeCrashAirplane(Aircraft *v)
Station *st = Station::Get(v->targetairport);
/* FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports */
uint32 prob = (_settings_game.vehicle.improved_breakdowns && _settings_game.difficulty.vehicle_breakdowns) ?
0x10000 / 10000 : 0x4000 << _settings_game.vehicle.plane_crashes;
uint32 prob = (0x4000 << _settings_game.vehicle.plane_crashes);
if ((st->airport.GetFTA()->flags & AirportFTAClass::SHORT_STRIP) &&
(AircraftVehInfo(v->engine_type)->subtype & AIR_FAST) &&
!_cheats.no_jetcrash.value) {
prob /= 20;
} else if (!_settings_game.vehicle.improved_breakdowns) {
} else {
prob /= 1500;
} else if (v->breakdown_ctr == 1 && v->breakdown_type == BREAKDOWN_AIRCRAFT_EM_LANDING) {
}
if (_settings_game.vehicle.improved_breakdowns && v->breakdown_ctr == 1 && v->breakdown_type == BREAKDOWN_AIRCRAFT_EM_LANDING) {
/* Airplanes that are attempting an emergency landing have a 2% chance to crash */
prob = 0x10000 / 50;
prob = max<uint32>(prob, 0x10000 / 50);
}
if (GB(Random(), 0, 22) > prob) return;

17
src/ground_vehicle.cpp
View File

@ -78,14 +78,15 @@ void GroundVehicle<T, Type>::CalculatePower(uint32& total_power, uint32& max_te,
for (const T *u = v; u != NULL; u = u->Next()) {
uint32 current_power = u->GetPower() + u->GetPoweredPartPower(u);
if (breakdowns && u->breakdown_ctr == 1 && u->breakdown_type == BREAKDOWN_LOW_POWER) {
current_power = current_power * u->breakdown_severity / 256;
}
total_power += current_power;
/* Only powered parts add tractive effort. */
if (current_power > 0) max_te += u->GetWeight() * u->GetTractiveEffort();
if (breakdowns && u->breakdown_ctr == 1 && u->breakdown_type == BREAKDOWN_LOW_POWER) {
total_power = total_power * u->breakdown_severity / 256;
}
}
max_te *= 10000; // Tractive effort in (tonnes * 1000 * 10 =) N.
@ -138,7 +139,6 @@ int GroundVehicle<T, Type>::GetAcceleration()
* and km/h to m/s conversion below result in a maxium of
* about 1.1E11, way more than 4.3E9 of int32. */
int64 power = this->gcache.cached_power * 746ll;
uint32 max_te = this->gcache.cached_max_te; // [N]
/* This is constructed from:
* - axle resistance: U16 power * 10 for 128 vehicles.
@ -171,7 +171,7 @@ int GroundVehicle<T, Type>::GetAcceleration()
AccelStatus mode = v->GetAccelerationStatus();
/* handle breakdown power reduction */
//TODO
uint32 max_te = this->gcache.cached_max_te; // [N]
if (Type == VEH_TRAIN && mode == AS_ACCEL && HasBit(Train::From(this)->flags, VRF_BREAKDOWN_POWER)) {
/* We'd like to cache this, but changing cached_power has too many unwanted side-effects */
uint32 power_temp;
@ -220,9 +220,7 @@ int GroundVehicle<T, Type>::GetAcceleration()
breakdown_factor /= (Train::From(this)->tcache.cached_num_engines + 2);
}
/* breakdown_chance is at least 5 (5 / 128 = ~4% of the normal chance) */
this->breakdown_chance = max(breakdown_factor >> 16, (uint64)5);
} else {
this->breakdown_chance = 128;
this->breakdown_chance_factor = max(breakdown_factor >> 16, (uint64)5);
}
if (mode == AS_ACCEL) {
@ -246,7 +244,6 @@ int GroundVehicle<T, Type>::GetAcceleration()
accel -= this->acceleration >> 1;
}
if (this->IsFrontEngine() && !(this->current_order_time & 0x1FF) &&
!(this->current_order.IsType(OT_LOADING)) &&
!(Train::From(this)->flags & (VRF_IS_BROKEN | (1 << VRF_TRAIN_STUCK))) &&

12
src/ground_vehicle.hpp
View File

@ -370,22 +370,24 @@ protected:
uint spd = this->subspeed + accel;
this->subspeed = (byte)spd;
int tempmax = max_speed;
/* When we are going faster than the maximum speed, reduce the speed
* somewhat gradually. But never lower than the maximum speed. */
int tempmax = ((this->breakdown_ctr == 1) ? this->cur_speed : max_speed);
if (this->breakdown_ctr == 1) {
if (this->breakdown_type == BREAKDOWN_LOW_POWER) {
if((this->tick_counter & 0x7) == 0) {
if ((this->tick_counter & 0x7) == 0 && _settings_game.vehicle.train_acceleration_model == AM_ORIGINAL) {
if (this->cur_speed > (this->breakdown_severity * max_speed) >> 8) {
tempmax = this->cur_speed - (this->cur_speed / 10) - 1;
} else {
tempmax = (this->breakdown_severity * max_speed) >> 8;
}
}
}
if(this->breakdown_type == BREAKDOWN_LOW_SPEED)
} else if (this->breakdown_type == BREAKDOWN_LOW_SPEED) {
tempmax = min(max_speed, this->breakdown_severity);
} else {
tempmax = this->cur_speed;
}
}
if (this->cur_speed > max_speed) {

5
src/lang/english.txt
View File

@ -3622,7 +3622,8 @@ STR_VEHICLE_STATUS_LEAVING :{LTBLUE}Leaving
STR_VEHICLE_STATUS_CRASHED :{RED}Crashed!
STR_VEHICLE_STATUS_BROKEN_DOWN :{RED}Broken down
STR_VEHICLE_STATUS_STOPPED :{RED}Stopped
STR_VEHICLE_STATUS_BROKEN_DOWN_VEL :{RED}Broken down - {STRING1}, {LTBLUE} {VELOCITY}
STR_VEHICLE_STATUS_BROKEN_DOWN_VEL :{RED}Broken down - {STRING2}, {LTBLUE} {VELOCITY}
STR_VEHICLE_STATUS_BROKEN_DOWN_VEL_SHORT :{RED}Broken down - {STRING2}
STR_VEHICLE_STATUS_TRAIN_STOPPING_VEL :{RED}Stopping, {VELOCITY}
STR_VEHICLE_STATUS_TRAIN_NO_POWER :{RED}No power
STR_VEHICLE_STATUS_TRAIN_STUCK :{ORANGE}Waiting for free path
@ -3661,7 +3662,7 @@ STR_VEHICLE_INFO_AGE_RUNNING_COST_YR :{BLACK}Age: {LT
STR_RUNNING :{LTBLUE}Running
STR_NEED_REPAIR :{ORANGE}Train needs repair - max speed reduced to {VELOCITY}
STR_CURRENT_STATUS :{BLACK}Current status: {STRING2}
STR_CURRENT_STATUS :{BLACK}Current status: {STRING3}
# The next two need to stay in this order
STR_VEHICLE_INFO_AGE :{COMMA} year{P "" s} ({COMMA})

2
src/roadveh_cmd.cpp
View File

@ -298,7 +298,7 @@ CommandCost CmdBuildRoadVehicle(TileIndex tile, DoCommandFlag flags, const Engin
v->reliability = e->reliability;
v->reliability_spd_dec = e->reliability_spd_dec;
v->breakdown_chance = 128;
v->breakdown_chance_factor = 128;
v->max_age = e->GetLifeLengthInDays();
_new_vehicle_id = v->index;

25
src/saveload/afterload.cpp
View File

@ -2820,13 +2820,11 @@ bool AfterLoadGame()
/* Set some breakdown-related variables to the correct values. */
if (SlXvIsFeatureMissing(XSLFI_IMPROVED_BREAKDOWNS)) {
Vehicle *v;
FOR_ALL_VEHICLES(v) {
switch(v->type) {
case VEH_TRAIN: {
if (Train::From(v)->IsFrontEngine()) {
if (v->breakdown_ctr == 1) SetBit(Train::From(v)->flags, VRF_BREAKDOWN_STOPPED);
} else if (Train::From(v)->IsEngine() || Train::From(v)->IsMultiheaded()) {
Train *v;
FOR_ALL_TRAINS(v) {
if (v->IsFrontEngine()) {
if (v->breakdown_ctr == 1) SetBit(v->flags, VRF_BREAKDOWN_STOPPED);
} else if (v->IsEngine() || v->IsMultiheaded()) {
/** Non-front engines could have a reliability of 0.
* Set it to the reliability of the front engine or the maximum, whichever is lower. */
const Engine *e = Engine::Get(v->engine_type);
@ -2834,17 +2832,22 @@ bool AfterLoadGame()
v->reliability = min(v->First()->reliability, e->reliability);
}
}
/* FALL THROUGH */
}
if (!SlXvIsFeaturePresent(XSLFI_IMPROVED_BREAKDOWNS, 3)) {
Vehicle *v;
FOR_ALL_VEHICLES(v) {
switch(v->type) {
case VEH_TRAIN:
case VEH_ROAD:
v->breakdown_chance = 128;
v->breakdown_chance_factor = 128;
break;
case VEH_SHIP:
v->breakdown_chance = 64;
v->breakdown_chance_factor = 64;
break;
case VEH_AIRCRAFT:
v->breakdown_chance = Clamp(64 + (AircraftVehInfo(v->engine_type)->max_speed >> 3), 0, 255);
v->breakdown_chance_factor = Clamp(64 + (AircraftVehInfo(v->engine_type)->max_speed >> 3), 0, 255);
v->breakdown_severity = 40;
break;

2
src/saveload/extended_ver_sl.cpp
View File

@ -45,7 +45,7 @@ std::vector<uint32> _sl_xv_discardable_chunk_ids; ///< list of chunks
static const uint32 _sl_xv_slxi_chunk_version = 0; ///< current version os SLXI chunk
const SlxiSubChunkInfo _sl_xv_sub_chunk_infos[] = {
{ XSLFI_IMPROVED_BREAKDOWNS, XSCF_NULL, 2, 2, "improved_breakdowns", NULL, NULL, NULL },
{ XSLFI_IMPROVED_BREAKDOWNS, XSCF_NULL, 3, 3, "improved_breakdowns", NULL, NULL, NULL },
{ XSLFI_NULL, XSCF_NULL, 0, 0, NULL, NULL, NULL, NULL },// This is the end marker
};

1
src/saveload/vehicle_sl.cpp
View File

@ -671,6 +671,7 @@ const SaveLoad *GetVehicleDescription(VehicleType vt)
SLE_VAR(Vehicle, breakdown_delay, SLE_UINT8),
SLE_VAR(Vehicle, breakdowns_since_last_service, SLE_UINT8),
SLE_VAR(Vehicle, breakdown_chance, SLE_UINT8),
SLE_CONDVAR_X(Vehicle, breakdown_chance_factor, SLE_UINT8, 0, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS, 3)),
SLE_CONDVAR_X(Vehicle, breakdown_type, SLE_UINT8, 0, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS)),
SLE_CONDVAR_X(Vehicle, breakdown_severity, SLE_UINT8, 0, SL_MAX_VERSION, SlXvFeatureTest(XSLFTO_AND, XSLFI_IMPROVED_BREAKDOWNS)),
SLE_CONDVAR(Vehicle, build_year, SLE_FILE_U8 | SLE_VAR_I32, 0, 30),

28
src/settings.cpp
View File

@ -1025,7 +1025,7 @@ static bool RoadVehAccelerationModelChanged(int32 p1)
RoadVehicle *rv;
FOR_ALL_ROADVEHICLES(rv) {
if (rv->IsFrontEngine()) {
rv->breakdown_chance = 128;
rv->breakdown_chance_factor = 128;
}
}
}
@ -1324,6 +1324,32 @@ static bool MaxVehiclesChanged(int32 p1)
return true;
}
static bool ImprovedBreakdownsSettingChanged(int32 p1)
{
if (!_settings_game.vehicle.improved_breakdowns) return true;
Vehicle *v;
FOR_ALL_VEHICLES(v) {
switch(v->type) {
case VEH_TRAIN:
if (v->IsFrontEngine()) {
v->breakdown_chance_factor = 128;
Train::From(v)->UpdateAcceleration();
}
break;
case VEH_ROAD:
if (v->IsFrontEngine()) {
v->breakdown_chance_factor = 128;
}
break;
default:
break;
}
}
return true;
}
#ifdef ENABLE_NETWORK

2
src/ship_cmd.cpp
View File

@ -714,7 +714,7 @@ CommandCost CmdBuildShip(TileIndex tile, DoCommandFlag flags, const Engine *e, u
v->reliability = e->reliability;
v->reliability_spd_dec = e->reliability_spd_dec;
v->breakdown_chance = 64; // ships have a 50% lower breakdown chance than normal
v->breakdown_chance_factor = 64; // ships have a 50% lower breakdown chance than normal
v->max_age = e->GetLifeLengthInDays();
_new_vehicle_id = v->index;

2
src/table/settings.ini
View File

@ -42,6 +42,7 @@ static bool InvalidateCompanyInfrastructureWindow(int32 p1);
static bool InvalidateCompanyWindow(int32 p1);
static bool ZoomMinMaxChanged(int32 p1);
static bool MaxVehiclesChanged(int32 p1);
static bool ImprovedBreakdownsSettingChanged(int32 p1);
#ifdef ENABLE_NETWORK
static bool UpdateClientName(int32 p1);
@ -1144,6 +1145,7 @@ var = vehicle.improved_breakdowns
guiflags = SGF_NO_NETWORK
def = false
str = STR_CONFIG_SETTING_IMPROVED_BREAKDOWNS
proc = ImprovedBreakdownsSettingChanged
patxname = ""improved_breakdowns.vehicle.improved_breakdowns""
; station.join_stations

2
src/train.h
View File

@ -292,7 +292,7 @@ protected: // These functions should not be called outside acceleration code.
*/
inline AccelStatus GetAccelerationStatus() const
{
return (this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK ) || HasBit(this->flags, VRF_BREAKDOWN_BRAKING) ? AS_BRAKE : AS_ACCEL;
return ((this->vehstatus & VS_STOPPED) || HasBit(this->flags, VRF_REVERSING) || HasBit(this->flags, VRF_TRAIN_STUCK) || HasBit(this->flags, VRF_BREAKDOWN_BRAKING)) ? AS_BRAKE : AS_ACCEL;
}
/**

5
src/train_cmd.cpp
View File

@ -492,10 +492,8 @@ void Train::UpdateAcceleration()
if (_settings_game.vehicle.improved_breakdowns) {
if (_settings_game.vehicle.train_acceleration_model == AM_ORIGINAL) {
this->breakdown_chance = max(128 * 3 / (this->tcache.cached_num_engines + 2), 5);
this->breakdown_chance_factor = max(128 * 3 / (this->tcache.cached_num_engines + 2), 5);
}
} else {
this->breakdown_chance = 128;
}
}
@ -4055,7 +4053,6 @@ void Train::OnNewDay()
if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);
if (this->IsFrontEngine()) {
CheckIfTrainNeedsService(this);
CheckOrders(this);

2
src/train_gui.cpp
View File

@ -254,7 +254,7 @@ static void TrainDetailsInfoTab(const Train *v, int left, int right, int y, byte
case 2:
if (v->breakdown_ctr == 1) {
if (_settings_game.vehicle.improved_breakdowns) {
SetDParam(0, STR_VEHICLE_STATUS_BROKEN_DOWN_VEL);
SetDParam(0, STR_VEHICLE_STATUS_BROKEN_DOWN_VEL_SHORT);
SetDParam(1, STR_BREAKDOWN_TYPE_CRITICAL + v->breakdown_type);
if (v->breakdown_type == BREAKDOWN_LOW_SPEED) {
SetDParam(2, min(v->First()->GetCurrentMaxSpeed(), v->breakdown_severity));

23
src/vehicle.cpp
View File

@ -123,6 +123,8 @@ void VehicleServiceInDepot(Vehicle *v)
v->date_of_last_service = _date;
v->breakdowns_since_last_service = 0;
v->reliability = v->GetEngine()->reliability;
/* Prevent vehicles from breaking down directly after exiting the depot. */
v->breakdown_chance = 0;
v = v->Next();
} while (v != NULL && v->HasEngineType());
}
@ -1277,15 +1279,21 @@ void CheckVehicleBreakdown(Vehicle *v)
return;
}
uint32 r1 = Random();
uint32 r2 = Random();
uint32 r = Random();
/* increase chance of failure */
int chance = v->breakdown_chance + 1;
if (Chance16I(1, 25, r)) chance += 25;
chance = min(255, chance);
v->breakdown_chance = chance;
byte chance = 128;
if (_settings_game.vehicle.improved_breakdowns) {
if (v->type == VEH_TRAIN && Train::From(v)->IsMultiheaded()) {
/* Dual engines have their breakdown chances reduced to 70% of the normal value */
chance = (v->type == VEH_TRAIN && Train::From(v)->IsMultiheaded()) ? v->First()->breakdown_chance * 7 / 10 : v->First()->breakdown_chance;
} else if(v->type == VEH_SHIP) {
chance = 64;
chance = chance * 7 / 10;
}
chance *= v->First()->breakdown_chance_factor;
chance >>= 7;
}
/**
* Chance is (1 - reliability) * breakdown_setting * breakdown_chance / 10.
@ -1295,9 +1303,12 @@ void CheckVehicleBreakdown(Vehicle *v)
* However, because breakdowns are no longer by definition a complete stop,
* their impact will be significantly less.
*/
uint32 r1 = Random();
if ((uint32) (0xffff - v->reliability) * _settings_game.difficulty.vehicle_breakdowns * chance > GB(r1, 0, 24) * 10) {
uint32 r2 = Random();
v->breakdown_ctr = GB(r1, 24, 6) + 0xF;
v->breakdown_delay = GB(r2, 0, 7) + 0x80;
v->breakdown_chance = 0;
DetermineBreakdownType(v, r2);
}
}

1
src/vehicle_base.h
View File

@ -195,6 +195,7 @@ public:
byte breakdown_severity; ///< severity of the breakdown. Note that lower means more severe
byte breakdown_type; ///< Type of breakdown
byte breakdown_chance_factor; ///< Improved breakdowns: current multiplier for breakdown_chance * 128, used for head vehicle only
SpriteID colourmap; ///< NOSAVE: cached colour mapping
/* Related to age and service time */

12
src/vehicle_gui.cpp
View File

@ -2613,7 +2613,7 @@ public:
} else if (v->breakdown_ctr == 1 || (v->type == VEH_TRAIN && Train::From(v)->flags & VRF_IS_BROKEN)) {
if (_settings_game.vehicle.improved_breakdowns) {
str = STR_VEHICLE_STATUS_BROKEN_DOWN_VEL;
SetDParam(2, v->GetDisplaySpeed());
SetDParam(3, v->GetDisplaySpeed());
} else {
str = STR_VEHICLE_STATUS_BROKEN_DOWN;
}
@ -2632,7 +2632,15 @@ public:
if (w->breakdown_type == BREAKDOWN_LOW_SPEED) {
SetDParam(1, min(w->First()->GetDisplayMaxSpeed(), w->breakdown_severity >> ((v->type == VEH_TRAIN) ? 0 : 1)));
} else if (w->breakdown_type == BREAKDOWN_LOW_POWER) {
SetDParam(1, w->breakdown_severity * 100 / 256);
int percent;
if (v->type == VEH_TRAIN) {
uint32 power, te;
Train::From(v)->CalculatePower(power, te, true);
percent = (100 * power) / Train::From(v)->gcache.cached_power;
} else {
percent = w->breakdown_severity * 100 / 256;
}
SetDParam(1, percent);
}
}
} else if (v->vehstatus & VS_STOPPED) {