// Deterministic 120 Hz movement core, body pose solver, test worlds. Pure JS — no DOM, no three.js.
// Extracted verbatim from the published EDGERUNNERS build (index-1sq5vsxc.js),
// plus the patches documented in tools/core-patches.mjs: wallJumpGrace.
// Generated by tools/extract-core.mjs — do not edit by hand.
var DJ = 0.008333333333333333,
k = {
height: 1.78,
radius: 0.35,
eyeHeight: 1.62,
maxPitchDeg: 89,
runBaseSpeed: 5,
sprintMaxSpeed: 7.4,
sprintChargeTime: 1.8,
sprintChargeDecay: 0.45,
sprintChargeMinSpeed: 4,
strafeSpeed: 4.6,
backSpeed: 3.6,
groundAccelK: 9,
frictionK: 14,
stopEpsilon: 0.02,
gravityRise: 16,
gravityFall: 25.6,
terminalFall: 55,
jumpSpeed: 6.3,
airAccel: 8,
airSpeedCap: 7.4,
coyoteTime: 0.12,
jumpBufferTime: 0.12,
jumpCutFactor: 0.65,
jumpCutMinRise: 2,
jumpCutWindow: 0.3,
maxSubstepTravel: 0.15,
contactEpsilon: 0.0001,
slopeWalkMaxDeg: 46,
slopeUpTax: 0.45,
slopeUpFloor: 0.55,
slopeDownGain: 0.3,
slopeDownCap: 1.2,
slideSlopeG: 12.4,
fovBaseDeg: 72,
fovSprintKickDeg: 9,
fovKickStartSpeed: 3,
fovSmoothK: 6,
bobStepFreqBase: 1.35,
bobStepFreqPerMs: 0.21,
bobAmpVBase: 0.014,
bobAmpVPerMs: 0.0048,
bobAmpLFactor: 0.6,
bobRollDeg: 0.5,
bobFadeInK: 10,
bobFadeOutK: 6,
bobFadeAirK: 14,
moveMinSpeed: 0.3,
strafeRollDeg: 1.4,
turnRollFactor: 0.045,
turnRollMaxDeg: 2.2,
rollMaxDeg: 3,
rollSmoothK: 10,
dipOmega: 18,
dipZeta: 0.62,
dipImpulseScale: 0.5,
dipMaxImpulse: 4.8,
landMinImpact: 2.5,
leanMaxDeg: 8,
leanSmoothK: 4,
speedSmoothK: 12,
grabWindowLo: 1.2,
grabWindowHi: 2.35,
grabMaxRise: 3,
grabReach: 0.3,
grabFacingMaxDeg: 70,
grabMaxAway: 0.5,
hangDrop: 2.1,
hangGap: 0.02,
catchOmega: 16,
catchZeta: 1,
grabDipScale: 0.35,
shimmySpeed: 0.85,
shimmyK: 10,
shimmyEndMargin: 0.3,
shimmyStepLen: 0.55,
regripMinTime: 0.15,
climbUpTime: 0.55,
climbOverTime: 0.3,
climbHop: 0.08,
climbEndInset: 0.25,
climbExitSpeed: 1.2,
climbSettleImpulse: 1.2,
dropPush: 0.4,
dropRegrabCooldown: 0.3,
ledgeFadeInK: 10,
ledgeFadeOutK: 8,
handHalfSpan: 0.2,
handLift: 0.025,
handInset: -0.005,
vaultWindowLo: 0.35,
vaultWindowHi: 2.2,
vaultCrossMaxRel: 1.05,
vaultMaxDepth: 1.6,
vaultDetectDist: 2,
vaultMinSpeed: 2.5,
vaultFacingMaxDeg: 60,
vaultTravelMaxDeg: 50,
vaultHop: 0.12,
vaultMaxRiseSpeed: 13,
vaultRiseMinTime: 0.18,
vaultExitMargin: 0.15,
vaultOntoInset: 0.6,
vaultOntoLossPerM: 0.12,
vaultOntoMinRetention: 0.75,
vaultEdgeMargin: 0.12,
vaultPlantImpulse: 1,
vaultSettleImpulse: 1.1,
vaultRollDeg: 2.2,
vaultPlantSpan: 0.17,
vaultFadeInK: 10,
vaultFadeOutK: 9,
slideHeight: 0.95,
slideMinSpeed: 4,
slideEndSpeed: 4,
slideMinTime: 0.25,
slideMaxTime: 1.6,
slideFrictionK: 0.68,
slideAutoFrictionK: 0.7,
slideAutoTime: 0.38,
slideAutoImpact: 9.5,
slideAutoMinSpeed: 3.5,
slideAutoCamDrop: 0.34,
slideAutoCrouch: 0.4,
slideSteerRate: 1.1,
slideShuffleSpeed: 1.8,
slideShuffleK: 6,
slideCamDrop: 0.62,
slideCrouch: 0.5,
slideDipImpulse: 0.7,
slideFadeInK: 7,
slideFadeOutK: 7,
tuckFadeInK: 12,
tuckFadeOutK: 7,
pressDetectGap: 0.1,
pressFacingMaxDeg: 35,
pressMinFwd: 0.3,
pressMinTop: 1.75,
pressFaceMargin: 0.45,
pressHandRaise: 0.06,
pressHandOut: 0.1,
pressTouchGap: 0.012,
pressFingerCantDeg: 12,
pressFadeInK: 10,
pressFadeOutK: 8,
standMantleReach: 0.55,
standMantleLo: 0.75,
standUpBase: 0.3,
standUpPerM: 0.22,
standPlantImpulse: 0.8,
vaultCrouch: 0.75,
vaultCamDuck: 0.42,
vaultDiveDeg: 64,
wallRunMinSpeed: 4,
wallRunEndSpeed: 2.6,
wallRunMaxTime: 1.7,
wallRunFloatTime: 0.55,
wallRunGravLo: 5.5,
wallRunGravHi: 9,
wallRunMaxFall: 3.2,
wallRunDragK: 12,
wallRunHop: 1.8,
wallRunHopCap: 3,
wallAttachMaxVy: 3,
wallAttachMinVy: -9,
wallAttachReach: 0.25,
wallRideGap: 0.02,
wallAttachK: 22,
wallRunFrictionK: 0.12,
wallRunVelMaxDeg: 55,
wallRunFacingMaxDeg: 65,
wallRunMinTopAbove: 2.4,
wallRunKeepTopAbove: 1,
wallAttachImpulse: 0.9,
wallRunRollDeg: 7,
wallJumpVy: 6,
wallJumpMinAwayFrac: 0.3,
wallJumpSpeedFloor: 5.5,
wallJumpGrace: 0.15,
wallRegrabTime: 0.3,
wallFadeInK: 10,
wallFadeOutK: 7,
wallTouchInTime: 0.14,
wallTouchHold: 0.38,
wallTouchOutTime: 0.3,
wallTouchDrop: 0.17,
wallTouchLead: 0.52,
wallTouchGap: 0.015,
wallLegTiltDeg: 9,
wallLegTiltFarDeg: 19,
wallFootRollDeg: 24,
wallBodyRollDeg: 4,
boostDuration: 1.5,
boostCooldown: 5,
boostSpeedMult: 1.35,
boostAccelK: 14,
boostAirCapMult: 1.35,
boostMinIntentSpeed: 0.5,
boostFovKickDeg: 6,
boostLeanDeg: 3.5,
boostFadeInK: 9,
boostFadeOutK: 5,
landHardImpact: 13.5,
landHoldTime: 0.5,
landFrictionK: 12,
landCamDrop: 0.58,
landCrouch: 0.62,
landFovPunch: 5,
landSlowMo: 0.35,
landCamFwd: 0.56,
landPitchTargetDeg: 62,
landHandFwd: 0.55,
landHandSpan: 0.28,
landPrimeVy: -12.2,
landPrimeInK: 8,
landPrimeOutK: 10,
landFadeInK: 9,
landFadeOutK: 4,
inspectDelay: 1,
inspectPitchDeg: 40,
inspectMaxSpeed: 0.15,
inspectDist: 0.5,
inspectSpan: 0.16,
inspectDrop: 0.05,
inspectMinFwd: 0.3,
inspectFollow: 0.55,
inspectWobbleDeg: 8,
inspectNodDeg: 3.5,
inspectWobbleHz: 0.3,
inspectFadeInK: 2.4,
inspectFadeOutK: 11,
};
var L$ = () => ({ fwd: 0, strafe: 0, jump: !1, slide: !1, boost: !1, dyaw: 0, dpitch: 0 }),
nU = (J) => ({
fwd: J.fwd,
strafe: J.strafe,
jump: J.jump,
slide: J.slide,
boost: J.boost,
dyaw: J.dyaw,
dpitch: J.dpitch,
});
var N0 = (J = 0, $ = 0, Q = 0) => ({ x: J, y: $, z: Q });
var S6 = (J, $) => ({ x: J.x + $.x, y: J.y + $.y, z: J.z + $.z });
var m0 = (J, $, Q) => (J < $ ? $ : J > Q ? Q : J),
b0 = (J) => m0(J, 0, 1),
s = (J, $, Q) => J + ($ - J) * Q,
T0 = (J) => {
let $ = b0(J);
return $ * $ * (3 - 2 * $);
},
j = Math.PI / 180,
f8 = Math.PI * 2,
w8 = (J, $, Q, Z) => J + ($ - J) * (1 - Math.exp(-Q * Z)),
lJ = (J) => {
let $ = J % f8;
if ($ > Math.PI) $ -= f8;
if ($ <= -Math.PI) $ += f8;
return $;
},
$K = (J, $, Q) => {
let Z = lJ($ - J);
return lJ(J + Z * Q);
};
var QK = (J, $, Q, Z) => {
let K = Z * 0.5,
Y = Math.sin(K);
return { x: J * Y, y: $ * Y, z: Q * Y, w: Math.cos(K) };
},
i8 = (J) => QK(1, 0, 0, J),
IJ = (J) => QK(0, 1, 0, J),
cJ = (J) => QK(0, 0, 1, J),
R8 = (J, $) => ({
x: J.w * $.x + J.x * $.w + J.y * $.z - J.z * $.y,
y: J.w * $.y - J.x * $.z + J.y * $.w + J.z * $.x,
z: J.w * $.z + J.x * $.y - J.y * $.x + J.z * $.w,
w: J.w * $.w - J.x * $.x - J.y * $.y - J.z * $.z,
}),
iU = (J, $, Q) => {
let K = J.x * $.x + J.y * $.y + J.z * $.z + J.w * $.w < 0 ? -1 : 1,
Y = J.x + ($.x * K - J.x) * Q,
U = J.y + ($.y * K - J.y) * Q,
X = J.z + ($.z * K - J.z) * Q,
W = J.w + ($.w * K - J.w) * Q,
H = Math.sqrt(Y * Y + U * U + X * X + W * W) || 1;
return { x: Y / H, y: U / H, z: X / H, w: W / H };
},
Z6 = (J, $) => {
let { x: Q, y: Z, z: K, w: Y } = J,
U = Y * $.x + Z * $.z - K * $.y,
X = Y * $.y + K * $.x - Q * $.z,
W = Y * $.z + Q * $.y - Z * $.x,
H = -Q * $.x - Z * $.y - K * $.z;
return {
x: U * Y + H * -Q + X * -K - W * -Z,
y: X * Y + H * -Z + W * -Q - U * -K,
z: W * Y + H * -K + U * -Z - X * -Q,
};
},
o8 = (J) => ({ x: -Math.sin(J), y: 0, z: -Math.cos(J) }),
oU = (J) => ({ x: Math.cos(J), y: 0, z: -Math.sin(J) }),
C8 = (J) => Math.sqrt(J.x * J.x + J.z * J.z);
var H6 = k.height,
D8 = {
stature: H6,
upperArm: 0.186 * H6,
forearm: 0.146 * H6,
hand: 0.108 * H6,
thigh: 0.245 * H6,
shank: 0.246 * H6,
footLen: 0.152 * H6,
ankleH: 0.039 * H6,
pelvisH: 0.53 * H6,
shoulderH: 0.818 * H6,
shoulderHalfW: 0.115 * H6,
hipHalfW: 0.052 * H6,
headCenter: 0.936 * H6,
headR: 0.0655 * H6,
},
sF = 0.5,
ZK = 82 * j;
function B$(J, $, Q) {
let Z = J.x,
K = $.x,
Y = Q.x,
U = J.y,
X = $.y,
W = Q.y,
H = J.z,
q = $.z,
F = Q.z,
N = Z + X + F;
if (N > 0) {
let M = Math.sqrt(N + 1) * 2;
return { w: M / 4, x: (q - W) / M, y: (Y - H) / M, z: (U - K) / M };
}
if (Z > X && Z > F) {
let M = Math.sqrt(1 + Z - X - F) * 2;
return { w: (q - W) / M, x: M / 4, y: (K + U) / M, z: (Y + H) / M };
}
if (X > F) {
let M = Math.sqrt(1 + X - Z - F) * 2;
return { w: (Y - H) / M, x: (K + U) / M, y: M / 4, z: (W + q) / M };
}
let O = Math.sqrt(1 + F - Z - X) * 2;
return { w: (U - K) / O, x: (Y + H) / O, y: (W + q) / O, z: O / 4 };
}
var aF = (J) => {
let $ = Math.sin(f8 * (J - 0.55));
return $ > 0 ? Math.pow($, 1.4) : 0;
},
sU = (J) => J - Math.floor(J);
function aU(J, $) {
let Q = s(4, 12, $) * j,
Z = s(20, 32, $) * j,
K = s(18, 32, $) * j,
Y = s(55, 92, $) * j,
U = s(2, 17, $) * j,
X = s(10, 28, $) * j,
W = s(35, 71, $) * j,
H = s(5, 10, $) * j,
q = Math.sin(f8 * J),
F = Math.sin(f8 * J + Math.PI),
N = (F - 0.18 * F * F * F) / 0.82;
return {
hip: Q + Z * q,
knee: K + Y * aF(J),
ankle: (8 + 14 * Math.sin(f8 * (J - 0.6))) * j,
shoulder: U + X * N,
elbow: W + H * Math.sin(f8 * J + Math.PI + 0.3),
abduct: s(3, 8, $) * j,
reachIn: s(0, 4, $) * j * (0.5 + 0.5 * N),
wristSet: 4 * j * (0.5 + 0.5 * N),
};
}
function rU(J, $) {
let Q = Math.sin(f8 * 0.22 * $);
return {
hip: 2 * j * J,
knee: 5 * j,
ankle: 0,
shoulder: (26.5 + 1.1 * Q) * j,
elbow: (50 + 2 * Q) * j,
abduct: 11.5 * j,
};
}
function tU(J, $) {
let Q = J
? { hip: 62 * j, knee: 92 * j, ankle: 12 * j, shoulder: 30 * j, elbow: 64 * j, abduct: 14 * j }
: { hip: -20 * j, knee: 58 * j, ankle: 20 * j, shoulder: 55 * j, elbow: 34 * j, abduct: 22 * j },
Z = { hip: 22 * j, knee: 30 * j, ankle: 5 * j, shoulder: 18 * j, elbow: 62 * j, abduct: 10 * j };
return {
hip: s(Q.hip, Z.hip, $),
knee: s(Q.knee, Z.knee, $),
ankle: s(Q.ankle, Z.ankle, $),
shoulder: s(Q.shoulder, Z.shoulder, $),
elbow: s(Q.elbow, Z.elbow, $),
abduct: s(Q.abduct, Z.abduct, $),
};
}
var d8 = (J, $, Q) => ({
hip: s(J.hip, $.hip, Q),
knee: s(J.knee, $.knee, Q),
ankle: s(J.ankle, $.ankle, Q),
shoulder: s(J.shoulder, $.shoulder, Q),
elbow: s(J.elbow, $.elbow, Q),
abduct: s(J.abduct, $.abduct, Q),
footRoll: s(J.footRoll ?? 0, $.footRoll ?? 0, Q),
reachIn: s(J.reachIn ?? 0, $.reachIn ?? 0, Q),
pronate: s(J.pronate ?? ZK, $.pronate ?? ZK, Q),
wristSet: s(J.wristSet ?? 4 * j, $.wristSet ?? 4 * j, Q),
legTilt: s(J.legTilt ?? 0, $.legTilt ?? 0, Q),
});
function eU(J, $, Q, Z) {
let K = Math.sin(f8 * $ + (J === 1 ? 0 : Math.PI)),
Y = Math.sin(Math.PI * b0(Q / 0.85)),
U = J === 1 ? 1 : 0.55,
X = 1 - Z;
return {
hip: (18 + 3 * K) * j + 58 * j * Y * U,
knee: (15 + 4 * K) * j + 68 * j * Y * U,
ankle: 25 * j * (1 - Y),
shoulder: s(168, 32, X) * j,
elbow: s(12, 42, X) * j,
abduct: s(14, 8, X) * j,
};
}
function KK(J, $, Q) {
let Z = m0($, 0.05, 0.95),
K = T0((J - 0.02) / Math.max(Z - 0.02, 0.2)),
Y = T0((J - 0.62) / 0.5);
return K * (1 - Y);
}
function JX(J, $, Q, Z, K) {
if (Z === 2) {
let Y = J === 1 ? 1 : 0.88;
return {
hip: (34 + 96 * $ * Y) * j,
knee: (62 + 84 * $ * Y) * j,
ankle: 14 * j * (1 - $),
shoulder: s(62 + 8 * $, 24, Q) * j,
elbow: s(16 + 6 * $, 60, Q) * j,
abduct: 10 * j,
};
}
if (J === -1)
return {
hip: (30 + 112 * $) * j,
knee: (60 + 92 * $) * j,
ankle: 12 * j * (1 - $),
shoulder: s(58 + 14 * $, -18, Q) * j,
elbow: s(14 + 8 * $, 32, Q) * j,
abduct: 16 * j,
};
if (K === 2)
return {
hip: (30 + 115 * $) * j,
knee: (58 + 97 * $) * j,
ankle: 10 * j * (1 - $),
shoulder: s(58 + 14 * $, -18, Q) * j,
elbow: s(14 + 8 * $, 32, Q) * j,
abduct: 14 * j,
};
return {
hip: (30 + 115 * $) * j,
knee: (58 + 97 * $) * j,
ankle: 10 * j * (1 - $),
shoulder: (26 + 38 * $) * j,
elbow: (52 + 18 * $) * j,
abduct: 20 * j,
};
}
function $X(J, $) {
let Q = J === 1 ? 1 : 0.93;
return {
hip: (62 + 10 * $) * j * Q,
knee: (24 - 8 * $) * j,
ankle: -12 * j,
shoulder: (38 - 12 * $) * j,
elbow: (24 + 6 * $) * j,
abduct: 13 * j,
};
}
function QX(J) {
return J === 1
? { hip: 132 * j, knee: 130 * j, ankle: 34 * j, shoulder: 32 * j, elbow: 74 * j, abduct: 14 * j }
: { hip: 124 * j, knee: 128 * j, ankle: 30 * j, shoulder: 44 * j, elbow: 60 * j, abduct: 18 * j };
}
function ZX(J, $, Q) {
if (Q === 2) {
let Z = J === 1 ? 1 : 0.86;
return {
hip: s(44, 56 * Z, $) * j,
knee: s(92, 104 * Z, $) * j,
ankle: 16 * j,
shoulder: s(24, 28, $) * j,
elbow: s(54, 52, $) * j,
abduct: (J === 1 ? 14 : 16) * j,
};
}
if (J === 1)
return {
hip: s(44, 58, $) * j,
knee: s(92, 16, $) * j,
ankle: 24 * j,
shoulder: s(26, 24, $) * j,
elbow: s(56, 34, $) * j,
abduct: 22 * j,
footRoll: 20 * j,
pronate: 30 * j,
};
return {
hip: s(34, 22, $) * j,
knee: s(96, 116, $) * j,
ankle: 26 * j,
shoulder: s(16, -34, $) * j,
elbow: s(52, 28, $) * j,
abduct: 16 * j,
footRoll: 10 * j,
pronate: 55 * j,
};
}
function C$(J) {
let $ = b0((J.speedSmooth - 1) / (k.sprintMaxSpeed - 1)),
Q = J.bobFade,
Z = J.airFade,
K = b0(-J.dip / 0.15),
Y = J.prepFade,
U = b0(J.ledgeFade),
X = T0((J.climbPhase - 0.5) / 0.45),
W = T0(b0(J.pinFade)) * (1 - X),
H = b0(J.vaultFade),
q = m0(J.vaultPlantPhase, 0.05, 0.95),
F = T0((J.vaultPhase - (q - 0.34)) / 0.32),
N = J.vaultKind === 2 ? T0((J.vaultPhase - 0.58) / 0.32) : T0((J.vaultPhase - q - 0.05) / 0.3),
O = J.vaultKind === 2 ? T0((J.vaultPhase - 0.58) / 0.3) : T0((J.vaultPhase - q - 0.08) / 0.3),
M = F * (1 - N),
V = KK(b0(J.vaultPhase), q, J.vaultKind) * T0(H),
G = k.vaultCrouch * V,
R = (J.slideKind === 2 ? k.slideAutoCrouch : k.slideCrouch) * T0(b0(J.slideFade)),
B = T0(b0(J.tuckFade)),
I = k.slideCrouch * B,
L = T0(b0(J.landFade)),
w = k.landCrouch * L,
z = sU(J.stridePhase),
S = sU(J.stridePhase + 0.5),
E = d8(rU(1, J.time), aU(z, $), Q),
_ = d8(rU(-1, J.time), aU(S, $), Q);
((E = d8(E, tU(!0, Y), Z)), (_ = d8(_, tU(!1, Y), Z)));
let c = Z * T0(b0(J.boostFade));
if (c > 0.0001) ((E = d8(E, $X(1, Y), c)), (_ = d8(_, $X(-1, Y), c)));
if (H > 0.0001) {
let y = T0(H);
((E = d8(E, JX(1, V, O, J.vaultKind, J.vaultHands), y)), (_ = d8(_, JX(-1, V, O, J.vaultKind, J.vaultHands), y)));
}
if (B > 0.0001) ((E = d8(E, QX(1), B)), (_ = d8(_, QX(-1), B)));
let A = T0(b0(J.slideFade));
if (A > 0.0001) ((E = d8(E, ZX(1, A, J.slideKind), A)), (_ = d8(_, ZX(-1, A, J.slideKind), A)));
if (U > 0.0001)
((E = d8(E, eU(1, J.shimmyPhase, J.climbPhase, W), U)), (_ = d8(_, eU(-1, J.shimmyPhase, J.climbPhase, W), U)));
let v = T0(b0(J.wallFade)),
u = J.wallSide >= 0 ? 1 : -1,
f = T0(J.wallT / k.wallTouchInTime) * (1 - T0((J.wallT - k.wallTouchHold) / k.wallTouchOutTime)) * v;
if (v > 0.0001) {
let y = u * k.wallLegTiltDeg * j * v,
h = u * k.wallLegTiltFarDeg * j * v,
d = u === 1;
((E.legTilt = (E.legTilt ?? 0) + (d ? h : y)), (_.legTilt = (_.legTilt ?? 0) + (d ? y : h)));
let Q0 = u * k.wallFootRollDeg * j * v;
((E.footRoll = (E.footRoll ?? 0) + Q0), (_.footRoll = (_.footRoll ?? 0) + Q0));
let e = d ? _ : E;
((e.shoulder = s(e.shoulder, 30 * j, 0.7 * f)),
(e.elbow = s(e.elbow, 24 * j, 0.7 * f)),
(e.abduct = s(e.abduct, 34 * j, 0.8 * f)));
}
let n = T0(b0(J.pressFade));
if (n > 0.0001)
for (let y of [E, _])
((y.shoulder = s(y.shoulder, 55 * j, 0.8 * n)),
(y.elbow = s(y.elbow, 26 * j, 0.8 * n)),
(y.abduct = s(y.abduct, 13 * j, 0.8 * n)));
let p = T0(b0(J.inspectFade));
if (p > 0.0001)
for (let y of [E, _])
((y.shoulder = s(y.shoulder, 62 * j, 0.85 * p)),
(y.elbow = s(y.elbow, 92 * j, 0.85 * p)),
(y.abduct = s(y.abduct, 9 * j, 0.8 * p)));
let l = T0(b0(J.landFade)),
Y0 = T0(b0(J.landPrime)) * (1 - l);
if (Y0 > 0.0001)
((E = d8(E, { hip: 30 * j, knee: 36 * j, ankle: 6 * j, shoulder: 92 * j, elbow: 8 * j, abduct: 17 * j }, Y0)),
(_ = d8(_, { hip: 26 * j, knee: 32 * j, ankle: 6 * j, shoulder: 88 * j, elbow: 10 * j, abduct: 19 * j }, Y0)));
if (l > 0.0001)
((E = d8(E, { hip: 102 * j, knee: 124 * j, ankle: -6 * j, shoulder: 92 * j, elbow: 18 * j, abduct: 13 * j }, l)),
(_ = d8(_, { hip: 94 * j, knee: 116 * j, ankle: -4 * j, shoulder: 88 * j, elbow: 22 * j, abduct: 15 * j }, l)));
let q0 = 22 * j * K,
V0 = 28 * j * K,
w0 = 16 * j * K,
L0 = 12 * j * K;
((E.hip += q0),
(_.hip += q0),
(E.knee += V0),
(_.knee += V0),
(E.shoulder += w0 * 0.72),
(_.shoulder += w0 * 1.28),
(E.elbow += L0 * 1.2),
(_.elbow += L0 * 0.8),
(E.abduct += 5 * j * K),
(_.abduct += 5 * j * K));
let l0 = Math.max(J.pitch, -0.52) * 0.1;
((E.shoulder += l0), (_.shoulder += l0));
let p0 = Math.max(0, -J.pitch);
((E.hip += p0 * 0.15), (_.hip += p0 * 0.15), (E.knee += p0 * 0.1), (_.knee += p0 * 0.1));
let $0 = s(0.02, 0.045, $) * Q * (1 - Z),
M0 = -$0 / 2 + ($0 / 2) * Math.sin(f8 * 2 * J.stridePhase + 0.6),
_0 = D8.pelvisH + M0 + J.dip * 1.15 + Z * 0.04 - G - R - I - w,
E0 = Math.sin(f8 * J.stridePhase) * Q * (1 - Z),
y0 = (J.slideKind === 2 ? 7 : -17) * j * T0(b0(J.slideFade)),
Y8 = 24 * j * B,
c0 = J.lean + K * 6 * j + 14 * j * W + k.vaultDiveDeg * j * V + y0 + Y8 + 56 * j * T0(L),
t0 = J.roll * 0.6 - u * k.wallBodyRollDeg * j * v,
N8 = -5 * j * E0 * $,
Z8 = R8(IJ(J.yaw + N8), R8(i8(-c0), cJ(-t0))),
n0 = 0.12,
W8 = o8(J.yaw),
x8 = Math.max(U, M, L),
A8 = c0 * 0.25 * (1 - x8) + s(n0, 0.06, x8),
b = N0(
J.pos.x - W8.x * A8 + Z6(Z8, N0(0.016 * E0, 0, 0)).x,
J.pos.y + _0,
J.pos.z - W8.z * A8 + Z6(Z8, N0(0.016 * E0, 0, 0)).z,
),
l8 = D8.shoulderH - D8.pelvisH,
J8 = 12 * j * E0 * $,
k0 =
Math.max(0, -J.pitch) * 0.18 +
s(2, 4, $) * j * Q +
1.2 * j * Math.sin(f8 * 0.22 * J.time) * (1 - Q) +
8 * j * W +
8 * j * M,
q8 = R8(Z8, R8(IJ(J8), i8(-k0))),
v0 = S6(b, Z6(Z8, N0(0, l8, 0))),
P = S6(v0, Z6(q8, N0(0, D8.headCenter - D8.shoulderH, 0.02))),
D = {};
((D.pelvis = { pos: b, quat: Z8 }), (D.chest = { pos: v0, quat: q8 }), (D.head = { pos: P, quat: q8 }));
let m = 0.12 * W,
K0 = (y, h, d) => {
let Q0 = y === 1 ? -1 : 1,
e = S6(v0, Z6(q8, N0(Q0 * D8.shoulderHalfW, m, 0))),
U0 = R8(q8, R8(cJ(Q0 * h.abduct), R8(IJ(Q0 * (h.reachIn ?? 0)), i8(h.shoulder)))),
C0 = S6(e, Z6(U0, N0(0, -D8.upperArm, 0))),
F0 = R8(U0, i8(h.elbow)),
O0 = S6(C0, Z6(F0, N0(0, -D8.forearm, 0))),
T = R8(F0, R8(i8(h.wristSet ?? 4 * j), IJ(-Q0 * (h.pronate ?? ZK)))),
Z0 = S6(O0, Z6(T, N0(0, -D8.hand * sF, 0)));
((D[`shoulder${d}`] = { pos: e, quat: U0 }),
(D[`elbow${d}`] = { pos: C0, quat: F0 }),
(D[`wrist${d}`] = { pos: O0, quat: T }),
(D[`hand${d}`] = { pos: Z0, quat: T }));
},
X0 = (y, h, d) => {
let Q0 = y === 1 ? -1 : 1,
e = S6(b, Z6(Z8, N0(Q0 * D8.hipHalfW, 0, 0))),
U0 = h.legTilt ?? 0,
C0 = R8(Z8, U0 !== 0 ? R8(cJ(U0), R8(i8(h.hip), cJ(Q0 * 2 * j))) : R8(i8(h.hip), cJ(Q0 * 2 * j))),
F0 = S6(e, Z6(C0, N0(0, -D8.thigh, 0))),
O0 = R8(C0, i8(-h.knee)),
T = S6(F0, Z6(O0, N0(0, -D8.shank, 0))),
Z0 = -(h.hip - h.knee) * 0.6 + h.ankle,
r = h.footRoll ?? 0,
J0 = r ? R8(R8(O0, i8(Z0)), cJ(-r)) : R8(O0, i8(Z0)),
H0 = S6(T, Z6(J0, N0(0, -D8.ankleH * 0.5, -D8.footLen * 0.32)));
((D[`hip${d}`] = { pos: e, quat: C0 }),
(D[`knee${d}`] = { pos: F0, quat: O0 }),
(D[`ankle${d}`] = { pos: T, quat: J0 }),
(D[`foot${d}`] = { pos: H0, quat: J0 }));
};
(K0(1, E, "L"), K0(-1, _, "R"), X0(1, E, "L"), X0(-1, _, "R"));
let W0 = (y, h, d, Q0, e, U0) => {
let C0 = D8.upperArm + D8.forearm - 0.004,
F0 = D[`shoulder${y}`].pos,
O0 = d.x - F0.x,
T = d.y - F0.y,
Z0 = d.z - F0.z,
r = Math.sqrt(O0 * O0 + T * T + Z0 * Z0) || 0.000000001,
J0 = Math.min(r, C0);
((O0 /= r), (T /= r), (Z0 /= r));
let H0 = m0((D8.upperArm * D8.upperArm + J0 * J0 - D8.forearm * D8.forearm) / (2 * J0), 0, D8.upperArm),
t = Math.sqrt(Math.max(0, D8.upperArm * D8.upperArm - H0 * H0)),
G0 = e.x,
P0 = e.y,
o0 = e.z,
u0 = G0 * O0 + P0 * T + o0 * Z0;
((G0 -= u0 * O0), (P0 -= u0 * T), (o0 -= u0 * Z0));
let L8 = Math.sqrt(G0 * G0 + P0 * P0 + o0 * o0) || 1,
G8 = N0(F0.x + O0 * H0 + (G0 / L8) * t, F0.y + T * H0 + (P0 / L8) * t, F0.z + Z0 * H0 + (o0 / L8) * t),
O6 = N0(F0.x + O0 * J0, F0.y + T * J0, F0.z + Z0 * J0),
KJ = N0(O6.x + (h.x - d.x), O6.y + (h.y - d.y), O6.z + (h.z - d.z)),
M6 = ($6, N6, m6) => {
let R6 = D[$6];
if (((R6.pos = N0(s(R6.pos.x, N6.x, U0), s(R6.pos.y, N6.y, U0), s(R6.pos.z, N6.z, U0))), m6))
R6.quat = iU(R6.quat, m6, U0);
};
(M6(`elbow${y}`, G8), M6(`wrist${y}`, O6, Q0), M6(`hand${y}`, KJ, Q0));
};
if (M > 0.0001) {
let y = Math.hypot(J.plantNx, J.plantNz),
h = y > 0.000001 ? J.plantNx / y : 0,
d = y > 0.000001 ? J.plantNz / y : 1,
Q0 = d,
e = -h,
U0 = Math.atan2(h, d),
C0 = R8(IJ(U0), i8(85 * j));
if (J.vaultHands === 2)
for (let F0 of [1, -1]) {
let O0 = F0 === 1 ? -1 : 1,
T = N0(J.plantX + Q0 * O0 * k.handHalfSpan, J.plantY, J.plantZ + e * O0 * k.handHalfSpan),
Z0 = N0(T.x + h * 0.05, T.y - 0.035, T.z + d * 0.05);
W0(F0 === 1 ? "L" : "R", T, Z0, C0, N0(Q0 * O0 + h * 0.3, -0.2, e * O0 + d * 0.3), M);
}
else {
let F0 = N0(J.plantX, J.plantY, J.plantZ),
O0 = N0(F0.x + h * 0.05, F0.y - 0.035, F0.z + d * 0.05);
W0("R", F0, O0, C0, N0(Q0 + h * 0.25, -0.3, e + d * 0.25), M);
}
}
if (W > 0.0001) {
let y = Math.hypot(J.ledgeNx, J.ledgeNz),
h = y > 0.000001 ? J.ledgeNx / y : 0,
d = y > 0.000001 ? J.ledgeNz / y : 1,
Q0 = d,
e = -h,
U0 = Math.atan2(h, d),
C0 = R8(IJ(U0), i8(70 * j));
for (let F0 of [1, -1]) {
let O0 = F0 === 1 ? "L" : "R",
T = F0 === 1 ? -1 : 1,
Z0 = 0.07 * Math.sin(f8 * J.shimmyPhase + (F0 === 1 ? 0 : Math.PI)),
r = T * k.handHalfSpan + Z0,
J0 = N0(J.grabX + Q0 * r - h * k.handInset, J.grabY + k.handLift, J.grabZ + e * r - d * k.handInset),
H0 = N0(J0.x + h * 0.015, J0.y - 0.05, J0.z + d * 0.015);
W0(O0, J0, H0, C0, N0(Q0 * T * 0.45 + h * 0.7, -0.25, e * T * 0.45 + d * 0.7), W);
}
}
if (f > 0.0001) {
let y = Math.hypot(J.wallNx, J.wallNz);
if (y > 0.000001 && Math.abs(J.wallNx + J.wallNz) > 0.5) {
let h = J.wallNx / y,
d = J.wallNz / y,
Q0 = J.wallPlane * (h + d),
e = -u * d,
U0 = u * h,
C0 = u === 1 ? "R" : "L",
F0 = D[`shoulder${C0}`].pos,
O0 = F0.x * h + F0.z * d - Q0 - k.wallTouchGap,
T = N0(F0.x - h * O0 + e * k.wallTouchLead, F0.y - k.wallTouchDrop, F0.z - d * O0 + U0 * k.wallTouchLead),
Z0 = Math.cos(38 * j),
r = Math.sin(38 * j),
J0 = e * Z0,
H0 = r,
t = U0 * Z0,
G0 = N0(-h, 0, -d),
P0 = N0(-J0, -H0, -t),
o0 = N0(P0.y * G0.z - P0.z * G0.y, P0.z * G0.x - P0.x * G0.z, P0.x * G0.y - P0.y * G0.x),
u0 = R8(B$(o0, P0, G0), i8(-6 * j)),
L8 = N0(T.x - J0 * 0.096 + h * 0.03, T.y - H0 * 0.096 + 0, T.z - t * 0.096 + d * 0.03);
W0(C0, T, L8, u0, N0(-e * 0.35 + h * 0.25, -0.9, -U0 * 0.35 + d * 0.25), f);
}
}
if (n > 0.0001) {
let y = Math.hypot(J.pressNx, J.pressNz);
if (y > 0.000001 && Math.abs(J.pressNx + J.pressNz) > 0.5) {
let h = J.pressNx / y,
d = J.pressNz / y,
Q0 = J.pressPlane * (h + d),
e = d,
U0 = -h,
C0 = Math.cos(k.pressFingerCantDeg * j),
F0 = Math.sin(k.pressFingerCantDeg * j);
for (let O0 of [1, -1]) {
let T = O0 === 1 ? "L" : "R",
Z0 = O0 === 1 ? -1 : 1,
r = D[`shoulder${T}`].pos,
J0 = r.x * h + r.z * d - Q0 - k.pressTouchGap,
H0 = N0(
r.x - h * J0 + e * Z0 * k.pressHandOut,
r.y + k.pressHandRaise,
r.z - d * J0 + U0 * Z0 * k.pressHandOut,
),
t = e * Z0 * F0,
G0 = C0,
P0 = U0 * Z0 * F0,
o0 = N0(-h, 0, -d),
u0 = N0(-t, -G0, -P0),
L8 = N0(u0.y * o0.z - u0.z * o0.y, u0.z * o0.x - u0.x * o0.z, u0.x * o0.y - u0.y * o0.x),
G8 = R8(B$(L8, u0, o0), i8(-4 * j)),
O6 = N0(H0.x - t * 0.096 + h * 0.02, H0.y - G0 * 0.096, H0.z - P0 * 0.096 + d * 0.02);
W0(T, H0, O6, G8, N0(e * Z0 * 0.5 + h * 0.3, -0.8, U0 * Z0 * 0.5 + d * 0.3), n);
}
}
}
if (p > 0.0001) {
let y = Math.cos(J.pitch),
h = Math.sin(J.pitch),
d = N0(W8.x * y, h, W8.z * y),
Q0 = N0(-W8.x * h, y, -W8.z * h),
e = N0(-W8.z, 0, W8.x),
U0 = N0(J.pos.x, J.pos.y + k.eyeHeight + J.dip, J.pos.z);
for (let C0 of [1, -1]) {
let F0 = C0 === 1 ? "L" : "R",
O0 = C0 === 1 ? -1 : 1,
T = f8 * k.inspectWobbleHz * J.time + (C0 === 1 ? 0 : 1.1),
Z0 = O0 * 6 * j + k.inspectWobbleDeg * j * Math.sin(T),
r = k.inspectNodDeg * j * Math.sin(0.5 * T + 0.7),
J0 = N0(
U0.x + d.x * k.inspectDist + e.x * O0 * k.inspectSpan - Q0.x * k.inspectDrop,
U0.y + d.y * k.inspectDist + e.y * O0 * k.inspectSpan - Q0.y * k.inspectDrop,
U0.z + d.z * k.inspectDist + e.z * O0 * k.inspectSpan - Q0.z * k.inspectDrop,
),
H0 = (J0.x - J.pos.x) * W8.x + (J0.z - J.pos.z) * W8.z;
if (H0 < k.inspectMinFwd) ((J0.x += W8.x * (k.inspectMinFwd - H0)), (J0.z += W8.z * (k.inspectMinFwd - H0)));
let t = N0(-d.x, -d.y, -d.z),
G0 = N0(-Q0.x, -Q0.y, -Q0.z),
P0 = N0(G0.y * t.z - G0.z * t.y, G0.z * t.x - G0.x * t.z, G0.x * t.y - G0.y * t.x),
o0 = R8(B$(P0, G0, t), R8(IJ(Z0), i8(r))),
u0 = N0(
J0.x - Q0.x * 0.096 + d.x * 0.012,
J0.y - Q0.y * 0.096 + d.y * 0.012,
J0.z - Q0.z * 0.096 + d.z * 0.012,
);
W0(F0, J0, u0, o0, N0(e.x * O0 * 0.35 + d.x * 0.15, -0.9, e.z * O0 * 0.35 + d.z * 0.15), p);
let L8 = D[`elbow${F0}`].pos,
G8 = D[`wrist${F0}`].pos,
O6 = Math.hypot(G8.x - L8.x, G8.y - L8.y, G8.z - L8.z) || 0.000000001,
KJ = k.inspectFollow,
M6 = Q0.x + ((G8.x - L8.x) / O6 - Q0.x) * KJ,
$6 = Q0.y + ((G8.y - L8.y) / O6 - Q0.y) * KJ,
N6 = Q0.z + ((G8.z - L8.z) / O6 - Q0.z) * KJ,
m6 = Math.hypot(M6, $6, N6) || 0.000000001;
((M6 /= m6), ($6 /= m6), (N6 /= m6));
let R6 = Q0.y * N6 - Q0.z * $6,
CJ = Q0.z * M6 - Q0.x * N6,
S9 = Q0.x * $6 - Q0.y * M6,
YJ = Math.hypot(R6, CJ, S9);
if (YJ > 0.000001) {
let T9 = Math.atan2(YJ, Q0.x * M6 + Q0.y * $6 + Q0.z * N6) * p,
rJ = Math.sin(T9 / 2) / YJ,
j9 = { w: Math.cos(T9 / 2), x: R6 * rJ, y: CJ * rJ, z: S9 * rJ },
UJ = D[`hand${F0}`],
E7 = D[`wrist${F0}`];
((UJ.quat = R8(j9, UJ.quat)), (E7.quat = R8(j9, E7.quat)));
let y9 = Z6(j9, N0(UJ.pos.x - G8.x, UJ.pos.y - G8.y, UJ.pos.z - G8.z));
UJ.pos = N0(G8.x + y9.x, G8.y + y9.y, G8.z + y9.z);
}
}
}
if (l > 0.0001) {
let y = Math.hypot(J.landDirX, J.landDirZ),
h = y > 0.000001 ? J.landDirX / y : 0,
d = y > 0.000001 ? J.landDirZ / y : 1,
Q0 = -d,
e = h;
for (let U0 of [1, -1]) {
let C0 = U0 === 1 ? "L" : "R",
F0 = U0 === 1 ? -1 : 1,
O0 = N0(J.landPlantX + Q0 * F0 * k.landHandSpan, J.landPlantY + 0.012, J.landPlantZ + e * F0 * k.landHandSpan),
T = Math.cos(14 * j),
Z0 = Math.sin(14 * j),
r = h * T + Q0 * F0 * Z0,
J0 = d * T + e * F0 * Z0,
H0 = N0(0, -1, 0),
t = N0(-r, 0, -J0),
G0 = N0(t.y * H0.z - t.z * H0.y, t.z * H0.x - t.x * H0.z, t.x * H0.y - t.y * H0.x),
P0 = R8(B$(G0, t, H0), i8(-6 * j)),
o0 = N0(O0.x - r * 0.09, O0.y + 0.035, O0.z - J0 * 0.09);
W0(C0, O0, o0, P0, N0(Q0 * F0 * 0.5 - h * 0.2, 0.85, e * F0 * 0.5 - d * 0.2), l);
}
}
let R0 = (y, h, d, Q0, e) => {
let U0 = D[`hand${y}`],
C0 = U0.pos.x * h + U0.pos.z * d - Q0,
F0 = 0.09,
O0 = 0.015,
T = 0.012,
Z0 = C0 - 0.012,
r = Math.sin(18 * j),
J0 = Math.cos(18 * j);
for (let t of [N0(0, -1, 0), N0(-r, -J0, 0), N0(r, -J0, 0)]) {
let G0 = Z6(U0.quat, t),
P0 = C0 + (G0.x * h + G0.z * d) * 0.09;
if (P0 - 0.015 < Z0) Z0 = P0 - 0.015;
}
let H0 = -Math.min(0, Z0) * e;
if (H0 > 0.000001) {
let t = D[`wrist${y}`],
G0 = D[`elbow${y}`];
((U0.pos = N0(U0.pos.x + h * H0, U0.pos.y, U0.pos.z + d * H0)),
(t.pos = N0(t.pos.x + h * H0, t.pos.y, t.pos.z + d * H0)),
(G0.pos = N0(G0.pos.x + h * H0 * 0.5, G0.pos.y, G0.pos.z + d * H0 * 0.5)));
}
};
if (v > 0.0001) {
let y = Math.hypot(J.wallNx, J.wallNz);
if (y > 0.000001 && Math.abs(J.wallNx + J.wallNz) > 0.5) {
let h = J.wallNx / y,
d = J.wallNz / y;
R0(u === 1 ? "R" : "L", h, d, J.wallPlane * (h + d), v);
}
}
if (n > 0.0001) {
let y = Math.hypot(J.pressNx, J.pressNz);
if (y > 0.000001 && Math.abs(J.pressNx + J.pressNz) > 0.5) {
let h = J.pressNx / y,
d = J.pressNz / y;
(R0("L", h, d, J.pressPlane * (h + d), n), R0("R", h, d, J.pressPlane * (h + d), n));
}
}
return D;
}
function KX(J) {
let $ = b0((J.speedSmooth - 1) / (k.sprintMaxSpeed - 1)),
Q = J.bobFade,
Z = J.airFade,
K = b0(-J.dip / 0.15),
Y = $ * Q,
U = s(0.24 + 0.02 * Math.sin(f8 * 0.22 * J.time) * (1 - Q), 0.68, Y);
((U = s(U, 0.18, Z)), (U -= 0.1 * K));
let X = U,
W = U,
H = s(0.35, 0.12, Y * (1 - Z)),
q = H,
F = T0(b0(J.slideFade));
if (F > 0.0001 && J.slideKind !== 2) ((X = s(X, 0.05, F)), (H = s(H, 0.65, F)));
let N = T0((J.climbPhase - 0.5) / 0.45),
O = T0(b0(J.pinFade)) * (1 - N);
if (O > 0.0001) ((X = s(X, 1, O)), (W = s(W, 1, O)), (H = s(H, 0.12, O)), (q = s(q, 0.12, O)));
let M = m0(J.vaultPlantPhase, 0.05, 0.95),
V = T0((J.vaultPhase - (M - 0.34)) / 0.32),
G = J.vaultKind === 2 ? T0((J.vaultPhase - 0.58) / 0.32) : T0((J.vaultPhase - M - 0.05) / 0.3),
R = V * (1 - G) * (b0(J.vaultFade) > 0.0001 ? 1 : 0);
if (R > 0.0001) {
if (((W = s(W, -0.78, R)), (q = s(q, 0.7, R)), J.vaultHands === 2)) ((X = s(X, -0.78, R)), (H = s(H, 0.7, R)));
}
let B =
T0(J.wallT / k.wallTouchInTime) * (1 - T0((J.wallT - k.wallTouchHold) / k.wallTouchOutTime)) * T0(b0(J.wallFade));
if (B > 0.0001)
if (J.wallSide >= 0) ((W = s(W, -0.85, B)), (q = s(q, 0.9, B)));
else ((X = s(X, -0.85, B)), (H = s(H, 0.9, B)));
let I = T0(b0(J.pressFade));
if (I > 0.0001) ((X = s(X, -0.85, I)), (W = s(W, -0.85, I)), (H = s(H, 0.95, I)), (q = s(q, 0.95, I)));
let L = T0(b0(J.landFade)),
w = T0(b0(J.landPrime)) * (1 - L);
if (w > 0.0001) ((X = s(X, -0.5, w)), (W = s(W, -0.5, w)), (H = s(H, 0.7, w)), (q = s(q, 0.7, w)));
if (L > 0.0001) ((X = s(X, -0.8, L)), (W = s(W, -0.8, L)), (H = s(H, 0.85, L)), (q = s(q, 0.85, L)));
let z = T0(b0(J.inspectFade));
if (z > 0.0001) ((X = s(X, -0.7, z)), (W = s(W, -0.7, z)), (H = s(H, 0.6, z)), (q = s(q, 0.6, z)));
return { curlL: X, curlR: W, spreadL: H, spreadR: q };
}
function _$(J) {
let $ = J.vaultTEnd > 0 ? J.vaultT1 / J.vaultTEnd : 0.5;
return k.vaultCamDuck * KK(b0(J.vaultPhase), $, J.vaultKind) * T0(b0(J.vaultFade));
}
function A$(J) {
return (J.slideKind === 2 ? k.slideAutoCamDrop : k.slideCamDrop) * T0(b0(J.slideFade));
}
function P$(J) {
return k.slideCamDrop * T0(b0(J.tuckFade));
}
function z$(J) {
return k.landCamDrop * T0(b0(J.landFade));
}
function w$(J) {
let $ = T0(b0(J.landFade)),
Q = -k.landPitchTargetDeg * (Math.PI / 180);
return J.pitch + (Math.min(J.pitch, Q) - J.pitch) * $;
}
function YK(J) {
return k.landCamFwd * T0(b0(J.landFade));
}
function UK(J) {
return 1 - (1 - k.landSlowMo) * T0(b0(J.landFade));
}
function XK(J) {
return {
eyeY: J.pos.y + k.eyeHeight + J.bobY + J.dip - _$(J) - A$(J) - P$(J) - z$(J),
bobX: J.bobX,
yaw: J.yaw,
pitch: w$(J),
roll: J.roll + J.bobRoll,
fov: J.fov,
};
}
function JJ(J) {
let $ = J.max.y - J.min.y,
Q = J.dir === "+x" || J.dir === "-x" ? J.max.x - J.min.x : J.max.z - J.min.z,
Z = J.dir === "+x" ? 1 : J.dir === "-x" ? -1 : 0,
K = J.dir === "+z" ? 1 : J.dir === "-z" ? -1 : 0;
return { ux: Z, uz: K, run: Q, rise: $, tan: $ / Q };
}
function x6(J, $, Q) {
let Z;
switch (J.dir) {
case "+x":
Z = ($ - J.min.x) / (J.max.x - J.min.x);
break;
case "-x":
Z = (J.max.x - $) / (J.max.x - J.min.x);
break;
case "+z":
Z = (Q - J.min.z) / (J.max.z - J.min.z);
break;
case "-z":
Z = (J.max.z - Q) / (J.max.z - J.min.z);
break;
}
return J.min.y + b0(Z) * (J.max.y - J.min.y);
}
var q7 = Math.tan(k.slopeWalkMaxDeg * j),
$J = (J) => JJ(J).tan <= q7 + 0.000000000001;
function C9(J, $, Q, Z, K, Y, U = "white") {
let X = $ / Math.tan(J * j);
switch (Y) {
case "-z":
return { min: N0(Z - K / 2, 0, Q - X), max: N0(Z + K / 2, $, Q), dir: Y, color: U };
case "+z":
return { min: N0(Z - K / 2, 0, Q), max: N0(Z + K / 2, $, Q + X), dir: Y, color: U };
case "-x":
return { min: N0(Q - X, 0, Z - K / 2), max: N0(Q, $, Z + K / 2), dir: Y, color: U };
case "+x":
return { min: N0(Q, 0, Z - K / 2), max: N0(Q + X, $, Z + K / 2), dir: Y, color: U };
}
}
var h0 = (J, $, Q, Z, K, Y = "white") => ({
min: N0(J - Q / 2, 0, $ - K / 2),
max: N0(J + Q / 2, Z, $ + K / 2),
color: Y,
}),
YX = (J, $, Q, Z, K, Y, U = "white") => ({
min: N0(J - Z / 2, $, Q - Y / 2),
max: N0(J + Z / 2, $ + K, Q + Y / 2),
color: U,
}),
S$ = 220,
g6 = () => ({ min: N0(-S$, -1, -S$), max: N0(S$, 0, S$), color: "floor" });
function HK() {
let J = [g6()],
$ = [];
(J.push(h0(-8, 2, 2.6, 0.5, 2.6, "orange")),
J.push(h0(-8, -2.8, 2.6, 1, 2.6, "white")),
J.push(h0(-8, -7.8, 2.6, 1.5, 2.6, "white")),
J.push(h0(-8, -13, 2.6, 2, 2.6, "red")),
J.push(h0(-8, -18.8, 2.6, 2, 2.6, "white")),
J.push(h0(-12.5, -18.8, 2.2, 1, 2.2, "white")),
J.push(h0(7, 4, 2, 2, 2, "white")),
J.push(h0(9.4, 4, 2, 1, 2, "white")),
J.push(h0(7, -2, 1.5, 0.75, 1.5, "red")),
J.push(h0(10, -6, 3, 2.5, 3, "white")),
J.push(h0(10, -9.2, 3, 1.25, 3, "white")),
J.push(h0(6.2, -11, 1, 0.5, 1, "orange")),
J.push(h0(8.5, -16, 2, 1, 2, "white")),
J.push(h0(12.5, -16, 2, 2, 2, "white")),
J.push(h0(7, -24, 2.5, 1.5, 2.5, "white")),
J.push(h0(-21, 4, 3.4, 0.5, 0.35, "red")),
J.push(h0(-21, -2, 3, 0.75, 0.8, "white")),
J.push(h0(-21, -8, 3.4, 0.95, 0.4, "orange")),
J.push(h0(-21, -14, 3, 1, 2.4, "white")),
J.push(h0(-21, -20, 3, 1.2, 1.2, "white")),
J.push(h0(-21, -26, 3.4, 1.55, 1.6, "red")),
J.push(h0(-21, -32, 3.4, 1.5, 0.4, "orange")),
J.push(h0(-21, -38, 3.4, 2, 1.2, "white")),
J.push(h0(-28.5, -10, 1, 4.5, 14, "red")),
J.push(h0(-30.4, -31, 1, 6, 14, "red")),
J.push(h0(-26.6, -31, 1, 6, 14, "white")),
J.push(h0(-34.5, -20, 1, 9, 28, "white")),
J.push(h0(-33.2, -8.5, 1.6, 2.6, 5, "orange")),
J.push(h0(11, -32, 3, 2.6, 3, "orange")),
J.push(h0(11, -38, 3, 4.8, 3, "white")),
J.push(h0(15.5, -35, 1.2, 2.8, 6, "red")),
J.push(h0(-16, -8, 4, 3, 4, "white")),
J.push(h0(-15, 8, 2, 1, 2, "white")),
J.push(h0(16, 2, 3, 4, 3, "white")),
J.push(h0(15, -28, 2, 0.5, 2, "red")),
J.push(h0(-5, -40, 2, 1, 2, "white")),
J.push(h0(5, -48, 3, 2, 3, "orange")),
J.push(h0(-12, -52, 2.5, 1.5, 2.5, "white")),
J.push(h0(0, -70, 6, 3, 2, "white")));
let Q = (Z, K, Y, U, X, W = 5) => {
let H = Y / Math.tan(K * j);
($.push(C9(K, Y, Z, 26, W, "-z", U)), $.push(C9(K, Y, Z - 2 * H, 26, W, "+z", X)));
};
return (
Q(2, 12, 0.9, "orange", "white"),
Q(-12, 28, 1.6, "white", "white", 9),
Q(-24, 40, 1.6, "red", "white"),
Q(-33, 45, 1.3, "white", "orange"),
$.push(C9(60, 2.2, -41, 26, 5, "-z", "red")),
J.push(h0(30, -41.6, 2, 1.9, 2.5, "white")),
J.push(h0(1.5, -30, 4, 0.75, 0.4, "orange")),
J.push(YX(1.5, 2, -30, 4, 2.4, 0.4, "orange")),
J.push(h0(-1.75, -30, 2.5, 4.4, 0.4, "white")),
J.push(h0(4.75, -30, 2.5, 4.4, 0.4, "white")),
$.push(C9(42, 4.6, -48, 21, 6, "-z", "orange")),
J.push(h0(21, -58, 7, 5, 6, "white")),
{ boxes: J, ramps: $, spawn: N0(0, 0, 20), spawnYaw: 0 }
);
}
function UX(J = 5) {
return { boxes: [g6(), h0(0, 0, 6, J, 6, "white")], spawn: N0(0, J, 0), spawnYaw: 0 };
}
function XX() {
return { boxes: [g6(), h0(-2.45, -15, 1, 4.5, 22, "red")], spawn: N0(-1.55, 0, 0), spawnYaw: 0 };
}
function HX() {
return {
boxes: [g6(), h0(-1.9, -16, 1, 8, 26, "red"), h0(1.9, -16, 1, 8, 26, "white")],
spawn: N0(-1, 0, 0),
spawnYaw: 0,
};
}
function WX() {
return { boxes: [g6(), h0(0, -10, 6, 2.5, 2, "orange")], spawn: N0(0, 0, 0), spawnYaw: 0 };
}
function NX() {
return { boxes: [g6(), h0(0, -10, 6, 0.95, 0.4, "orange")], spawn: N0(0, 0, 0), spawnYaw: 0 };
}
function rF(J = 30, $ = 1.5, Q = 8) {
let Z = $ / Math.tan(J * j);
return {
boxes: [g6()],
ramps: [C9(J, $, -8, 0, Q, "-z", "orange"), C9(J, $, -8 - 2 * Z, 0, Q, "+z", "white")],
spawn: N0(0, 0, 0),
spawnYaw: 0,
};
}
function qX() {
return rF(25, 1.5, 10);
}
function FX() {
return { boxes: [g6()], spawn: N0(0, 0, 0), spawnYaw: 0 };
}
function GX() {
return { boxes: [g6(), h0(0, -16, 8, 3.8, 4, "white")], spawn: N0(0, 0, 0), spawnYaw: 0 };
}
function OX() {
return {
boxes: [
g6(),
h0(0, -6, 2, 2, 2, "white"),
h0(8, -6, 2, 1, 2, "white"),
YX(-8, 2.2, -6, 2, 2, 2, "white"),
h0(0, -20, 12, 3, 1, "white"),
],
spawn: N0(0, 0, 0),
spawnYaw: 0,
};
}
var nJ = (J, $, Q) => $ >= J.min.x && $ <= J.max.x && Q >= J.min.z && Q <= J.max.z;
function T$(J, $) {
if (!$.ramps || !J.grounded) return null;
for (let Q of $.ramps) {
if (!$J(Q)) continue;
if (!nJ(Q, J.pos.x, J.pos.z)) continue;
if (Math.abs(J.pos.y - x6(Q, J.pos.x, J.pos.z)) <= 0.000001) return Q;
}
return null;
}
var _9 = k.contactEpsilon;
function A9(J, $, Q, Z) {
let K = m0(J, Z.min.x, Z.max.x),
Y = m0($, Z.min.z, Z.max.z),
U = J - K,
X = $ - Y;
return U * U + X * X < Q * Q;
}
function WK(J, $, Q, Z) {
let K = m0(J, Z.min.x, Z.max.x),
Y = m0($, Z.min.z, Z.max.z),
U = J - K,
X = $ - Y;
return U * U + X * X < Q * Q;
}
function j$(J, $, Q, Z) {
let K = JJ(J);
return x6(J, m0($ + K.ux * Z, J.min.x, J.max.x), m0(Q + K.uz * Z, J.min.z, J.max.z));
}
function F7(J, $, Q, Z) {
let K = k.radius,
Y = J.slideState > 0 || J.tuckState > 0 ? k.slideHeight : k.height,
U = $.ramps,
X = J.vel.x * Q,
W = J.vel.z * Q,
H = Math.sqrt(X * X + W * W),
q = Math.max(1, Math.ceil(H / k.maxSubstepTravel)),
F = q7 * (H / q) + 0.000001;
for (let O = 0; O < q; O++) {
if (((J.pos.x += X / q), (J.pos.z += W / q), U && J.grounded)) {
let M = -1 / 0;
for (let V of U) {
if (!$J(V)) continue;
if (!nJ(V, J.pos.x, J.pos.z)) continue;
let G = x6(V, J.pos.x, J.pos.z);
if (Math.abs(G - J.pos.y) <= F && G > M) M = G;
}
if (M > -1 / 0) J.pos.y = M;
}
y$(J, $, K, Y);
}
if (J.grounded)
if (!$.ramps) {
let O = !1;
for (let M of $.boxes)
if (Math.abs(J.pos.y - M.max.y) < 0.000000001 && A9(J.pos.x, J.pos.z, K, M)) {
O = !0;
break;
}
if (!O) J.grounded = !1;
} else {
let O = q7 * H + 0.000001,
M = -1 / 0;
for (let V of $.boxes)
if (V.max.y <= J.pos.y + 0.000000001 && V.max.y >= J.pos.y - O && V.max.y > M && A9(J.pos.x, J.pos.z, K, V))
M = V.max.y;
for (let V of $.ramps) {
if (!$J(V)) continue;
if (!nJ(V, J.pos.x, J.pos.z)) continue;
let G = x6(V, J.pos.x, J.pos.z);
if (G >= J.pos.y - O && G <= J.pos.y + O && G > M) M = G;
}
if (M > -1 / 0) J.pos.y = M;
else J.grounded = !1;
}
if (!J.grounded) {
let O = J.vel.y > 0 ? k.gravityRise : k.gravityFall;
J.vel.y = Math.max(J.vel.y - O * Q, -k.terminalFall);
}
let N = J.pos.y;
if (((J.pos.y += J.vel.y * Q), J.vel.y <= 0)) {
let O = -1 / 0;
for (let M of $.boxes) {
if (!A9(J.pos.x, J.pos.z, K, M)) continue;
let V = M.max.y;
if (N >= V - 0.000000001 && J.pos.y <= V && V > O) O = V;
}
if ($.ramps)
for (let M of $.ramps) {
if (!$J(M)) continue;
if (!nJ(M, J.pos.x, J.pos.z)) continue;
let V = x6(M, J.pos.x, J.pos.z);
if (N >= V - 0.000000001 && J.pos.y <= V && V > O) O = V;
}
if (O > -1 / 0) {
J.pos.y = O;
let M = -J.vel.y;
if (((J.vel.y = 0), !J.grounded)) ((J.grounded = !0), (Z.landed = M));
} else J.grounded = !1;
} else {
let O = J.pos.y + Y,
M = N + Y,
V = 1 / 0;
for (let G of $.boxes) {
if (!A9(J.pos.x, J.pos.z, K, G)) continue;
let R = G.min.y;
if (M <= R + 0.000000001 && O > R && R < V) V = R;
}
if ($.ramps)
for (let G of $.ramps) {
if (!WK(J.pos.x, J.pos.z, K, G)) continue;
let R = G.min.y;
if (M <= R + 0.000000001 && O > R && R < V) V = R;
}
if (V < 1 / 0) ((J.pos.y = V - Y), (J.vel.y = 0), (Z.headBump = !0));
J.grounded = !1;
}
if ($.ramps)
for (let O of $.ramps) {
if (!nJ(O, J.pos.x, J.pos.z)) continue;
let M = x6(O, J.pos.x, J.pos.z),
V = M - J.pos.y;
if (V <= 0.000000000001) continue;
let G = JJ(O);
if ($J(O) && V <= q7 * H + 0.0001) {
if (((J.pos.y = M), J.vel.y <= 0)) {
let R = -J.vel.y;
if (((J.vel.y = 0), !J.grounded)) ((J.grounded = !0), (Z.landed = R));
}
} else {
let R = V / G.tan + 0.000001;
if (((J.pos.x -= G.ux * R), (J.pos.z -= G.uz * R), !J.grounded)) {
let B = 1 / Math.sqrt(1 + G.tan * G.tan),
I = -G.ux * G.tan * B,
L = B,
w = -G.uz * G.tan * B,
z = J.vel.x * I + J.vel.y * L + J.vel.z * w;
if (z < 0) ((J.vel.x -= I * z), (J.vel.y -= L * z), (J.vel.z -= w * z));
} else {
let B = J.vel.x * G.ux + J.vel.z * G.uz;
if (B > 0) ((J.vel.x -= G.ux * B), (J.vel.z -= G.uz * B));
}
}
}
}
function y$(J, $, Q, Z) {
for (let K = 0; K < 4; K++) {
let Y = !1;
if ($.ramps) Y = tF(J, $.ramps, Q, Z) || Y;
for (let U of $.boxes) {
if (J.pos.y >= U.max.y - _9) continue;
if (J.pos.y + Z <= U.min.y + _9) continue;
let X = m0(J.pos.x, U.min.x, U.max.x),
W = m0(J.pos.z, U.min.z, U.max.z),
H = J.pos.x - X,
q = J.pos.z - W,
F = H * H + q * q;
if (F >= Q * Q) continue;
let N;
if (F > 0.000000000001) {
let M = Math.sqrt(F);
((H /= M), (q /= M), (N = Q - M));
} else {
let M = J.pos.x - U.min.x,
V = U.max.x - J.pos.x,
G = J.pos.z - U.min.z,
R = U.max.z - J.pos.z,
B = Math.min(M, V, G, R);
((H = B === M ? -1 : B === V ? 1 : 0), (q = H !== 0 ? 0 : B === G ? -1 : 1), (N = B + Q));
}
((J.pos.x += H * N), (J.pos.z += q * N));
let O = J.vel.x * H + J.vel.z * q;
if (O < 0) ((J.vel.x -= H * O), (J.vel.z -= q * O));
Y = !0;
}
if (!Y) break;
}
}
function tF(J, $, Q, Z) {
let K = !1;
for (let Y of $) {
if (J.pos.y + Z <= Y.min.y + _9) continue;
let U = m0(J.pos.x, Y.min.x, Y.max.x),
X = m0(J.pos.z, Y.min.z, Y.max.z),
W = x6(Y, U, X),
H = $J(Y),
q = JJ(Y),
F = J.pos.x - U,
N = J.pos.z - X,
O = F * F + N * N;
if (O > 0.000000000001) {
if (O >= Q * Q) continue;
if (J.pos.y >= W - (H ? Q * q.tan + _9 : _9)) continue;
let M = Math.sqrt(O);
((F /= M), (N /= M));
let V = Q - M;
((J.pos.x += F * V), (J.pos.z += N * V));
let G = J.vel.x * F + J.vel.z * N;
if (G < 0) ((J.vel.x -= F * G), (J.vel.z -= N * G));
K = !0;
} else if (!H && J.pos.y < W - _9) {
let M = (W - J.pos.y) / q.tan + 0.000001;
if (((J.pos.x -= q.ux * M), (J.pos.z -= q.uz * M), J.grounded)) {
let V = J.vel.x * q.ux + J.vel.z * q.uz;
if (V > 0) ((J.vel.x -= q.ux * V), (J.vel.z -= q.uz * V));
} else {
let V = 1 / Math.sqrt(1 + q.tan * q.tan),
G = -q.ux * q.tan * V,
R = V,
B = -q.uz * q.tan * V,
I = J.vel.x * G + J.vel.y * R + J.vel.z * B;
if (I < 0) ((J.vel.x -= G * I), (J.vel.y -= R * I), (J.vel.z -= B * I));
}
K = !0;
}
}
return K;
}
function iJ(J) {
return J.ledgeNx !== 0 ? N0(J.ledgePlane, J.ledgeY, J.ledgeAnchorT) : N0(J.ledgeAnchorT, J.ledgeY, J.ledgePlane);
}
function RX(J) {
let $ = iJ(J);
return N0($.x + J.ledgeNx * (k.radius + k.hangGap), J.ledgeY - k.hangDrop, $.z + J.ledgeNz * (k.radius + k.hangGap));
}
function QJ(J, $, Q, Z, K, Y) {
for (let U of J.boxes) {
if (U === $) continue;
if (U.max.y <= K + 0.000001 || U.min.y >= Y - 0.000001) continue;
if (A9(Q, Z, k.radius, U)) return !0;
}
if (J.ramps)
for (let U of J.ramps) {
if (U.min.y >= Y - 0.000001) continue;
if (!WK(Q, Z, k.radius, U)) continue;
if (j$(U, Q, Z, k.radius) > K + 0.000001) return !0;
}
return !1;
}
function MX(J, $, Q, Z, K, Y, U, X) {
let W = (V, G) => V >= K && V <= U && G >= Y && G <= X;
if (W(J, $) || W(Q, Z)) return 0;
let H = (V, G, R, B) => {
let I = (Q - J) * (G - $) - (Z - $) * (V - J),
L = (Q - J) * (B - $) - (Z - $) * (R - J),
w = (R - V) * ($ - G) - (B - G) * (J - V),
z = (R - V) * (Z - G) - (B - G) * (Q - V);
return I * L < 0 && w * z < 0;
};
if (H(K, Y, U, Y) || H(U, Y, U, X) || H(U, X, K, X) || H(K, X, K, Y)) return 0;
let q = (V, G) => Math.hypot(V - m0(V, K, U), G - m0(G, Y, X)),
F = Q - J,
N = Z - $,
O = F * F + N * N,
M = (V, G) => {
let R = O > 0 ? m0(((V - J) * F + (G - $) * N) / O, 0, 1) : 0;
return Math.hypot(V - (J + F * R), G - ($ + N * R));
};
return Math.min(q(J, $), q(Q, Z), M(K, Y), M(K, X), M(U, Y), M(U, X));
}
function P9(J, $, Q, Z, K, Y, U, X) {
for (let W of J.boxes) {
if (W === $) continue;
if (W.max.y <= U + 0.000001 || W.min.y >= X - 0.000001) continue;
if (MX(Q, Z, K, Y, W.min.x, W.min.z, W.max.x, W.max.z) < k.radius) return !0;
}
if (J.ramps)
for (let W of J.ramps) {
if (W.min.y >= X - 0.000001) continue;
if (MX(Q, Z, K, Y, W.min.x, W.min.z, W.max.x, W.max.z) >= k.radius) continue;
if (Math.max(j$(W, Q, Z, k.radius), j$(W, K, Y, k.radius)) > U + 0.000001) return !0;
}
return !1;
}
function VX(J, $, Q, Z, K, Y, U, X, W) {
if (QJ(J, $, Y, U, K - k.hangDrop, K + k.climbHop + k.height)) return !1;
let H = Q !== 0 ? W : X,
q = Q !== 0 ? X : W,
F = H - Q * k.climbEndInset,
N = q - Z * k.climbEndInset;
return !P9(J, $, Y, U, F, N, K + 0.0001, K + k.climbHop + k.height);
}
function EX(J, $) {
let Q = k.radius,
Z = o8(J.yaw),
K = Math.cos(k.grabFacingMaxDeg * j),
Y = null;
for (let U of $.boxes) {
let X = U.max.y - J.pos.y;
if (X < k.grabWindowLo || X > k.grabWindowHi) continue;
let W = [
{ nx: 1, nz: 0, plane: U.max.x, t: J.pos.z, lo: U.min.z, hi: U.max.z, d: J.pos.x - U.max.x },
{ nx: -1, nz: 0, plane: U.min.x, t: J.pos.z, lo: U.min.z, hi: U.max.z, d: U.min.x - J.pos.x },
{ nx: 0, nz: 1, plane: U.max.z, t: J.pos.x, lo: U.min.x, hi: U.max.x, d: J.pos.z - U.max.z },
{ nx: 0, nz: -1, plane: U.min.z, t: J.pos.x, lo: U.min.x, hi: U.max.x, d: U.min.z - J.pos.z },
];
for (let H of W) {
if (H.d < -0.01 || H.d > Q + k.grabReach) continue;
if (H.hi - H.lo < 2 * k.shimmyEndMargin + 0.01) continue;
if (H.t < H.lo - 0.05 || H.t > H.hi + 0.05) continue;
if (Z.x * H.nx + Z.z * H.nz > -K) continue;
if (J.vel.x * H.nx + J.vel.z * H.nz > k.grabMaxAway) continue;
if (Y && H.d >= Y.dist) continue;
if (
J.regrabTimer > 0 &&
Math.abs(U.max.y - J.ledgeY) < 0.000000001 &&
Math.abs(H.plane - J.ledgePlane) < 0.000000001 &&
H.nx === J.ledgeNx &&
H.nz === J.ledgeNz
)
continue;
let q = m0(H.t, H.lo + k.shimmyEndMargin, H.hi - k.shimmyEndMargin),
F = H.nx !== 0 ? H.plane : q,
N = H.nx !== 0 ? q : H.plane,
O = F + H.nx * (Q + k.hangGap),
M = N + H.nz * (Q + k.hangGap);
if (!VX($, U, H.nx, H.nz, U.max.y, O, M, q, H.plane)) continue;
Y = { nx: H.nx, nz: H.nz, top: U.max.y, plane: H.plane, lo: H.lo, hi: H.hi, anchorT: q, dist: H.d };
}
}
return Y;
}
function kX(J, $, Q) {
((J.ledgePhase = 1),
(J.ledgeNx = $.nx),
(J.ledgeNz = $.nz),
(J.ledgeY = $.top),
(J.ledgePlane = $.plane),
(J.ledgeLo = $.lo + k.shimmyEndMargin),
(J.ledgeHi = $.hi - k.shimmyEndMargin),
(J.ledgeAnchorT = m0($.anchorT, J.ledgeLo, J.ledgeHi)),
(J.hangTime = 0),
(J.climbBuf = 0),
(J.climbPhase = 0),
(J.pinFade = 0),
(J.shimmyVel = 0),
(J.shimmyPhase = 0),
(J.jumpCutDone = !0),
(J.jumpTime = 1e9),
(J.coyote = 0),
(J.buffer = 0));
let Z = Math.max(0, -(J.vel.x * $.nx + J.vel.z * $.nz)),
K = Math.max(0, -J.vel.y) + 0.5 * Z;
((J.dipVel -= Math.min(K * k.grabDipScale, k.dipMaxImpulse)), (Q.grabbed = K));
}
function DX(J, $, Q, Z, K, Y, U, X) {
J.hangTime += Z;
let W =
J.hangTime >= k.regripMinTime &&
VX(Q, null, J.ledgeNx, J.ledgeNz, J.ledgeY, J.pos.x, J.pos.z, J.ledgeAnchorT, J.ledgePlane);
if (Y || U || $.fwd > 0.5) J.climbBuf = k.jumpBufferTime;
else if (W) J.climbBuf = Math.max(0, J.climbBuf - Z);
if (X) {
((J.ledgePhase = 0),
(J.regrabTimer = k.dropRegrabCooldown),
(J.vel.x = J.ledgeNx * k.dropPush),
(J.vel.z = J.ledgeNz * k.dropPush),
(J.vel.y = Math.min(0, J.vel.y)),
(K.dropped = !0));
return;
}
if (J.climbBuf > 0 && W) {
((J.ledgePhase = 2),
(J.climbTime = 0),
(J.climbUpT = k.climbUpTime),
(J.climbOverT = k.climbOverTime),
(J.climbX0 = J.pos.x),
(J.climbY0 = J.pos.y),
(J.climbZ0 = J.pos.z),
(J.shimmyVel = 0),
(J.vel.x = 0),
(J.vel.y = 0),
(J.vel.z = 0),
(K.climbStarted = !0),
G7(J, Z, K));
return;
}
J.shimmyVel = w8(J.shimmyVel, m0($.strafe, -1, 1) * k.shimmySpeed, k.shimmyK, Z);
let H = J.ledgeAnchorT + J.shimmyVel * Z;
if (H <= J.ledgeLo) ((H = J.ledgeLo), (J.shimmyVel = 0));
else if (H >= J.ledgeHi) ((H = J.ledgeHi), (J.shimmyVel = 0));
if (H !== J.ledgeAnchorT) {
let M = k.radius + k.hangGap,
V = J.ledgeNx !== 0 ? J.ledgePlane + J.ledgeNx * M : H,
G = J.ledgeNx !== 0 ? H : J.ledgePlane + J.ledgeNz * M;
if (QJ(Q, null, V, G, J.ledgeY - k.hangDrop, J.ledgeY)) ((H = J.ledgeAnchorT), (J.shimmyVel = 0));
}
((J.ledgeAnchorT = H), (J.shimmyPhase += (Math.abs(J.shimmyVel) * Z) / k.shimmyStepLen));
let q = RX(J),
F = k.catchOmega,
N = 2 * k.catchZeta * F;
((J.vel.x += (F * F * (q.x - J.pos.x) - N * J.vel.x) * Z),
(J.vel.y += (F * F * (q.y - J.pos.y) - N * J.vel.y) * Z),
(J.vel.z += (F * F * (q.z - J.pos.z) - N * J.vel.z) * Z),
(J.pos.x += J.vel.x * Z),
(J.pos.y += J.vel.y * Z),
(J.pos.z += J.vel.z * Z));
let O = J.ledgeNx !== 0 ? (J.pos.x - J.ledgePlane) * J.ledgeNx : (J.pos.z - J.ledgePlane) * J.ledgeNz;
if (O < k.radius) {
let M = k.radius - O;
((J.pos.x += J.ledgeNx * M), (J.pos.z += J.ledgeNz * M));
let V = J.vel.x * J.ledgeNx + J.vel.z * J.ledgeNz;
if (V < 0) ((J.vel.x -= J.ledgeNx * V), (J.vel.z -= J.ledgeNz * V));
}
J.grounded = !1;
}
function G7(J, $, Q) {
J.climbTime += $;
let Z = J.climbUpT + J.climbOverT,
K = iJ(J),
Y = K.x - J.ledgeNx * k.climbEndInset,
U = K.z - J.ledgeNz * k.climbEndInset,
X = J.pos.x,
W = J.pos.y,
H = J.pos.z;
if (J.climbTime < J.climbUpT) {
let q = T0(J.climbTime / J.climbUpT);
((J.pos.x = J.climbX0),
(J.pos.z = J.climbZ0),
(J.pos.y = s(J.climbY0, J.ledgeY + k.climbHop, q)),
(J.grounded = !1));
} else if (J.climbTime < Z) {
let q = T0((J.climbTime - J.climbUpT) / J.climbOverT);
((J.pos.x = s(J.climbX0, Y, q)),
(J.pos.z = s(J.climbZ0, U, q)),
(J.pos.y = J.ledgeY + k.climbHop * (1 - q)),
(J.grounded = !1));
} else {
((J.pos.x = Y),
(J.pos.z = U),
(J.pos.y = J.ledgeY),
(J.ledgePhase = 0),
(J.grounded = !0),
(J.vel.x = -J.ledgeNx * k.climbExitSpeed),
(J.vel.z = -J.ledgeNz * k.climbExitSpeed),
(J.vel.y = 0),
(J.dipVel -= k.climbSettleImpulse),
(J.airTime = 0),
(J.landTime = 0),
(J.climbPhase = 1),
(Q.climbEnded = !0));
return;
}
((J.climbPhase = b0(J.climbTime / Z)),
(J.vel.x = (J.pos.x - X) / $),
(J.vel.y = (J.pos.y - W) / $),
(J.vel.z = (J.pos.z - H) / $));
}
function IX(J, $) {
let Q = k.radius,
Z = o8(J.yaw),
K = Math.cos(k.vaultFacingMaxDeg * j),
Y = C8(J.vel),
U = null,
X = 1 / 0;
for (let W of $.boxes) {
let H = W.max.y - J.pos.y;
if (H < k.standMantleLo || H > k.vaultWindowHi) continue;
let q = [
{ nx: 1, nz: 0, plane: W.max.x, t: J.pos.z, lo: W.min.z, hi: W.max.z, d: J.pos.x - W.max.x },
{ nx: -1, nz: 0, plane: W.min.x, t: J.pos.z, lo: W.min.z, hi: W.max.z, d: W.min.x - J.pos.x },
{ nx: 0, nz: 1, plane: W.max.z, t: J.pos.x, lo: W.min.x, hi: W.max.x, d: J.pos.z - W.max.z },
{ nx: 0, nz: -1, plane: W.min.z, t: J.pos.x, lo: W.min.x, hi: W.max.x, d: W.min.z - J.pos.z },
];
for (let F of q) {
let N = F.d - Q;
if (N < -0.01 || N > k.standMantleReach || N >= X) continue;
if (F.t < F.lo - 0.05 || F.t > F.hi + 0.05) continue;
if (F.hi - F.lo < 2 * k.shimmyEndMargin + 0.01) continue;
if (Z.x * F.nx + Z.z * F.nz > -K) continue;
let O = -(J.vel.x * F.nx + J.vel.z * F.nz);
if (O < -k.grabMaxAway) continue;
if (Y > 1.5 && O < 0.4 * Y) continue;
let M = m0(F.t, F.lo + k.shimmyEndMargin, F.hi - k.shimmyEndMargin);
if (QJ($, W, J.pos.x, J.pos.z, J.pos.y + 0.001, W.max.y + k.climbHop + k.height)) continue;
let V = F.nx !== 0 ? F.plane : M,
G = F.nx !== 0 ? M : F.plane,
R = V - F.nx * k.climbEndInset,
B = G - F.nz * k.climbEndInset;
if (P9($, W, J.pos.x, J.pos.z, R, B, W.max.y + 0.0001, W.max.y + k.climbHop + k.height)) continue;
((U = { nx: F.nx, nz: F.nz, top: W.max.y, plane: F.plane, lo: F.lo, hi: F.hi, anchorT: M }), (X = N));
}
}
return U;
}
function LX(J, $, Q) {
((J.ledgePhase = 2),
(J.ledgeNx = $.nx),
(J.ledgeNz = $.nz),
(J.ledgeY = $.top),
(J.ledgePlane = $.plane),
(J.ledgeLo = $.lo + k.shimmyEndMargin),
(J.ledgeHi = $.hi - k.shimmyEndMargin),
(J.ledgeAnchorT = m0($.anchorT, J.ledgeLo, J.ledgeHi)),
(J.hangTime = 0),
(J.climbBuf = 0),
(J.climbTime = 0),
(J.climbPhase = 0),
(J.climbX0 = J.pos.x),
(J.climbY0 = J.pos.y),
(J.climbZ0 = J.pos.z),
(J.climbUpT = m0(k.standUpBase + k.standUpPerM * ($.top + k.climbHop - J.pos.y), 0.42, 0.8)),
(J.climbOverT = k.climbOverTime),
(J.pinFade = 0),
(J.shimmyVel = 0),
(J.shimmyPhase = 0),
(J.jumpCutDone = !0),
(J.jumpTime = 1e9),
(J.coyote = 0),
(J.vel.x = 0),
(J.vel.y = 0),
(J.vel.z = 0),
(J.grounded = !1),
(J.dipVel -= k.standPlantImpulse),
(Q.climbStarted = !0));
}
function CX(J, $) {
let Q = C8(J.vel);
if (Q < k.vaultMinSpeed) return null;
let Z = J.vel.x / Q,
K = J.vel.z / Q,
Y = o8(J.yaw),
U = Math.cos(k.vaultFacingMaxDeg * j),
X = Math.cos(k.vaultTravelMaxDeg * j),
W = k.radius,
H = k.vaultEdgeMargin,
q = null,
F = 1 / 0;
for (let N of $.boxes) {
let O = N.max.y - J.pos.y;
if (O < k.vaultWindowLo || O > k.vaultWindowHi) continue;
let M = [
{ nx: 1, nz: 0, d: J.pos.x - N.max.x, depth: N.max.x - N.min.x, lo: N.min.z, hi: N.max.z },
{ nx: -1, nz: 0, d: N.min.x - J.pos.x, depth: N.max.x - N.min.x, lo: N.min.z, hi: N.max.z },
{ nx: 0, nz: 1, d: J.pos.z - N.max.z, depth: N.max.z - N.min.z, lo: N.min.x, hi: N.max.x },
{ nx: 0, nz: -1, d: N.min.z - J.pos.z, depth: N.max.z - N.min.z, lo: N.min.x, hi: N.max.x },
];
for (let V of M) {
let G = V.d - W;
if (G <= 0) continue;
if (G >= F) continue;
if (Z * V.nx + K * V.nz > -X) continue;
if (Y.x * V.nx + Y.z * V.nz > -U) continue;
let R = -(J.vel.x * V.nx + J.vel.z * V.nz),
B = N.max.y + k.vaultHop,
L = (1.5 * (B - J.pos.y)) / k.vaultMaxRiseSpeed;
if (G > Math.max(k.vaultDetectDist, R * L + 0.7)) continue;
let w = 1;
if (G / R < L) {
if (((w = G / L / R), w < 0.7)) continue;
}
let z = R * w,
S = G / z,
E = Math.max(L, k.vaultRiseMinTime),
_ = J.vel.x * w,
c = J.vel.z * w,
A = Q * w,
v = (L0) => (V.nx !== 0 ? J.pos.z + c * L0 : J.pos.x + _ * L0),
u = V.d / z,
f = v(u);
if (f < V.lo + H || f > V.hi - H) continue;
let n = J.pos.x + _ * S,
p = J.pos.z + c * S;
if (P9($, N, J.pos.x, J.pos.z, n, p, J.pos.y + 0.001, B + k.height)) continue;
let l = V.nx !== 0 ? (V.nx === 1 ? N.max.x : N.min.x) : 0,
Y0 = V.nx !== 0 ? 0 : V.nz === 1 ? N.max.z : N.min.z,
q0 = (V.nx !== 0 ? Math.sign(Z) : Math.sign(-K)) || 1,
V0 = (L0) => {
if (V.depth > k.vaultMaxDepth) return !1;
let l0 = (V.d + V.depth + W + k.vaultExitMargin) / z,
p0 = v((V.d + V.depth) / z);
if (p0 < V.lo + H || p0 > V.hi - H) return !1;
let $0 = J.pos.x + _ * l0,
M0 = J.pos.z + c * l0;
if (P9($, N, n, p, $0, M0, B + 0.0001, B + k.height)) return !1;
let _0 =
L0 === 1
? m0(f + k.vaultPlantSpan * q0, V.lo + 0.05, V.hi - 0.05)
: m0(f, V.lo + k.handHalfSpan + 0.06, V.hi - k.handHalfSpan - 0.06);
return (
(q = {
kind: 1,
hands: L0,
speed: A,
dirX: Z,
dirZ: K,
t1: S,
riseT: E,
t2: l0,
tEnd: l0,
yTop: B,
exitSpeed: A,
plantX: (V.nx !== 0 ? l : _0) - V.nx * k.handInset,
plantY: N.max.y + k.handLift,
plantZ: (V.nx !== 0 ? _0 : Y0) - V.nz * k.handInset,
nx: V.nx,
nz: V.nz,
gap: G,
}),
(F = G),
!0
);
},
w0 = () => {
if (V.depth < k.vaultOntoInset + 0.05) return !1;
if (V.hi - V.lo < 2 * (k.handHalfSpan + 0.06)) return !1;
let L0 = u,
l0 = (V.d + k.vaultOntoInset) / z,
p0 = v(l0);
if (p0 < V.lo + H || p0 > V.hi - H) return !1;
let $0 = J.pos.x + _ * l0,
M0 = J.pos.z + c * l0;
if (QJ($, N, $0, M0, N.max.y + 0.0001, N.max.y + k.height)) return !1;
if (P9($, N, n, p, $0, M0, N.max.y + 0.0001, B + k.height)) return !1;
let _0 = Math.max(k.vaultOntoMinRetention, 1 - k.vaultOntoLossPerM * O),
E0 = L0 + ((l0 - L0) * 2) / (1 + _0),
y0 = m0(f, V.lo + k.handHalfSpan + 0.06, V.hi - k.handHalfSpan - 0.06);
return (
(q = {
kind: 2,
hands: 2,
speed: A,
dirX: Z,
dirZ: K,
t1: S,
riseT: E,
t2: L0,
tEnd: E0,
yTop: B,
exitSpeed: A * _0,
plantX: (V.nx !== 0 ? l : y0) - V.nx * k.handInset,
plantY: N.max.y + k.handLift,
plantZ: (V.nx !== 0 ? y0 : Y0) - V.nz * k.handInset,
nx: V.nx,
nz: V.nz,
gap: G,
}),
(F = G),
!0
);
};
if (O <= k.vaultCrossMaxRel && V0(1)) continue;
if (w0()) continue;
if (O > k.vaultCrossMaxRel) V0(2);
}
}
return q;
}
function _X(J, $, Q) {
((J.vaultState = $.kind),
(J.vaultKind = $.kind),
(J.vaultHands = $.hands),
(J.vaultT = 0),
(J.vaultT1 = $.t1),
(J.vaultT2 = $.t2),
(J.vaultTEnd = $.tEnd),
(J.vaultX0 = J.pos.x),
(J.vaultY0 = J.pos.y),
(J.vaultZ0 = J.pos.z),
(J.vaultDirX = $.dirX),
(J.vaultDirZ = $.dirZ),
(J.vaultSpeed = $.speed),
(J.vaultYTop = $.yTop),
(J.vaultExitSpeed = $.exitSpeed),
(J.plantX = $.plantX),
(J.plantY = $.plantY),
(J.plantZ = $.plantZ),
(J.plantNx = $.nx),
(J.plantNz = $.nz),
(J.vaultPhase = 0),
(J.vaultFade = 0),
(J.grounded = !1),
(J.coyote = 0),
(J.jumpCutDone = !0),
(J.jumpTime = 1e9),
(J.vel.y = 0),
(J.vel.x = $.dirX * $.speed),
(J.vel.z = $.dirZ * $.speed),
(Q.vaulted = $.speed));
}
function BX(J, $) {
if (J.vaultState !== 2 || $ <= J.vaultT2) return J.vaultSpeed * $;
let Q = J.vaultTEnd - J.vaultT2,
Z = Math.min($ - J.vaultT2, Q),
K = J.vaultExitSpeed / J.vaultSpeed;
return J.vaultSpeed * J.vaultT2 + J.vaultSpeed * (Z - ((1 - K) * Z * Z) / (2 * Q));
}
function eF(J, $) {
if ($ < J.vaultT1) return s(J.vaultY0, J.vaultYTop, T0($ / J.vaultT1));
if (J.vaultState === 2 && $ > J.vaultT2) {
let Q = T0(($ - J.vaultT2) / (J.vaultTEnd - J.vaultT2));
return J.vaultYTop - k.vaultHop * Q;
}
return J.vaultYTop;
}
function f$(J, $, Q, Z) {
if (((J.buffer = Math.max(0, J.buffer - $)), Z)) J.buffer = k.jumpBufferTime;
let K = J.vaultT;
J.vaultT += $;
let Y = J.vaultT;
if (K < J.vaultT1 && Y >= J.vaultT1) J.dipVel -= k.vaultPlantImpulse;
if (Y >= J.vaultTEnd) {
let q = BX(J, J.vaultTEnd);
if (((J.pos.x = J.vaultX0 + J.vaultDirX * q), (J.pos.z = J.vaultZ0 + J.vaultDirZ * q), J.vaultState === 2))
((J.pos.y = J.vaultYTop - k.vaultHop),
(J.vel.x = J.vaultDirX * J.vaultExitSpeed),
(J.vel.z = J.vaultDirZ * J.vaultExitSpeed),
(J.vel.y = 0),
(J.grounded = !0),
(J.dipVel -= k.vaultSettleImpulse),
(J.airTime = 0),
(J.landTime = 0));
else
((J.pos.y = J.vaultYTop),
(J.vel.x = J.vaultDirX * J.vaultSpeed),
(J.vel.z = J.vaultDirZ * J.vaultSpeed),
(J.vel.y = 0),
(J.grounded = !1),
(J.airTime += $),
(J.landTime += $));
((J.vaultState = 0), (J.vaultPhase = 1), (Q.vaultEnded = !0));
return;
}
let U = J.pos.x,
X = J.pos.y,
W = J.pos.z,
H = BX(J, Y);
((J.pos.x = J.vaultX0 + J.vaultDirX * H),
(J.pos.z = J.vaultZ0 + J.vaultDirZ * H),
(J.pos.y = eF(J, Y)),
(J.grounded = !1),
(J.vaultPhase = b0(Y / J.vaultTEnd)),
(J.vel.x = (J.pos.x - U) / $),
(J.vel.y = (J.pos.y - X) / $),
(J.vel.z = (J.pos.z - W) / $),
(J.airTime += $),
(J.landTime += $));
}
function AX(J, $) {
let Q = k.radius;
if (C8(J.vel) < k.wallRunMinSpeed) return null;
let K = Math.tan(k.wallRunVelMaxDeg * (Math.PI / 180)),
Y = Math.cos(k.wallRunFacingMaxDeg * (Math.PI / 180)),
U = o8(J.yaw),
X = null,
W = 1 / 0;
for (let H of $.boxes) {
if (H.max.y - J.pos.y < k.wallRunMinTopAbove) continue;
if (H.min.y > J.pos.y + 0.5) continue;
let q = [
[1, 0, H.max.x, H.min.z, H.max.z, J.pos.z],
[-1, 0, H.min.x, H.min.z, H.max.z, J.pos.z],
[0, 1, H.max.z, H.min.x, H.max.x, J.pos.x],
[0, -1, H.min.z, H.min.x, H.max.x, J.pos.x],
];
for (let [F, N, O, M, V, G] of q) {
let R = J.pos.x * F + J.pos.z * N - O * (F + N) - Q;
if (R < -0.000001 || R > k.wallAttachReach) continue;
if (G < M || G > V) continue;
let B = J.vel.x * F + J.vel.z * N;
if (B > 0.3) continue;
let I = J.vel.x - F * B,
L = J.vel.z - N * B,
w = Math.sqrt(I * I + L * L);
if (w < k.wallRunMinSpeed) continue;
if (Math.abs(B) > K * w) continue;
let z = I / w,
S = L / w;
if (U.x * z + U.z * S < Y) continue;
if (J.wallLockT > 0 && F * J.wallLockNx + N * J.wallLockNz > 0.99 && Math.abs(O - J.wallLockPlane) < 0.05)
continue;
if (R < W) {
W = R;
let E = F * S - N * z;
X = { nx: F, nz: N, plane: O, lo: M, hi: V, topY: H.max.y, dirX: z, dirZ: S, side: E };
}
}
}
return X;
}
function PX(J, $, Q) {
((J.wallState = 1),
(J.wallNx = $.nx),
(J.wallNz = $.nz),
(J.wallPlane = $.plane),
(J.wallLo = $.lo),
(J.wallHi = $.hi),
(J.wallTopY = $.topY),
(J.wallDirX = $.dirX),
(J.wallDirZ = $.dirZ),
(J.wallSide = $.side),
(J.wallT = 0));
let Z = J.vel.x * $.nx + J.vel.z * $.nz;
if (Z < 0) ((J.vel.x -= $.nx * Z), (J.vel.z -= $.nz * Z));
if (J.vel.y > -1.5 && J.vel.y < k.wallRunHopCap) J.vel.y = Math.min(J.vel.y + k.wallRunHop, k.wallRunHopCap);
((J.jumpCutDone = !0),
(J.coyote = 0),
(J.buffer = 0),
(J.dipVel -= k.wallAttachImpulse),
(Q.wallStarted = C8(J.vel)));
}
function NK(J, $) {
((J.wallState = 0),
(J.wallLockNx = J.wallNx),
(J.wallLockNz = J.wallNz),
(J.wallLockPlane = J.wallPlane),
(J.wallLockT = k.wallRegrabTime),
($.wallEnded = !0));
}
function JG(J, $) {
let Q = o8(J.yaw),
Z = J.wallNx,
K = J.wallNz,
Y = Q.x * Z + Q.z * K,
U = Q.x - Z * Y,
X = Q.z - K * Y,
W = Math.sqrt(U * U + X * X);
Y = Math.max(Y, k.wallJumpMinAwayFrac);
let H = W > 0.000000001 ? Math.sqrt(Math.max(0, 1 - Y * Y)) / W : 0,
q = Z * Y + U * H,
F = K * Y + X * H,
N = Math.sqrt(q * q + F * F);
((q /= N), (F /= N));
let O = Math.max(C8(J.vel), k.wallJumpSpeedFloor);
((J.vel.x = q * O),
(J.vel.z = F * O),
(J.vel.y = k.wallJumpVy),
(J.jumpTime = 0),
(J.jumpCutDone = !0),
NK(J, $),
($.wallJumped = O),
($.jumped = !0));
}
function zX(J, $, Q, Z, K, Y) {
J.wallT += Z;
let { wallNx: U, wallNz: X } = J;
if (Y && J.airTime >= k.wallJumpGrace) {
(JG(J, K),
(J.pos.x += J.vel.x * Z),
(J.pos.z += J.vel.z * Z),
(J.pos.y += J.vel.y * Z),
y$(J, Q, k.radius, k.height),
(J.airTime += Z),
(J.landTime += Z));
return;
}
let W = J.vel.x * J.wallDirX + J.vel.z * J.wallDirZ,
H = U !== 0 ? J.pos.z : J.pos.x;
if (
J.wallT >= k.wallRunMaxTime ||
W < k.wallRunEndSpeed ||
$.fwd <= 0.1 ||
H < J.wallLo ||
H > J.wallHi ||
J.wallTopY - J.pos.y < k.wallRunKeepTopAbove
) {
(NK(J, K), oJ(J, $, Q, Z, K, !1, !1));
return;
}
let F = J.wallT < k.wallRunFloatTime ? k.wallRunGravLo : k.wallRunGravHi;
if (((J.vel.y -= F * Z), J.vel.y < -k.wallRunMaxFall))
J.vel.y += (-k.wallRunMaxFall - J.vel.y) * (1 - Math.exp(-k.wallRunDragK * Z));
let N = Math.exp(-k.wallRunFrictionK * Z),
O = W * N;
((J.vel.x = J.wallDirX * O), (J.vel.z = J.wallDirZ * O), (J.pos.x += J.vel.x * Z), (J.pos.z += J.vel.z * Z));
let M = J.wallPlane * (U + X) + k.radius + k.wallRideGap,
V = J.pos.x * U + J.pos.z * X,
G = (M - V) * (1 - Math.exp(-k.wallAttachK * Z));
((J.pos.x += U * G), (J.pos.z += X * G), y$(J, Q, k.radius, k.height));
let R = J.pos.y;
if (((J.pos.y += J.vel.y * Z), J.vel.y <= 0)) {
let B = -1 / 0;
for (let I of Q.boxes) {
let L = Math.min(Math.max(J.pos.x, I.min.x), I.max.x),
w = Math.min(Math.max(J.pos.z, I.min.z), I.max.z),
z = J.pos.x - L,
S = J.pos.z - w;
if (z * z + S * S >= k.radius * k.radius) continue;
let E = I.max.y;
if (R >= E - 0.000000001 && J.pos.y <= E && E > B) B = E;
}
if (Q.ramps)
for (let I of Q.ramps) {
if (!$J(I)) continue;
if (!nJ(I, J.pos.x, J.pos.z)) continue;
let L = x6(I, J.pos.x, J.pos.z);
if (R >= L - 0.000000001 && J.pos.y <= L && L > B) B = L;
}
if (B > -1 / 0) {
J.pos.y = B;
let I = -J.vel.y;
if (
((J.vel.y = 0),
(J.grounded = !0),
(K.landed = I),
NK(J, K),
(J.airTime = 0),
(J.landTime = 0),
(J.lastImpact = I),
I > k.landMinImpact)
)
J.dipVel -= Math.min(I * k.dipImpulseScale, k.dipMaxImpulse);
return;
}
}
((J.airTime += Z), (J.landTime += Z));
}
var $G = Math.PI / 180;
function wX(J, $, Q) {
if (((J.pressHit = 0), !J.grounded || $.fwd <= k.pressMinFwd)) return;
let Z = k.radius,
K = o8(J.yaw),
Y = Math.cos(k.pressFacingMaxDeg * $G),
U = 1 / 0;
for (let X of Q.boxes) {
if (X.max.y - J.pos.y < k.pressMinTop) continue;
if (X.min.y > J.pos.y + 0.5) continue;
let W = [
[1, 0, X.max.x, X.min.z, X.max.z, J.pos.z],
[-1, 0, X.min.x, X.min.z, X.max.z, J.pos.z],
[0, 1, X.max.z, X.min.x, X.max.x, J.pos.x],
[0, -1, X.min.z, X.min.x, X.max.x, J.pos.x],
];
for (let [H, q, F, N, O, M] of W) {
let V = J.pos.x * H + J.pos.z * q - F * (H + q) - Z;
if (V < -0.000001 || V > k.pressDetectGap) continue;
if (M < N + k.pressFaceMargin || M > O - k.pressFaceMargin) continue;
if (-(K.x * H + K.z * q) < Y) continue;
if (V < U) ((U = V), (J.pressHit = 1), (J.pressNx = H), (J.pressNz = q), (J.pressPlane = F));
}
}
}
function oJ(J, $, Q, Z, K, Y, U = !1) {
if (U && J.grounded && C8(J.vel) >= k.slideMinSpeed) {
(O7(J, 1, K), b$(J, $, Q, Z, K, !1, !1));
return;
}
if (!J.grounded && $.slide) J.tuckState = 1;
else if (J.tuckState === 1) {
let I = J.pos.x + J.vel.x * Z,
L = J.pos.z + J.vel.z * Z;
if (v$(J, Q) && !QJ(Q, null, I, L, J.pos.y + k.slideHeight, J.pos.y + k.height)) J.tuckState = 0;
}
if (J.landState === 1 && (J.landTime >= k.landHoldTime || !J.grounded)) J.landState = 0;
let X = J.landState === 1,
W = m0($.fwd, -1, 1),
H = m0($.strafe, -1, 1),
q = Math.sqrt(W * W + H * H);
if (q > 1) ((W /= q), (H /= q));
let F = o8(J.yaw),
N = oU(J.yaw),
O = N0(F.x * W + N.x * H, 0, F.z * W + N.z * H),
M = C8(O),
V = M > 0.000001;
if (J.grounded) J.coyote = k.coyoteTime;
else J.coyote = Math.max(0, J.coyote - Z);
if (((J.buffer = Math.max(0, J.buffer - Z)), Y)) J.buffer = k.jumpBufferTime;
let G = !1;
if (J.buffer > 0 && J.grounded && !X) {
let I = CX(J, Q);
if (I) {
if (I.t1 <= I.riseT + 2 * Z) {
(_X(J, I, K), (J.buffer = 0), f$(J, Z, K, !1));
return;
}
((G = !0), (J.buffer = Math.max(J.buffer, 2 * Z)));
}
}
if (!G && J.buffer > 0 && J.grounded && !X) {
let I = IX(J, Q);
if (I) {
(LX(J, I, K), (J.buffer = 0), G7(J, Z, K));
return;
}
}
if (!G && J.buffer > 0 && (J.grounded || J.coyote > 0) && !X)
((J.vel.y = k.jumpSpeed),
(J.grounded = !1),
(J.coyote = 0),
(J.buffer = 0),
(J.jumpCutDone = !$.jump),
(J.jumpTime = 0),
(J.airTime = Math.max(J.airTime, 0.000000001)),
(K.jumped = !0));
if (!J.grounded && !J.jumpCutDone && !$.jump && J.vel.y > k.jumpCutMinRise && J.jumpTime < k.jumpCutWindow)
((J.vel.y *= k.jumpCutFactor), (J.jumpCutDone = !0));
let R = C8(J.vel);
if (J.grounded) {
if (W > 0.5 && R > k.sprintChargeMinSpeed && J.vel.x * F.x + J.vel.z * F.z > 0.7 * R)
J.sprintCharge = b0(J.sprintCharge + Z / k.sprintChargeTime);
else if (R < k.sprintChargeMinSpeed || W < 0) J.sprintCharge = b0(J.sprintCharge - Z / k.sprintChargeDecay);
}
let B = J.boostTime > 0;
if (J.grounded)
if (X) {
let I = Math.exp(-k.landFrictionK * Z);
if (((J.vel.x *= I), (J.vel.z *= I), C8(J.vel) < k.stopEpsilon)) ((J.vel.x = 0), (J.vel.z = 0));
} else if (V) {
let I = Math.max(0, W),
L = Math.max(0, -W),
w = Math.abs(H),
z = B ? k.boostSpeedMult : 1,
S = s(k.runBaseSpeed, k.sprintMaxSpeed, T0(J.sprintCharge)) * z,
E = (I * S + L * k.backSpeed + w * k.strafeSpeed) / (I + L + w),
_ = T$(J, Q);
if (_) {
let u = JJ(_),
f = (O.x / M) * u.ux + (O.z / M) * u.uz;
E *=
f >= 0
? Math.max(1 - k.slopeUpTax * u.tan * f, k.slopeUpFloor)
: Math.min(1 - k.slopeDownGain * u.tan * f, k.slopeDownCap);
}
let c = (O.x / M) * E,
A = (O.z / M) * E,
v = 1 - Math.exp(-(B && W > 0 ? k.boostAccelK : k.groundAccelK) * Z);
((J.vel.x += (c - J.vel.x) * v), (J.vel.z += (A - J.vel.z) * v));
} else {
let I = Math.exp(-k.frictionK * Z);
if (((J.vel.x *= I), (J.vel.z *= I), C8(J.vel) < k.stopEpsilon)) ((J.vel.x = 0), (J.vel.z = 0));
}
else if (V) {
let I = C8(J.vel);
((J.vel.x += (O.x / M) * k.airAccel * Z), (J.vel.z += (O.z / M) * k.airAccel * Z));
let L = C8(J.vel),
w = Math.max(I, k.airSpeedCap * (B ? k.boostAirCapMult : 1));
if (L > w) {
let z = w / L;
((J.vel.x *= z), (J.vel.z *= z));
}
}
if ((F7(J, Q, Z, K), J.grounded)) ((J.airTime = 0), (J.landTime += Z));
else ((J.airTime += Z), (J.jumpTime += Z));
if (K.landed !== void 0) {
if (
((J.landTime = 0),
(J.lastImpact = K.landed),
(J.jumpTime = 1e9),
(J.jumpCutDone = !0),
K.landed > k.landMinImpact)
)
J.dipVel -= Math.min(K.landed * k.dipImpulseScale, k.dipMaxImpulse);
let I = C8(J.vel);
if (J.tuckState === 1 && $.slide && I >= k.slideMinSpeed) ((J.tuckState = 0), O7(J, 1, K));
else if (K.landed >= k.landHardImpact) {
if (J.tuckState === 1) J.tuckState = 0;
J.landState = 1;
let L = o8(J.bodyYaw),
w = k.landHandFwd + I / k.landFrictionK;
((J.landDirX = L.x),
(J.landDirZ = L.z),
(J.landPlantX = J.pos.x + L.x * w),
(J.landPlantY = J.pos.y),
(J.landPlantZ = J.pos.z + L.z * w),
(K.hardLanded = !0));
} else if (K.landed >= k.slideAutoImpact && I >= k.slideAutoMinSpeed) {
if (J.tuckState === 1) J.tuckState = 0;
O7(J, 2, K);
} else if (J.tuckState === 1) {
if (((J.tuckState = 0), !v$(J, Q))) O7(J, 1, K);
}
}
if (!J.grounded && J.vel.y <= k.grabMaxRise && J.slideState === 0 && J.tuckState === 0) {
let I = EX(J, Q);
if (I) kX(J, I, K);
}
if (
J.ledgePhase === 0 &&
!J.grounded &&
J.slideState === 0 &&
J.tuckState === 0 &&
$.fwd > 0.5 &&
J.vel.y <= k.wallAttachMaxVy &&
J.vel.y >= k.wallAttachMinVy
) {
let I = AX(J, Q);
if (I) PX(J, I, K);
}
wX(J, $, Q);
}
function O7(J, $, Q) {
((J.slideState = $),
(J.slideKind = $),
(J.slideT = 0),
(J.dipVel -= k.slideDipImpulse),
(Q.slideStarted = C8(J.vel)));
}
function v$(J, $) {
return !QJ($, null, J.pos.x, J.pos.z, J.pos.y + k.slideHeight, J.pos.y + k.height);
}
function b$(J, $, Q, Z, K, Y, U) {
J.slideT += Z;
let X = C8(J.vel),
W = v$(J, Q);
if (((J.buffer = Math.max(0, J.buffer - Z)), Y)) J.buffer = k.jumpBufferTime;
if (J.buffer > 0 && J.grounded && W) {
((J.slideState = 0),
(K.slideEnded = !0),
(J.buffer = 0),
(J.coyote = 0),
(J.vel.y = k.jumpSpeed),
(J.grounded = !1),
(J.jumpCutDone = !$.jump),
(J.jumpTime = 0),
(J.airTime = Math.max(J.airTime, 0.000000001)),
(K.jumped = !0),
F7(J, Q, Z, K),
(J.airTime += Z),
(J.landTime += Z));
return;
}
let H =
(J.slideState === 2 && J.slideT >= k.slideAutoTime) ||
(U && J.slideT >= k.slideMinTime) ||
(J.slideState === 1 && X < k.slideEndSpeed && J.slideT >= k.slideMinTime) ||
J.slideT >= k.slideMaxTime;
if (H && W && J.grounded) {
((J.slideState = 0), (K.slideEnded = !0), oJ(J, $, Q, Z, K, !1, !1));
return;
}
if (J.grounded)
if (H && !W) {
let q = o8(J.yaw),
F = m0($.fwd, -1, 1),
N = 1 - Math.exp(-k.slideShuffleK * Z);
((J.vel.x += (q.x * F * k.slideShuffleSpeed - J.vel.x) * N),
(J.vel.z += (q.z * F * k.slideShuffleSpeed - J.vel.z) * N));
} else {
let q = J.slideState === 2 ? k.slideAutoFrictionK : k.slideFrictionK,
F = Math.exp(-q * Z);
((J.vel.x *= F), (J.vel.z *= F));
let N = -m0($.strafe, -1, 1) * k.slideSteerRate * Z;
if (N !== 0) {
let M = Math.cos(N),
V = Math.sin(N),
G = J.vel.x * M - J.vel.z * V,
R = J.vel.x * V + J.vel.z * M;
((J.vel.x = G), (J.vel.z = R));
}
let O = T$(J, Q);
if (O) {
let M = JJ(O),
V = 1 / Math.sqrt(1 + M.tan * M.tan),
G = k.slideSlopeG * M.tan * V * V;
((J.vel.x -= M.ux * G * Z), (J.vel.z -= M.uz * G * Z));
}
}
if ((F7(J, Q, Z, K), J.grounded)) ((J.airTime = 0), (J.landTime += Z));
else J.airTime += Z;
if (K.landed !== void 0) {
if (((J.landTime = 0), (J.lastImpact = K.landed), K.landed > k.landMinImpact))
J.dipVel -= Math.min(K.landed * k.dipImpulseScale, k.dipMaxImpulse);
}
}
function SX(J, $, Q, Z, K) {
let Y = C8(J.vel);
J.speedSmooth = w8(J.speedSmooth, Y, k.speedSmoothK, Z);
let U = J.wallState > 0,
X = (J.grounded || U) && Y > k.moveMinSpeed && J.slideState === 0;
if (X) {
let f = k.bobStepFreqBase + k.bobStepFreqPerMs * J.speedSmooth,
n = (J.stridePhase - 0.3) * 2;
J.stridePhase += (f / 2) * Z;
let p = (J.stridePhase - 0.3) * 2;
if (Math.floor(p) > Math.floor(n)) K.footstep = ((Math.floor(p) % 2) + 2) % 2 === 0 ? "L" : "R";
} else if (J.bobFade < 0.2) {
let f = J.stridePhase - Math.floor(J.stridePhase),
n = 0.3 - f;
for (let p of [0.8 - f, 1.3 - f]) if (Math.abs(p) < Math.abs(n)) n = p;
J.stridePhase = w8(J.stridePhase, J.stridePhase + n, 4, Z);
}
let W = X ? 1 : 0,
H = X ? k.bobFadeInK : J.grounded || J.wallFade > 0.3 ? k.bobFadeOutK : k.bobFadeAirK;
J.bobFade = w8(J.bobFade, W, H, Z);
let q = (k.bobAmpVBase + k.bobAmpVPerMs * J.speedSmooth) * J.bobFade;
((J.bobY = q * Math.sin(f8 * (J.stridePhase * 2))),
(J.bobX = q * k.bobAmpLFactor * Math.sin(f8 * J.stridePhase)),
(J.bobRoll = k.bobRollDeg * j * Math.sin(f8 * J.stridePhase + 0.5) * J.bobFade));
let F = m0(-Q * k.turnRollFactor, -k.turnRollMaxDeg * j, k.turnRollMaxDeg * j),
N = k.strafeRollDeg * j * m0($.strafe, -1, 1),
O = J.vaultState === 1 && J.vaultHands === 1 ? k.vaultRollDeg * j * Math.sin(Math.PI * b0(J.vaultPhase)) : 0,
M = -J.wallSide * k.wallRunRollDeg * j * T0(b0(J.wallFade)),
V = m0(N + F + O, -k.rollMaxDeg * j, k.rollMaxDeg * j) + M;
if (
((J.roll = w8(J.roll, V, k.rollSmoothK, Z)),
(J.wallFade = w8(J.wallFade, U ? 1 : 0, U ? k.wallFadeInK : k.wallFadeOutK, Z)),
J.boostTime > 0)
) {
if (((J.boostTime = Math.max(0, J.boostTime - Z)), J.boostTime === 0)) K.boostEnded = !0;
}
((J.boostCd = Math.max(0, J.boostCd - Z)),
(J.boostFade = w8(J.boostFade, J.boostTime > 0 ? 1 : 0, J.boostTime > 0 ? k.boostFadeInK : k.boostFadeOutK, Z)));
let G =
k.fovBaseDeg +
k.fovSprintKickDeg * b0((J.speedSmooth - k.fovKickStartSpeed) / (k.sprintMaxSpeed - k.fovKickStartSpeed)) +
k.boostFovKickDeg * J.boostFade -
k.landFovPunch * T0(b0(J.landFade));
J.fov = w8(J.fov, G, k.fovSmoothK, Z);
let R = -k.dipOmega * k.dipOmega * J.dip - 2 * k.dipZeta * k.dipOmega * J.dipVel;
((J.dipVel += R * Z), (J.dip += J.dipVel * Z));
let B =
(k.leanMaxDeg * j * b0(J.speedSmooth / k.sprintMaxSpeed) + k.boostLeanDeg * j * J.boostFade) *
(J.grounded ? 1 : 0.6) *
(J.slideState > 0 ? 0 : 1);
J.lean = w8(J.lean, B, k.leanSmoothK, Z);
let I = J.ledgePhase > 0,
L = J.vaultState > 0;
((J.ledgeFade = w8(J.ledgeFade, I ? 1 : 0, I ? k.ledgeFadeInK : k.ledgeFadeOutK, Z)),
(J.pinFade = w8(J.pinFade, I ? 1 : 0, I ? k.ledgeFadeInK : k.ledgeFadeOutK, Z)),
(J.vaultFade = w8(J.vaultFade, L ? 1 : 0, L ? k.vaultFadeInK : k.vaultFadeOutK, Z)));
let w = J.slideState > 0;
J.slideFade = w8(J.slideFade, w ? 1 : 0, w ? k.slideFadeInK : k.slideFadeOutK, Z);
let z = J.tuckState > 0;
J.tuckFade = w8(J.tuckFade, z ? 1 : 0, z ? k.tuckFadeInK : k.tuckFadeOutK, Z);
let S = I || L || w || U || J.vaultFade > 0.35 || J.wallFade > 0.35;
if (((J.airFade = w8(J.airFade, J.grounded || S ? 0 : 1, J.grounded ? 10 : S ? 8 : 12, Z)), I || L || w || U))
J.prepFade = w8(J.prepFade, 0, 10, Z);
else if (!J.grounded) J.prepFade = w8(J.prepFade, b0((-J.vel.y - 1) / 6), 14, Z);
else if (J.airFade < 0.05) J.prepFade = 0;
let E = I
? Math.atan2(J.ledgeNx, J.ledgeNz)
: L
? Math.atan2(-J.vaultDirX, -J.vaultDirZ)
: U
? Math.atan2(-J.wallDirX, -J.wallDirZ)
: w && Y > 0.5
? Math.atan2(-J.vel.x, -J.vel.z)
: J.yaw,
_ = lJ(E - J.bodyYaw),
c = 10 * Z;
((J.bodyYaw = lJ(J.bodyYaw + m0(_ * (1 - Math.exp(-18 * Z)), -c, c))),
(J.pressFade = w8(J.pressFade, J.pressHit === 1 ? 1 : 0, J.pressHit === 1 ? k.pressFadeInK : k.pressFadeOutK, Z)),
(J.landFade = w8(J.landFade, J.landState === 1 ? 1 : 0, J.landState === 1 ? k.landFadeInK : k.landFadeOutK, Z)));
let A =
!J.grounded &&
J.ledgePhase === 0 &&
J.vaultState === 0 &&
J.wallState === 0 &&
J.tuckState === 0 &&
J.vel.y <= k.landPrimeVy;
J.landPrime = w8(J.landPrime, A ? 1 : 0, A ? k.landPrimeInK : k.landPrimeOutK, Z);
let v =
J.grounded &&
J.ledgePhase === 0 &&
J.vaultState === 0 &&
J.slideState === 0 &&
J.wallState === 0 &&
J.tuckState === 0 &&
J.pressHit === 0 &&
J.landState === 0 &&
J.landFade < 0.3 &&
Y < k.inspectMaxSpeed &&
J.pitch < -k.inspectPitchDeg * j &&
$.fwd === 0 &&
$.strafe === 0 &&
!$.jump &&
!$.slide &&
!$.boost;
J.inspectTime = v ? J.inspectTime + Z : 0;
let u = J.inspectTime >= k.inspectDelay;
J.inspectFade = w8(J.inspectFade, u ? 1 : 0, u ? k.inspectFadeInK : k.inspectFadeOutK, Z);
}
function TX(J, $ = 0) {
return {
pos: { x: J.x, y: J.y, z: J.z },
vel: N0(),
yaw: $,
bodyYaw: $,
pitch: 0,
grounded: !1,
coyote: 0,
buffer: 0,
jumpHeldPrev: !1,
jumpCutDone: !0,
jumpTime: 1e9,
airTime: 0,
landTime: 1e9,
lastImpact: 0,
sprintCharge: 0,
ledgePhase: 0,
ledgeNx: 0,
ledgeNz: 1,
ledgeY: 0,
ledgePlane: 0,
ledgeLo: 0,
ledgeHi: 0,
ledgeAnchorT: 0,
hangTime: 0,
climbTime: 0,
climbUpT: k.climbUpTime,
climbOverT: k.climbOverTime,
climbPhase: 0,
climbX0: 0,
climbY0: 0,
climbZ0: 0,
climbBuf: 0,
shimmyVel: 0,
shimmyPhase: 0,
regrabTimer: 0,
ledgeFade: 0,
pinFade: 0,
fwdPrev: 0,
vaultState: 0,
vaultT: 0,
vaultT1: 0,
vaultT2: 0,
vaultTEnd: 0,
vaultX0: 0,
vaultY0: 0,
vaultZ0: 0,
vaultDirX: 0,
vaultDirZ: -1,
vaultSpeed: 0,
vaultYTop: 0,
vaultExitSpeed: 0,
plantX: 0,
plantY: 0,
plantZ: 0,
plantNx: 0,
plantNz: 1,
vaultKind: 1,
vaultHands: 1,
vaultFade: 0,
vaultPhase: 0,
wallState: 0,
wallNx: 0,
wallNz: 1,
wallPlane: 0,
wallLo: 0,
wallHi: 0,
wallTopY: 0,
wallDirX: 0,
wallDirZ: -1,
wallSide: 1,
wallT: 0,
wallFade: 0,
wallLockNx: 0,
wallLockNz: 1,
wallLockPlane: 0,
wallLockT: 0,
slideState: 0,
slideKind: 1,
slideT: 0,
slideFade: 0,
slideHeldPrev: !1,
pressHit: 0,
pressNx: 0,
pressNz: 1,
pressPlane: 0,
pressFade: 0,
landState: 0,
landFade: 0,
landPrime: 0,
landPlantX: 0,
landPlantY: 0,
landPlantZ: 0,
landDirX: 0,
landDirZ: 1,
inspectTime: 0,
inspectFade: 0,
tuckState: 0,
tuckFade: 0,
boostTime: 0,
boostCd: 0,
boostFade: 0,
boostHeldPrev: !1,
speedSmooth: 0,
stridePhase: 0,
bobFade: 0,
bobY: 0,
bobX: 0,
bobRoll: 0,
roll: 0,
fov: k.fovBaseDeg,
dip: 0,
dipVel: 0,
lean: 0,
airFade: 1,
prepFade: 0,
time: 0,
tick: 0,
};
}
function jX(J, $, Q, Z) {
let K = {},
Y = k.maxPitchDeg * j;
((J.yaw = lJ(J.yaw + $.dyaw)), (J.pitch = m0(J.pitch + $.dpitch, -Y, Y)));
let U = $.dyaw / Z,
X = $.jump && !J.jumpHeldPrev,
W = $.fwd > 0.5 && J.fwdPrev <= 0.5,
H = $.fwd < -0.5 && J.fwdPrev >= -0.5,
q = $.slide && !J.slideHeldPrev,
F = $.boost && !J.boostHeldPrev;
if (
((J.jumpHeldPrev = $.jump),
(J.fwdPrev = m0($.fwd, -1, 1)),
(J.slideHeldPrev = $.slide),
(J.boostHeldPrev = $.boost),
F &&
J.boostCd <= 0 &&
J.ledgePhase === 0 &&
J.vaultState === 0 &&
J.wallState === 0 &&
J.slideState === 0 &&
($.fwd > 0.5 || C8(J.vel) > k.boostMinIntentSpeed))
)
((J.boostTime = k.boostDuration), (J.boostCd = k.boostCooldown), (K.boosted = C8(J.vel)));
if (
((J.regrabTimer = Math.max(0, J.regrabTimer - Z)),
(J.wallLockT = Math.max(0, J.wallLockT - Z)),
(J.pressHit = 0),
J.ledgePhase === 1)
)
(DX(J, $, Q, Z, K, X, W, H), (J.airTime += Z), (J.landTime += Z));
else if (J.ledgePhase === 2) {
if ((G7(J, Z, K), !K.climbEnded)) ((J.airTime += Z), (J.landTime += Z));
} else if (J.vaultState > 0) f$(J, Z, K, X);
else if (J.wallState > 0) zX(J, $, Q, Z, K, X);
else if (J.slideState > 0) b$(J, $, Q, Z, K, X, q);
else oJ(J, $, Q, Z, K, X, q);
return (SX(J, $, U, Z, K), (J.time += Z), (J.tick += 1), K);
}
function h$(J) {
return { world: J, player: TX(J.spawn, J.spawnYaw) };
}
function x$(J, $) {
return jX(J.player, $, J.world, DJ);
}
function LJ(J) {
let $ = iJ(J);
return {
pos: { x: J.pos.x, y: J.pos.y, z: J.pos.z },
yaw: J.bodyYaw,
camYaw: J.yaw,
camPitch: w$(J),
camFwd: YK(J),
pitch: J.pitch,
roll: J.roll + J.bobRoll,
velY: J.vel.y,
speedSmooth: J.speedSmooth,
stridePhase: J.stridePhase,
bobFade: J.bobFade,
airFade: J.airFade,
prepFade: J.prepFade,
dip: J.dip,
lean: J.lean,
time: J.time,
ledgeFade: J.ledgeFade,
pinFade: J.pinFade,
climbPhase: J.climbPhase,
shimmyPhase: J.shimmyPhase,
grabX: $.x,
grabY: $.y,
grabZ: $.z,
ledgeNx: J.ledgeNx,
ledgeNz: J.ledgeNz,
vaultFade: J.vaultFade,
vaultPhase: J.vaultPhase,
vaultKind: J.vaultKind,
vaultHands: J.vaultHands,
vaultPlantPhase: J.vaultTEnd > 0 ? J.vaultT1 / J.vaultTEnd : 0.5,
plantX: J.plantX,
plantY: J.plantY,
plantZ: J.plantZ,
plantNx: J.plantNx,
plantNz: J.plantNz,
slideFade: J.slideFade,
slideKind: J.slideKind,
tuckFade: J.tuckFade,
boostFade: J.boostFade,
wallFade: J.wallFade,
wallSide: J.wallSide,
wallT: J.wallT,
wallNx: J.wallNx,
wallNz: J.wallNz,
wallPlane: J.wallPlane,
pressFade: J.pressFade,
inspectFade: J.inspectFade,
landFade: J.landFade,
landPrime: J.landPrime,
landPlantX: J.landPlantX,
landPlantY: J.landPlantY,
landPlantZ: J.landPlantZ,
landDirX: J.landDirX,
landDirZ: J.landDirZ,
pressNx: J.pressNx,
pressNz: J.pressNz,
pressPlane: J.pressPlane,
eyeY: J.pos.y + k.eyeHeight + J.bobY + J.dip - _$(J) - A$(J) - P$(J) - z$(J),
bobX: J.bobX,
fov: J.fov,
speed: Math.sqrt(J.vel.x * J.vel.x + J.vel.z * J.vel.z),
grounded: J.grounded,
sprintCharge: J.sprintCharge,
boostCdFrac: k.boostCooldown > 0 ? J.boostCd / k.boostCooldown : 0,
};
}
var QG = (J, $, Q) => ({ x: s(J.x, $.x, Q), y: s(J.y, $.y, Q), z: s(J.z, $.z, Q) });
function yX(J, $, Q) {
return {
pos: QG(J.pos, $.pos, Q),
yaw: $K(J.yaw, $.yaw, Q),
camYaw: $K(J.camYaw, $.camYaw, Q),
camPitch: s(J.camPitch, $.camPitch, Q),
camFwd: s(J.camFwd, $.camFwd, Q),
pitch: s(J.pitch, $.pitch, Q),
roll: s(J.roll, $.roll, Q),
velY: s(J.velY, $.velY, Q),
speedSmooth: s(J.speedSmooth, $.speedSmooth, Q),
stridePhase: s(J.stridePhase, $.stridePhase, Q),
bobFade: s(J.bobFade, $.bobFade, Q),
airFade: s(J.airFade, $.airFade, Q),
prepFade: s(J.prepFade, $.prepFade, Q),
dip: s(J.dip, $.dip, Q),
lean: s(J.lean, $.lean, Q),
time: s(J.time, $.time, Q),
ledgeFade: s(J.ledgeFade, $.ledgeFade, Q),
pinFade: s(J.pinFade, $.pinFade, Q),
climbPhase: s(J.climbPhase, $.climbPhase, Q),
shimmyPhase: s(J.shimmyPhase, $.shimmyPhase, Q),
grabX: s(J.grabX, $.grabX, Q),
grabY: s(J.grabY, $.grabY, Q),
grabZ: s(J.grabZ, $.grabZ, Q),
ledgeNx: s(J.ledgeNx, $.ledgeNx, Q),
ledgeNz: s(J.ledgeNz, $.ledgeNz, Q),
vaultFade: s(J.vaultFade, $.vaultFade, Q),
vaultPhase: $.vaultPhase >= J.vaultPhase ? s(J.vaultPhase, $.vaultPhase, Q) : Q < 0.5 ? J.vaultPhase : $.vaultPhase,
vaultKind: Q < 0.5 ? J.vaultKind : $.vaultKind,
vaultHands: Q < 0.5 ? J.vaultHands : $.vaultHands,
vaultPlantPhase: s(J.vaultPlantPhase, $.vaultPlantPhase, Q),
plantX: s(J.plantX, $.plantX, Q),
plantY: s(J.plantY, $.plantY, Q),
plantZ: s(J.plantZ, $.plantZ, Q),
plantNx: s(J.plantNx, $.plantNx, Q),
plantNz: s(J.plantNz, $.plantNz, Q),
slideFade: s(J.slideFade, $.slideFade, Q),
slideKind: Q < 0.5 ? J.slideKind : $.slideKind,
tuckFade: s(J.tuckFade, $.tuckFade, Q),
boostFade: s(J.boostFade, $.boostFade, Q),
wallFade: s(J.wallFade, $.wallFade, Q),
wallSide: Q < 0.5 ? J.wallSide : $.wallSide,
wallT: s(J.wallT, $.wallT, Q),
wallNx: Q < 0.5 ? J.wallNx : $.wallNx,
wallNz: Q < 0.5 ? J.wallNz : $.wallNz,
wallPlane: Q < 0.5 ? J.wallPlane : $.wallPlane,
pressFade: s(J.pressFade, $.pressFade, Q),
inspectFade: s(J.inspectFade, $.inspectFade, Q),
landFade: s(J.landFade, $.landFade, Q),
landPrime: s(J.landPrime, $.landPrime, Q),
landPlantX: Q < 0.5 ? J.landPlantX : $.landPlantX,
landPlantY: Q < 0.5 ? J.landPlantY : $.landPlantY,
landPlantZ: Q < 0.5 ? J.landPlantZ : $.landPlantZ,
landDirX: Q < 0.5 ? J.landDirX : $.landDirX,
landDirZ: Q < 0.5 ? J.landDirZ : $.landDirZ,
pressNx: Q < 0.5 ? J.pressNx : $.pressNx,
pressNz: Q < 0.5 ? J.pressNz : $.pressNz,
pressPlane: Q < 0.5 ? J.pressPlane : $.pressPlane,
eyeY: s(J.eyeY, $.eyeY, Q),
bobX: s(J.bobX, $.bobX, Q),
fov: s(J.fov, $.fov, Q),
speed: s(J.speed, $.speed, Q),
grounded: Q < 0.5 ? J.grounded : $.grounded,
sprintCharge: s(J.sprintCharge, $.sprintCharge, Q),
boostCdFrac: s(J.boostCdFrac, $.boostCdFrac, Q),
};
}
class qK {
dt;
maxFrame;
acc = 0;
constructor(J = DJ, $ = 0.25) {
this.dt = J;
this.maxFrame = $;
}
advance(J, $) {
this.acc += Math.min(Math.max(J, 0), this.maxFrame);
let Q = 0;
while (this.acc >= this.dt) ($(), (this.acc -= this.dt), Q++);
return Q;
}
get alpha() {
return this.acc / this.dt;
}
}
function ZG(J, $) {
let Q = Math.round($ / DJ),
Z = Array(Q),
K = L$(),
Y = [];
for (let H of J) {
if (H.press === "jump") (Y.push({ at: H.at, set: { jump: !0 } }), Y.push({ at: H.at + 0.05, set: { jump: !1 } }));
if (H.press === "boost")
(Y.push({ at: H.at, set: { boost: !0 } }), Y.push({ at: H.at + 0.05, set: { boost: !1 } }));
if (H.set || H.look) Y.push(H);
}
Y.sort((H, q) => H.at - q.at);
let U = new Float64Array(Q),
X = new Float64Array(Q);
for (let H of Y) {
if (!H.look) continue;
let q = Math.max(0, Math.round(H.at / DJ)),
F = Math.min(Q, Math.max(q + 1, Math.round((H.at + H.look.over) / DJ))),
N = F - q;
for (let O = q; O < F; O++)
((U[O] += ((H.look.dyawDeg ?? 0) * j) / N), (X[O] += ((H.look.dpitchDeg ?? 0) * j) / N));
}
let W = 0;
for (let H = 0; H < Q; H++) {
let q = H * DJ;
while (W < Y.length && Y[W].at <= q + 0.000000001) {
let N = Y[W].set;
if (N) Object.assign(K, N);
W++;
}
let F = nU(K);
((F.dyaw = U[H]), (F.dpitch = X[H]), (Z[H] = F));
}
return Z;
}
var KG = [
"tick",
"t",
"px",
"py",
"pz",
"vx",
"vy",
"vz",
"speed",
"grounded",
"yaw",
"pitch",
"eyeY",
"bobY",
"bobX",
"roll",
"fov",
"dip",
"stridePhase",
"sprintCharge",
"bobFade",
"airFade",
"lean",
"ledge",
"ledgeFade",
"pinFade",
"climbPhase",
"grabX",
"grabY",
"grabZ",
"shimmyVel",
"shimmyPhase",
"vault",
"vaultFade",
"vaultPhase",
"vaultHands",
"vaultPP",
"plantX",
"plantY",
"plantZ",
"slide",
"slideFade",
"slideKind",
"boost",
"boostCd",
"boostFade",
"wall",
"wallFade",
"wallSide",
"wallNx",
"wallNz",
"wallPlane",
"wallTop",
"tuck",
"tuckFade",
"pressFade",
"inspectFade",
"land",
"landFade",
"landPrime",
];
function YG(J) {
let $ = XK(J),
Q = iJ(J);
return {
tick: J.tick,
t: J.time,
px: J.pos.x,
py: J.pos.y,
pz: J.pos.z,
vx: J.vel.x,
vy: J.vel.y,
vz: J.vel.z,
speed: Math.sqrt(J.vel.x * J.vel.x + J.vel.z * J.vel.z),
grounded: J.grounded ? 1 : 0,
yaw: J.yaw,
pitch: J.pitch,
eyeY: $.eyeY,
bobY: J.bobY,
bobX: J.bobX,
roll: $.roll,
fov: $.fov,
dip: J.dip,
stridePhase: J.stridePhase,
sprintCharge: J.sprintCharge,
bobFade: J.bobFade,
airFade: J.airFade,
lean: J.lean,
ledge: J.ledgePhase,
ledgeFade: J.ledgeFade,
pinFade: J.pinFade,
climbPhase: J.climbPhase,
grabX: Q.x,
grabY: Q.y,
grabZ: Q.z,
shimmyVel: J.shimmyVel,
shimmyPhase: J.shimmyPhase,
vault: J.vaultState,
vaultFade: J.vaultFade,
vaultPhase: J.vaultPhase,
vaultHands: J.vaultHands,
vaultPP: J.vaultTEnd > 0 ? J.vaultT1 / J.vaultTEnd : 0.5,
plantX: J.plantX,
plantY: J.plantY,
plantZ: J.plantZ,
slide: J.slideState,
slideFade: J.slideFade,
slideKind: J.slideKind,
boost: J.boostTime > 0 ? 1 : 0,
boostCd: J.boostCd,
boostFade: J.boostFade,
wall: J.wallState,
wallFade: J.wallFade,
wallSide: J.wallSide,
wallNx: J.wallNx,
wallNz: J.wallNz,
wallPlane: J.wallPlane,
wallTop: J.wallTopY,
tuck: J.tuckState,
tuckFade: J.tuckFade,
pressFade: J.pressFade,
inspectFade: J.inspectFade,
land: J.landState,
landFade: J.landFade,
landPrime: J.landPrime,
};
}
function UG(J, $, Q) {
if ($.jumped) J.push({ tick: Q.tick, t: Q.time, type: "jumped" });
if ($.landed !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "landed", value: $.landed });
if ($.footstep) J.push({ tick: Q.tick, t: Q.time, type: "footstep", side: $.footstep });
if ($.headBump) J.push({ tick: Q.tick, t: Q.time, type: "headBump" });
if ($.grabbed !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "grabbed", value: $.grabbed });
if ($.climbStarted) J.push({ tick: Q.tick, t: Q.time, type: "climbStarted" });
if ($.climbEnded) J.push({ tick: Q.tick, t: Q.time, type: "climbEnded" });
if ($.dropped) J.push({ tick: Q.tick, t: Q.time, type: "dropped" });
if ($.vaulted !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "vaulted", value: $.vaulted, kind: Q.vaultKind });
if ($.vaultEnded) J.push({ tick: Q.tick, t: Q.time, type: "vaultEnded" });
if ($.slideStarted !== void 0)
J.push({ tick: Q.tick, t: Q.time, type: "slideStarted", value: $.slideStarted, kind: Q.slideState });
if ($.slideEnded) J.push({ tick: Q.tick, t: Q.time, type: "slideEnded" });
if ($.boosted !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "boosted", value: $.boosted });
if ($.boostEnded) J.push({ tick: Q.tick, t: Q.time, type: "boostEnded" });
if ($.wallStarted !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "wallStarted", value: $.wallStarted });
if ($.wallEnded) J.push({ tick: Q.tick, t: Q.time, type: "wallEnded" });
if ($.wallJumped !== void 0) J.push({ tick: Q.tick, t: Q.time, type: "wallJumped", value: $.wallJumped });
if ($.hardLanded) J.push({ tick: Q.tick, t: Q.time, type: "hardLanded" });
}
function XG(J, $, Q) {
let Z = [],
K = [],
Y = Q.collectPose ? [] : void 0;
for (let U of $) {
let X = x$(J, U),
W = J.player;
if ((Z.push(YG(W)), UG(K, X, W), Y)) Y.push(C$(LJ(W)));
}
return { samples: Z, events: K, poses: Y, world: J.world };
}
function fX(J, $, Q, Z = {}) {
let K = h$(J);
if (Z.spawn) K.player.pos = { ...Z.spawn };
if (Z.spawnYaw !== void 0) K.player.yaw = Z.spawnYaw;
return XG(K, ZG($, Q), Z);
}
function vX(J) {
let $ = -2128831035,
Q = -873292572,
Z = new ArrayBuffer(8),
K = new Float64Array(Z),
Y = new Uint8Array(Z);
for (let U of J.samples)
for (let X of KG) {
K[0] = U[X];
for (let W = 0; W < 8; W++) (($ = (($ ^ Y[W]) * 16777619) | 0), (Q = ((Q ^ Y[W]) * 16777623) | 0));
}
return ($ >>> 0).toString(16).padStart(8, "0") + (Q >>> 0).toString(16).padStart(8, "0");
}
export {
k as CFG,
DJ as DT,
L$ as blankInput,
N0 as vec3,
h$ as createGame,
x$ as stepGame,
jX as stepPlayer,
TX as createPlayer,
LJ as snapshot,
yX as lerpSnapshot,
qK as FixedStep,
UK as timeScale,
ZG as compileScript,
fX as runScript,
vX as hashRun,
C$ as bodyPose,
KX as handPose,
D8 as BODY,
h0 as groundBox,
YX as floatBox,
C9 as ramp,
g6 as floorBox,
HK as playgroundWorld,
FX as flatWorld,
OX as obstacleWorld,
WX as clingWorld,
NX as vaultWorld,
qX as rampWorld,
XX as wallWorld,
HX as wallChainWorld,
GX as pressWorld,
UX as dropWorld,
};
// Deterministic 120 Hz movement core, body pose solver, test worlds. Pure JS — no DOM, no three.js.
// Extracted verbatim from the published EDGERUNNERS build (index-1sq5vsxc.js),
// plus the patches documented in tools/core-patches.mjs: wallJumpGrace.
// Generated by tools/extract-core.mjs — do not edit by hand.
var DJ = 0.008333333333333333,
k = {
height: 1.78,
radius: 0.35,
eyeHeight: 1.62,
maxPitchDeg: 89,
runBaseSpeed: 5,
sprintMaxSpeed: 7.4,
sprintChargeTime: 1.8,
sprintChargeDecay: 0.45,
sprintChargeMinSpeed: 4,
strafeSpeed: 4.6,
backSpeed: 3.6,
groundAccelK: 9,
frictionK: 14,
stopEpsilon: 0.02,
gravityRise: 16,
gravityFall: 25.6,
terminalFall: 55,
jumpSpeed: 6.3,
airAccel: 8,
airSpeedCap: 7.4,
coyoteTime: 0.12,
jumpBufferTime: 0.12,
jumpCutFactor: 0.65,
jumpCutMinRise: 2,
jumpCutWindow: 0.3,
maxSubstepTravel: 0.15,
contactEpsilon: 0.0001,
slopeWalkMaxDeg: 46,
slopeUpTax: 0.45,
slopeUpFloor: 0.55,
slopeDownGain: 0.3,
slopeDownCap: 1.2,
slideSlopeG: 12.4,
fovBaseDeg: 72,
fovSprintKickDeg: 9,
fovKickStartSpeed: 3,
fovSmoothK: 6,
bobStepFreqBase: 1.35,
bobStepFreqPerMs: 0.21,
bobAmpVBase: 0.014,
bobAmpVPerMs: 0.0048,
bobAmpLFactor: 0.6,
bobRollDeg: 0.5,
bobFadeInK: 10,
bobFadeOutK: 6,
bobFadeAirK: 14,
moveMinSpeed: 0.3,
strafeRollDeg: 1.4,
turnRollFactor: 0.045,
turnRollMaxDeg: 2.2,
rollMaxDeg: 3,
rollSmoothK: 10,
dipOmega: 18,
dipZeta: 0.62,
dipImpulseScale: 0.5,
dipMaxImpulse: 4.8,
landMinImpact: 2.5,
leanMaxDeg: 8,
leanSmoothK: 4,
speedSmoothK: 12,
grabWindowLo: 1.2,
grabWindowHi: 2.35,
grabMaxRise: 3,
grabReach: 0.3,
grabFacingMaxDeg: 70,
grabMaxAway: 0.5,
hangDrop: 2.1,
hangGap: 0.02,
catchOmega: 16,
catchZeta: 1,
grabDipScale: 0.35,
shimmySpeed: 0.85,
shimmyK: 10,
shimmyEndMargin: 0.3,
shimmyStepLen: 0.55,
regripMinTime: 0.15,
climbUpTime: 0.55,
climbOverTime: 0.3,
climbHop: 0.08,
climbEndInset: 0.25,
climbExitSpeed: 1.2,
climbSettleImpulse: 1.2,
dropPush: 0.4,
dropRegrabCooldown: 0.3,
ledgeFadeInK: 10,
ledgeFadeOutK: 8,
handHalfSpan: 0.2,
handLift: 0.025,
handInset: -0.005,
vaultWindowLo: 0.35,
vaultWindowHi: 2.2,
vaultCrossMaxRel: 1.05,
vaultMaxDepth: 1.6,
vaultDetectDist: 2,