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 "depot_map.h"
00016
00020 template <class T, VehicleType Type>
00021 void GroundVehicle<T, Type>::PowerChanged()
00022 {
00023 assert(this->First() == this);
00024 const T *v = T::From(this);
00025
00026 uint32 total_power = 0;
00027 uint32 max_te = 0;
00028 uint32 number_of_parts = 0;
00029 uint16 max_track_speed = v->GetDisplayMaxSpeed();
00030
00031 for (const T *u = v; u != NULL; u = u->Next()) {
00032 uint32 current_power = u->GetPower() + u->GetPoweredPartPower(u);
00033 total_power += current_power;
00034
00035
00036 if (current_power > 0) max_te += u->GetWeight() * u->GetTractiveEffort();
00037 number_of_parts++;
00038
00039
00040 uint16 track_speed = u->GetMaxTrackSpeed();
00041 if (track_speed > 0) max_track_speed = min(max_track_speed, track_speed);
00042 }
00043
00044 byte air_drag;
00045 byte air_drag_value = v->GetAirDrag();
00046
00047
00048 if (air_drag_value == 0) {
00049 uint16 max_speed = v->GetDisplayMaxSpeed();
00050
00051 air_drag = (max_speed <= 10) ? 192 : max(2048 / max_speed, 1);
00052 } else {
00053
00054 air_drag = (air_drag_value == 1) ? 0 : air_drag_value;
00055 }
00056
00057 this->gcache.cached_air_drag = air_drag + 3 * air_drag * number_of_parts / 20;
00058
00059 max_te *= 10000;
00060 max_te /= 256;
00061 if (this->gcache.cached_power != total_power || this->gcache.cached_max_te != max_te) {
00062
00063 if (total_power == 0) this->vehstatus |= VS_STOPPED;
00064
00065 this->gcache.cached_power = total_power;
00066 this->gcache.cached_max_te = max_te;
00067 SetWindowDirty(WC_VEHICLE_DETAILS, this->index);
00068 SetWindowWidgetDirty(WC_VEHICLE_VIEW, this->index, WID_VV_START_STOP);
00069 }
00070
00071 this->gcache.cached_max_track_speed = max_track_speed;
00072 }
00073
00078 template <class T, VehicleType Type>
00079 void GroundVehicle<T, Type>::CargoChanged()
00080 {
00081 assert(this->First() == this);
00082 uint32 weight = 0;
00083
00084 for (T *u = T::From(this); u != NULL; u = u->Next()) {
00085 uint32 current_weight = u->GetWeight();
00086 weight += current_weight;
00087
00088 u->gcache.cached_slope_resistance = current_weight * u->GetSlopeSteepness() * 100;
00089 }
00090
00091
00092 this->gcache.cached_weight = max<uint32>(1, weight);
00093
00094 this->gcache.cached_axle_resistance = 10 * weight;
00095
00096
00097 this->PowerChanged();
00098 }
00099
00104 template <class T, VehicleType Type>
00105 int GroundVehicle<T, Type>::GetAcceleration() const
00106 {
00107
00108 const T *v = T::From(this);
00109
00110 int64 speed = v->GetCurrentSpeed();
00111
00112
00113 int32 mass = this->gcache.cached_weight;
00114
00115
00116
00117
00118
00119 int64 power = this->gcache.cached_power * 746ll;
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132 int64 resistance = 0;
00133
00134 bool maglev = v->GetAccelerationType() == 2;
00135
00136 const int area = v->GetAirDragArea();
00137 if (!maglev) {
00138
00139 resistance = this->gcache.cached_axle_resistance;
00140 resistance += mass * v->GetRollingFriction();
00141 }
00142
00143
00144 resistance += (area * this->gcache.cached_air_drag * speed * speed) / 1000;
00145
00146 resistance += this->GetSlopeResistance();
00147
00148
00149 AccelStatus mode = v->GetAccelerationStatus();
00150
00151 const int max_te = this->gcache.cached_max_te;
00152
00153
00154 int64 force;
00155 if (speed > 0) {
00156 if (!maglev) {
00157
00158 force = power * 18 / (speed * 5);
00159 if (mode == AS_ACCEL && force > max_te) force = max_te;
00160 } else {
00161 force = power / 25;
00162 }
00163 } else {
00164
00165 force = (mode == AS_ACCEL && !maglev) ? min(max_te, power) : power;
00166 force = max(force, (mass * 8) + resistance);
00167 }
00168
00169 if (mode == AS_ACCEL) {
00170
00171 if (force == resistance) return 0;
00172
00173
00174
00175
00176
00177
00178 int accel = ClampToI32((force - resistance) / (mass * 4));
00179 return force < resistance ? min(-1, accel) : max(1, accel);
00180 } else {
00181 return ClampToI32(min(-force - resistance, -10000) / mass);
00182 }
00183 }
00184
00189 template <class T, VehicleType Type>
00190 bool GroundVehicle<T, Type>::IsChainInDepot() const
00191 {
00192 const T *v = this->First();
00193
00194 assert_compile((int)TRANSPORT_RAIL == (int)VEH_TRAIN);
00195 assert_compile((int)TRANSPORT_ROAD == (int)VEH_ROAD);
00196 if (!IsDepotTypeTile(v->tile, (TransportType)Type) || v->cur_speed != 0) return false;
00197
00198
00199 for (; v != NULL; v = v->Next()) {
00200 if (!v->T::IsInDepot() || v->tile != this->tile) return false;
00201 }
00202
00203 return true;
00204 }
00205
00206
00207 template struct GroundVehicle<Train, VEH_TRAIN>;
00208
00209 template struct GroundVehicle<RoadVehicle, VEH_ROAD>;