summaryrefslogtreecommitdiff
path: root/train_cmd.c
diff options
context:
space:
mode:
Diffstat (limited to 'train_cmd.c')
-rw-r--r--train_cmd.c302
1 files changed, 213 insertions, 89 deletions
diff --git a/train_cmd.c b/train_cmd.c
index 32b89974e..5853116b1 100644
--- a/train_cmd.c
+++ b/train_cmd.c
@@ -34,6 +34,200 @@ static const byte _signal_otherdir[14] = {
0x80, 0x80, 0x80, 0x20, 0x40, 0x10
};
+static const byte _curve_neighbours45[8][2] = {
+ {7, 1},
+ {0, 2},
+ {1, 3},
+ {2, 4},
+ {3, 5},
+ {4, 6},
+ {5, 7},
+ {6, 0},
+};
+
+static const byte _curve_neighbours90[8][2] = {
+ {6, 2},
+ {7, 3},
+ {0, 4},
+ {1, 5},
+ {2, 6},
+ {3, 7},
+ {4, 0},
+ {5, 1},
+};
+
+enum AccelType {
+ AM_ACCEL,
+ AM_BRAKE
+};
+
+//new acceleration
+static int GetTrainAcceleration(Vehicle *v, bool mode)
+{
+ Vehicle *u = v;
+ int num = 0; //number of vehicles, change this into the number of axles later
+ int power = 0;
+ int mass = 0;
+ int max_speed = 2000;
+ int area = 120;
+ int friction = 35; //[1e-3]
+ int drag_coeff = 20; //[1e-4]
+ int incl = 0;
+ int resistance;
+ int speed = v->cur_speed; //[mph]
+ int force = 0x3FFFFFFF;
+ int pos = 0;
+ int lastpos = -1;
+ int curvecount[2] = {0, 0};
+ int *dist = NULL;
+ int sum = 0;
+ int numcurve = 0;
+ int i;
+
+ speed *= 10;
+ speed /= 16;
+
+ //first find the curve speed limit
+ for (; u->next != NULL; u = u->next, pos++) {
+ int dir = u->direction;
+ int ndir = u->next->direction;
+
+ for (i = 0; i < 2; i++) {
+ if ( _curve_neighbours45[dir][i] == ndir) {
+ curvecount[i]++;
+ if (lastpos != -1) {
+ dist = realloc(dist, sizeof(int) * ++numcurve);
+ dist[numcurve - 1] = pos - lastpos;
+ if (pos - lastpos == 1) {
+ max_speed = 88;
+ }
+ }
+ lastpos = pos;
+ }
+ }
+
+ //if we have a 90 degree turn, fix the speed limit to 60
+ if ( _curve_neighbours90[dir][0] == ndir || _curve_neighbours90[dir][1] == ndir) {
+ max_speed = 61;
+ }
+ }
+
+ for(i = 0; i < numcurve; i++) {
+ sum += dist[i];
+ }
+
+ if (numcurve > 0) {
+ sum /= numcurve;
+ }
+
+ if ((curvecount[0] != 0 || curvecount[1] != 0) && (max_speed > 88)) {
+ int total = curvecount[0] + curvecount[1];
+ if (curvecount[0] == 1 && curvecount[1] == 1) {
+ max_speed = 0xFFFF;
+ } else if (total > 1) {
+ max_speed = 232 - (13 - clamp(sum, 1, 12)) * (13 - clamp(sum, 1, 12));
+ }
+ }
+
+ max_speed += (max_speed / 2) * v->u.rail.railtype;
+
+ if (IsTileType(v->tile, MP_STATION) && v->subtype == TS_Front_Engine) {
+ static const TileIndexDiffC _station_dir_from_vdir[] = {
+ {0, 0}, {-1, 0}, {0, 0}, {0, 1}, {0, 0}, {1, 0}, {0, 0}, {0, -1}
+ };
+
+ if (((v->current_order.station == _map2[v->tile]) || !(v->current_order.flags & OF_NON_STOP)) && v->last_station_visited != _map2[v->tile]) {
+ int station_length = 0;
+ TileIndex tile = v->tile;
+ int delta_v;
+
+ max_speed = 120;
+ do {
+ station_length++;
+ tile = TILE_ADD(tile, ToTileIndexDiff(_station_dir_from_vdir[v->direction]));
+ } while (IsTileType(tile, MP_STATION));
+
+ delta_v = v->cur_speed / (station_length + 1);
+ if (v->max_speed > (v->cur_speed - delta_v))
+ max_speed = v->cur_speed - (delta_v / 10);
+
+ max_speed = max(max_speed, 25 * station_length);
+ }
+ }
+
+ for (u = v; u != NULL; u = u->next) {
+ const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
+ int vmass;
+
+ num++;
+ power += rvi->power * 746; //[W]
+ drag_coeff += 3;
+
+ if (rvi->max_speed != 0)
+ max_speed = min(rvi->max_speed, max_speed);
+
+ if (u->u.rail.track == 0x80)
+ max_speed = 61;
+
+ vmass = rvi->weight; //[t]
+ vmass += (_cargoc.weights[u->cargo_type] * u->cargo_count) / 16;
+ mass += vmass; //[t]
+
+ if (!IsTileType(u->tile, MP_TUNNELBRIDGE)) {
+ if (HASBIT(u->u.rail.flags, VRF_GOINGUP)) {
+ incl += vmass * 60; //3% slope, quite a bit actually
+ } else if (HASBIT(u->u.rail.flags, VRF_GOINGDOWN)) {
+ incl -= vmass * 60;
+ }
+ }
+ }
+
+
+ // these are shown in the UI
+ v->u.rail.cached_weight = mass;
+ v->u.rail.cached_power = power / 746;
+ v->max_speed = max_speed;
+
+
+ if (v->u.rail.railtype != 2) {
+ resistance = 13 * mass / 10;
+ resistance += 60 * num;
+ resistance += friction * mass * speed / 1000;
+ resistance += (area * drag_coeff * speed * speed) / 10000;
+ } else
+ resistance = (area * (drag_coeff / 2) * speed * speed) / 10000;
+ resistance += incl;
+ resistance *= 4; //[N]
+
+ if (speed > 0) {
+ switch (v->u.rail.railtype) {
+ case 0:
+ case 1:
+ {
+ force = power / speed; //[N]
+ force *= 22;
+ force /= 10;
+ } break;
+ case 2:
+ force = power / 25;
+ break;
+ }
+ } else
+ //"kickoff" acceleration
+ force = resistance * 10;
+
+ if (force <= 0) force = 10000;
+
+ if (v->u.rail.railtype != 2)
+ force = min(force, mass * 10 * 200);
+
+ if (mode == AM_ACCEL) {
+ return (force - resistance) / (mass * 4);
+ } else {
+ return min((-force - resistance) /(mass * 4), (10000 / (mass * 4)));
+ }
+}
+
void UpdateTrainAcceleration(Vehicle *v)
{
uint acc, power=0, max_speed=5000, weight=0;
@@ -73,84 +267,6 @@ void UpdateTrainAcceleration(Vehicle *v)
v->acceleration = (byte)acc;
}
-#define F_GRAV 9.82f
-#define F_THETA 0.05f
-
-#define F_HP_KW 0.74569f
-#define F_KPH_MS 0.27778f
-#define F_MU 0.3f
-
-#define F_COEF_FRIC 0.04f
-#define F_COEF_ROLL 0.18f
-
-#define F_CURVE_FACTOR (1/96.f)
-
-static int GetRealisticAcceleration(Vehicle *v)
-{
- uint emass = 0;
- Vehicle *u = v;
- float f = 0.0f, spd;
- int curves = 0;
-
- assert(v->subtype == TS_Front_Engine);
-
- // compute inclination force and number of curves.
- do {
- const RailVehicleInfo *rvi = RailVehInfo(u->engine_type);
- uint mass = rvi->weight + ((_cargoc.weights[u->cargo_type] * u->cargo_count) >> 4);
- if (rvi->power) emass += mass;
-
- if (!IsTileType(u->tile, MP_TUNNELBRIDGE)) {
- if (HASBIT(u->u.rail.flags, VRF_GOINGUP)) {
- f += (float)mass * ( -F_GRAV * F_THETA);
- } else if (HASBIT(u->u.rail.flags, VRF_GOINGDOWN)) {
- f += (float)mass * ( F_GRAV * F_THETA);
- }
- }
-
- // compute curve penalty..
- if (u->next != NULL) {
- uint diff = (u->direction - u->next->direction) & 7;
- if (diff) {
- curves += (diff == 1 || diff == 7) ? 1 : 3;
- }
- }
- } while ((u = u->next) != NULL);
-
- spd = (float)(v->cur_speed ? v->cur_speed : 1);
-
- // compute tractive effort
- {
- float te = (float)v->u.rail.cached_power * (F_HP_KW/F_KPH_MS) / spd;
- float te2 = (float)emass * (F_MU * F_GRAV);
- if (te > te2) te = te2;
- f += te;
- }
-
- // add air resistance
- {
- float cx = 1.0f; // NOT DONE
-
- // air resistance is doubled in tunnels.
- if (v->vehstatus == 0x40) cx *= 2;
-
- f -= cx * spd * spd * (F_KPH_MS * F_KPH_MS * 0.001f);
- }
-
- // after this f contains the acceleration.
- f /= (float)v->u.rail.cached_weight;
-
- // add friction to sum of forces (avoid mul by weight). (0.001 because we want kN)
- f -= (F_COEF_FRIC * F_GRAV * 0.001f + (F_COEF_ROLL * F_KPH_MS * F_GRAV * 0.001f) * spd);
-
- // penalty for curves?
- if (curves)
- f -= (float)min(curves, 8) * F_CURVE_FACTOR;
-
- return (int)(f * (1.0/(F_KPH_MS * 0.015f)) + 0.5f);
-}
-
-
int GetTrainImage(Vehicle *v, byte direction)
{
int img = v->spritenum;
@@ -1517,9 +1633,9 @@ static byte ChooseTrainTrack(Vehicle *v, uint tile, int direction, byte trackbit
fd.best_track_dist = (uint)-1;
NewTrainPathfind(tile, _search_directions[i][direction], (TPFEnumProc*)TrainTrackFollower, &fd, NULL);
- if (best_track != -1) {
- if (best_track_dist == -1) {
- if (fd.best_track_dist == -1) {
+ if (best_track != (uint)-1) {
+ if (best_track_dist == (uint)-1) {
+ if (fd.best_track_dist == (uint)-1) {
/* neither reached the destination, pick the one with the smallest bird dist */
if (fd.best_bird_dist > best_bird_dist) goto bad;
if (fd.best_bird_dist < best_bird_dist) goto good;
@@ -1528,7 +1644,7 @@ static byte ChooseTrainTrack(Vehicle *v, uint tile, int direction, byte trackbit
goto good;
}
} else {
- if (fd.best_track_dist == -1) {
+ if (fd.best_track_dist == (uint)-1) {
/* didn't find destination, but we've found the destination previously */
goto bad;
} else {
@@ -1553,7 +1669,7 @@ static byte ChooseTrainTrack(Vehicle *v, uint tile, int direction, byte trackbit
bad:;
} while (bits != 0);
// printf("Train %d %s\n", v->unitnumber, best_track_dist == -1 ? "NOTFOUND" : "FOUND");
- assert(best_track != -1);
+ assert(best_track != (uint)-1);
}
#if 0
@@ -1782,17 +1898,25 @@ static int UpdateTrainSpeed(Vehicle *v)
uint accel;
if (v->vehstatus & VS_STOPPED || HASBIT(v->u.rail.flags, VRF_REVERSING)) {
- accel = -v->acceleration * 2;
+ if (_patches.realistic_acceleration)
+ accel = GetTrainAcceleration(v, AM_BRAKE) * 2;
+ else
+ accel = v->acceleration * -2;
} else {
- accel = v->acceleration;
- if (_patches.realistic_acceleration) {
- accel = GetRealisticAcceleration(v);
- }
+ if (_patches.realistic_acceleration)
+ accel = GetTrainAcceleration(v, AM_ACCEL);
+ else
+ accel = v->acceleration;
}
spd = v->subspeed + accel * 2;
v->subspeed = (byte)spd;
- v->cur_speed = spd = clamp(v->cur_speed + ((int)spd >> 8), 0, v->max_speed);
+ {
+ int tempmax = v->max_speed;
+ if (v->cur_speed > v->max_speed)
+ tempmax = v->cur_speed - (v->cur_speed / 10) - 1;
+ v->cur_speed = spd = clamp(v->cur_speed + ((int)spd >> 8), 0, tempmax);
+ }
if (!(v->direction & 1)) spd = spd * 3 >> 2;
generated by cgit v1.2.3-70-g09d2 (git 2.47.1) at 2024-12-29 00:43:07 +0000