Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "stdafx.h"
00013 #include "train.h"
00014 #include "roadveh.h"
00015 #include "vehicle_gui.h"
00016 #include "window_func.h"
00017
00021 template <class T, VehicleType Type>
00022 void GroundVehicle<T, Type>::PowerChanged()
00023 {
00024 assert(this->First() == this);
00025 const T *v = T::From(this);
00026
00027 uint32 total_power = 0;
00028 uint32 max_te = 0;
00029 uint32 number_of_parts = 0;
00030 uint16 max_track_speed = v->GetDisplayMaxSpeed();
00031
00032 for (const T *u = v; u != NULL; u = u->Next()) {
00033 uint32 current_power = u->GetPower() + u->GetPoweredPartPower(u);
00034 total_power += current_power;
00035
00036
00037 if (current_power > 0) max_te += u->GetWeight() * u->GetTractiveEffort();
00038 number_of_parts++;
00039
00040
00041 uint16 track_speed = u->GetMaxTrackSpeed();
00042 if (track_speed > 0) max_track_speed = min(max_track_speed, track_speed);
00043 }
00044
00045 byte air_drag;
00046 byte air_drag_value = v->GetAirDrag();
00047
00048
00049 if (air_drag_value == 0) {
00050 uint16 max_speed = v->GetDisplayMaxSpeed();
00051
00052 air_drag = (max_speed <= 10) ? 192 : max(2048 / max_speed, 1);
00053 } else {
00054
00055 air_drag = (air_drag_value == 1) ? 0 : air_drag_value;
00056 }
00057
00058 this->gcache.cached_air_drag = air_drag + 3 * air_drag * number_of_parts / 20;
00059
00060 max_te *= 10000;
00061 max_te /= 256;
00062 if (this->gcache.cached_power != total_power || this->gcache.cached_max_te != max_te) {
00063
00064 if (total_power == 0) this->vehstatus |= VS_STOPPED;
00065
00066 this->gcache.cached_power = total_power;
00067 this->gcache.cached_max_te = max_te;
00068 SetWindowDirty(WC_VEHICLE_DETAILS, this->index);
00069 SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, VVW_WIDGET_START_STOP_VEH);
00070 }
00071
00072 this->gcache.cached_max_track_speed = max_track_speed;
00073 }
00074
00079 template <class T, VehicleType Type>
00080 void GroundVehicle<T, Type>::CargoChanged()
00081 {
00082 assert(this->First() == this);
00083 uint32 weight = 0;
00084
00085 for (T *u = T::From(this); u != NULL; u = u->Next()) {
00086 uint32 current_weight = u->GetWeight();
00087 weight += current_weight;
00088
00089 u->gcache.cached_slope_resistance = current_weight * u->GetSlopeSteepness() * 100;
00090 }
00091
00092
00093 this->gcache.cached_weight = max<uint32>(1, weight);
00094
00095 this->gcache.cached_axle_resistance = 10 * weight;
00096
00097
00098 this->PowerChanged();
00099 }
00100
00105 template <class T, VehicleType Type>
00106 int GroundVehicle<T, Type>::GetAcceleration() const
00107 {
00108
00109 const T *v = T::From(this);
00110 int32 speed = v->GetCurrentSpeed();
00111
00112
00113 int32 mass = this->gcache.cached_weight;
00114
00115
00116 int32 power = this->gcache.cached_power * 746;
00117
00118 int32 resistance = 0;
00119
00120 bool maglev = v->GetAccelerationType() == 2;
00121
00122 const int area = v->GetAirDragArea();
00123 if (!maglev) {
00124
00125 resistance = this->gcache.cached_axle_resistance;
00126 resistance += mass * v->GetRollingFriction();
00127 }
00128
00129
00130 resistance += (area * this->gcache.cached_air_drag * speed * speed) / 1000;
00131
00132 resistance += this->GetSlopeResistance();
00133
00134
00135 AccelStatus mode = v->GetAccelerationStatus();
00136
00137 const int max_te = this->gcache.cached_max_te;
00138 int force;
00139 if (speed > 0) {
00140 if (!maglev) {
00141
00142 force = power * 18 / (speed * 5);
00143 if (mode == AS_ACCEL && force > max_te) force = max_te;
00144 } else {
00145 force = power / 25;
00146 }
00147 } else {
00148
00149 force = (mode == AS_ACCEL && !maglev) ? min(max_te, power) : power;
00150 force = max(force, (mass * 8) + resistance);
00151 }
00152
00153 if (mode == AS_ACCEL) {
00154
00155 if (force == resistance) return 0;
00156
00157
00158
00159
00160
00161
00162 int accel = (force - resistance) / (mass * 4);
00163 return force < resistance ? min(-1, accel) : max(1, accel);
00164 } else {
00165 return min(-force - resistance, -10000) / mass;
00166 }
00167 }
00168
00169
00170 template struct GroundVehicle<Train, VEH_TRAIN>;
00171
00172 template struct GroundVehicle<RoadVehicle, VEH_ROAD>;