solar = function (runner, MPS, fatigue, time = 0) {
const V = runner.MPS2V(MPS);
const readyness = 1 - fatigue;
const PR = Math.min(1, MPS / runner.V2MPS(1.5));
const tStart = 0;
const TStart = runner.pRest;
const pStand = runner.pRest * 1.12 * 1.2;
const timeBasis = 1536 * Math.pow(16, -V);
const t8 = Math.min(24, Math.max(1.5, Math.min(timeBasis, 2 * runner.X)));
const t10 = Math.max(2.1, Math.min(runner.Xf * timeBasis, 8 * runner.X));
var Xdrift = V < 2 ? runner.X : (runner.X * timeBasis) / 6;
const T6 = TStart + (runner.V2P(1.5) - TStart) * PR;
const t9 = Math.max(
2.5,
Math.min(t8 + (t10 - t8) / 2, runner.X * 2, -Xdrift + (Xdrift + t10) * 0.6)
);
let T8;
let T9;
const Tbase8 =
runner.V2P(1.5) +
(readyness * 1.5 * runner.P_i * (Math.min(runner.X * 2, 24) + Xdrift)) /
(9 * Xdrift);
const Tbase9 = Tbase8 + 0.15 * readyness * runner.P_i;
const Tbase10 = Tbase9 + 0.1 * readyness * runner.P_i;
if (V > 1.5) {
T8 = Math.min(
runner.V2P(1.5 + readyness * 0.5) +
(readyness * runner.P_i * 3) / runner.X,
runner.V2P(1.5) +
(readyness * 1.5 * runner.P_i * (t8 + Xdrift)) / (t10 + Xdrift)
);
T9 = Math.min(
runner.V2P(1.5) +
(readyness * 1.5 * runner.P_i * (t9 + Xdrift)) / (t10 + Xdrift),
runner.V2P(1.5 + 0.6 * 1.5 * readyness)
);
} else {
T8 =
T6 +
((readyness * 1.5 * runner.P_i * (Math.min(runner.X * 2, 24) + Xdrift)) /
(9 * Xdrift)) *
PR;
T9 = (T8 * Tbase9) / Tbase8;
}
const T10 = V > 1.5 ? T9 + readyness * runner.P_i * 0.1 : T9;
const const7 = 1.75;
const T7 = T6 + (T8 - T6) / const7;
const T5 = TStart + (runner.V2p(1.25) - TStart) * PR;
const T4 = TStart + (runner.V2p(1) - TStart) * PR;
const T3 = TStart + (runner.V2p(0.75) - TStart) * PR;
const T2 = Math.max(TStart + (runner.V2p(0.5) - TStart) * PR, TStart);
const T1 = Math.max(TStart + (runner.V2p(0.25) - TStart) * PR, TStart);
const T0 = Math.max(TStart + (runner.V2p(0) - TStart) * PR, TStart);
const t7 = Math.max(
0.75,
(-Xdrift / 8 + (t8 + Xdrift / 8) / const7) / Math.sqrt(readyness)
);
const t6 =
Math.min(4, Math.max(0.5, Math.min(4, t7 / 2))) / (1 + fatigue / 2);
const t5 = Math.max(0.45, t6 / 1.5);
const logBaseA = 1.25;
const t4 = t5 / logBaseA;
const t3 = t4 / logBaseA;
const t2 = t3 / logBaseA;
const t1 = t2 / logBaseA;
const t0 = t1 / logBaseA;
let ts = [tStart, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10];
let Ts = [TStart, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10];
// Create arrays of values inside run time
if (time == 0) {
time = t10;
} else if (time > t10) {
time = t10;
}
let T8f;
let T9f;
const Tbase8f =
runner.V2P(1.5) +
(1.5 * runner.P_i * (Math.min(runner.X * 2, 24) + Xdrift)) / (9 * Xdrift);
const Tbase9f = Tbase8f + 0.15 * runner.P_i;
const Tbase10f = Tbase9f + 0.1 * runner.P_i;
if (V > 1.5) {
T8f = Math.min(
runner.V2P(2) + (runner.P_i * 3) / runner.X,
runner.V2P(1.5) +
(readyness * 1.5 * runner.P_i * (t8 + Xdrift)) / (t10 + Xdrift)
);
T9f = Math.min(
runner.V2P(1.5) +
(readyness * 1.5 * runner.P_i * (t9 + Xdrift)) / (t10 + Xdrift),
runner.V2P(2.4)
);
} else {
T8f =
T6 +
((1.5 * runner.P_i * (Math.min(runner.X * 2, 24) + Xdrift)) /
(9 * Xdrift)) *
PR;
T9f = (T8f * Tbase9f) / Tbase8f;
}
const T10f = V > 1.5 ? T9f + runner.P_i * 0.1 : T9f;
const T7f = T6 + (T8f - T6) / 1.75;
let Tsf = [TStart, T0, T1, T2, T3, T4, T5, T6, T7f, T8f, T9f, T10f];
const endHR = everpolate.linear([time], ts, Ts)[0];
const endHRf = everpolate.linear([time], ts, Tsf)[0];
const sortingFun = function (a, b) {
return a - b;
};
const filterFunt = function (x) {
return x <= time;
};
const filterFunT = function (x) {
return x <= endHRf;
};
ts = [tStart, t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, time]
.sort(sortingFun)
.filter(filterFunt);
ts = ts.map((v) => v * 60);
Ts = [TStart, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, endHR]
.sort(sortingFun)
.filter(filterFunT);
// RECOVERY PARTaw
// All the R's
const RStart = endHR;
const R1 = Math.min(TStart + endHRf - T1, endHR);
const R2 = Math.min(TStart + endHRf - T2, endHR);
const R3 = Math.min(TStart + endHRf - T3, endHR);
const R4 = TStart + endHRf - T4;
const R5 = TStart + endHRf - T5;
const R6 = TStart + endHRf - T6;
const R7 = TStart + endHRf - T7;
const R8 = TStart + endHRf - T8;
const R9 = TStart + endHRf - T9;
const R10 = TStart + endHRf - T10;
// r's
const rStart = 0;
const logBaseR = 2;
const delay = 0.2;
const Vx = Math.max(Math.pow(16, 2 - V), 1);
const r6 = Math.max(3, Math.min(8, time / (3.75 * Vx) + delay));
const r4 = r6 / 3 + delay;
const r5 = r4 + (r6 - r4) * 0.4;
const r2 = Math.max(0.7, Math.sqrt(runner.E)) + delay;
const r3 = r2 + (r4 - r2) * 0.4;
const r1 = (r2 * (endHRf - R1)) / (endHRf - R2);
const r7 = 12 / runner.E + delay;
const r8 = r7 + (r7 - r6) * 1.25;
const r9 = (r8 + (R8 - R9) / ((R7 - R8) / (r8 - r7))) * 1.25;
const r10 = r9 * 1.5;
let rs = [rStart, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10];
let Rs = [RStart, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10];
const startTime = everpolate.linear([endHR - 0.01], Rs, rs)[0];
console.log(startTime);
const filterFunr = function (x) {
return x >= startTime + 0.01;
};
const filterFunR = function (x) {
return x <= endHR - 0.02;
};
rs = [rStart, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10]
.filter(filterFunr)
.map((v) => (v - startTime + time) * 60);
Rs = [RStart, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10].filter(filterFunR);
rs.unshift(time * 60);
Rs.unshift(endHR);
return {
tStart: tStart * 60,
t0: t0 * 60,
t1: t1 * 60,
t2: t2 * 60,
t3: t3 * 60,
t4: t4 * 60,
t5: t5 * 60,
t6: t6 * 60,
t7: t7 * 60,
t8: t8 * 60,
t9: t9 * 60,
t10: t10 * 60,
ts: ts,
TStart: TStart,
T0: T0,
T1: T1,
T2: T2,
T3: T3,
T4: T4,
T5: T5,
T6: T6,
T7: T7,
T8: T8,
T9: T9,
T10: T10,
Ts: Ts,
rStart: (rStart + time) * 60,
r1: (r1 + time) * 60,
r2: (r2 + time) * 60,
r3: (r3 + time) * 60,
r4: (r4 + time) * 60,
r5: (r5 + time) * 60,
r6: (r6 + time) * 60,
r7: (r7 + time) * 60,
r8: (r8 + time) * 60,
r9: (r9 + time) * 60,
r10: (r10 + time) * 60,
rs: rs,
RStart: RStart,
R1: R1,
R2: R2,
R3: R3,
R4: R4,
R5: R5,
R6: R6,
R7: R7,
R8: R8,
R9: R9,
R10: R10,
Rs: Rs
};
}