Files
web/src/lib/pages/bionyx/RankRadar.svelte

512 lines
22 KiB
Svelte
Raw Normal View History

2026-11-03 04:34:38 +03:00
<script>
2026-11-03 15:13:24 +03:00
import { onMount, onDestroy } from 'svelte';
2026-11-03 04:34:38 +03:00
// Радар навыков сообщества.
// 6 осей в 3 делениях по соседству: MIND / BODY / KNOWLEDGE.
// Имена осей — ВОДЯНЫЕ ЗНАКИ в полосе между кольцами R_AXIS и R_ARC:
// искривлённый текст (textPath), кегль подобран так, что капительная высота
// равна ширине полосы. Верхние оси: базовая на ВНУТРЕННЕМ кольце, буквы растут
// наружу; нижние: базовая на ВНЕШНЕМ кольце, буквы растут к центру.
// Трекинг дозируется на СКРЫТОМ СРЕДНЕМ РАДИУСЕ RC: там меряем/решаем
// (влезание в сектор, лимит растяжки), затем textLength проецируется на
2026-11-03 15:13:24 +03:00
// базовый радиус оси (tl = P * rBase / RC).
2026-11-03 04:34:38 +03:00
// Слой знаков обрезан маской-кольцом: за R_ARC и внутрь сетки ничего не течёт.
// Названия делений вынесены ЗА внешнее кольцо (верх и низ одинаково снаружи).
2026-11-03 15:13:24 +03:00
// Свечение делений — СЕКТОРЫ от кольца осей: максимум на R_AXIS, гаснет наружу
// и свободно выходит за R_ARC; маска жёстко срезает его по R_AXIS,
// внутрь сетки не попадает ничего (даже размывание).
// Индекс = геометрическое среднее делений: ноль в любом делении обнуляет всё.
2026-11-03 04:34:38 +03:00
const GROUPS = [
{ name: 'MIND', color: '#3ee0ff', axes: ['WILL', 'FLEX'] },
{ name: 'BODY', color: '#ffc65c', axes: ['GRIT', 'PWR'] },
{ name: 'KNOWLEDGE', color: '#e05cff', axes: ['DEPTH', 'SCOPE'] },
];
// углы осей в градусах (0 = вправо, 90 = вниз, экранная система)
const ANGLES = [180, 240, 300, 0, 60, 120];
// дуги делений: верхние идут по часовой (текст вершиной наружу),
// нижняя — против (текст читается нормально, вершиной к центру)
const ARCS = [
{ name: 'MIND', from: 150, to: 270, sweep: 1 },
{ name: 'BODY', from: 270, to: 30, sweep: 1 },
{ name: 'KNOWLEDGE', from: 150, to: 30, sweep: 0 },
];
// границы делений — между парами осей
const BOUNDS = [30, 150, 270];
const RANKS = [
{ min: 92, grade: 'S+' },
{ min: 80, grade: 'S' },
{ min: 65, grade: 'A' },
{ min: 50, grade: 'B' },
{ min: 35, grade: 'C' },
{ min: 20, grade: 'D' },
{ min: 0, grade: 'E' },
];
const RANK_COLORS = {
'S+': '#ffd76a',
'S': '#ffcb6b',
'A': '#4ff0b7',
'B': '#6bd4ff',
'C': '#a7b8b5',
'D': '#77837f',
'E': '#5b6663',
};
2026-11-03 15:13:24 +03:00
// порядок «прокачки»: по нему строится полоса делений под буквой ранга
const GRADE_ORDER = ['E', 'D', 'C', 'B', 'A', 'S', 'S+'];
2026-11-03 04:34:38 +03:00
const AXES = GROUPS.flatMap((g) => g.axes);
2026-11-03 15:13:24 +03:00
// ── витрина профилей ──
// Слайды сменяются раз в SLIDE_MS. Сначала проходятся все шаблоны ранга E,
// затем D, C, B, A, S и наконец S+ — постепенно видно, как выглядит прокачка.
// Значения в порядке осей: WILL, FLEX, GRIT, PWR, DEPTH, SCOPE.
const SHOWCASE = [
[4, 16, 30, 29, 29, 18], // E
[2, 19, 16, 29, 33, 24], // E
[13, 17, 16, 22, 24, 65], // D
[13, 17, 44, 26, 77, 19], // D
[26, 17, 61, 62, 58, 32], // C
[41, 35, 44, 26, 77, 19], // C
[41, 35, 44, 26, 77, 57], // C
[32, 35, 68, 54, 42, 57], // C
[41, 60, 41, 62, 69, 68], // B
[75, 35, 44, 26, 77, 57], // B
[76, 73, 86, 76, 89, 57], // A
[91, 79, 92, 76, 88, 94], // S
[100, 92, 92, 79, 92, 94], // S+
];
const SLIDE_MS = 5000;
const MORPH_MS = 900;
2026-11-03 04:34:38 +03:00
const cx = 200;
const cy = 165;
const R = 84; // радиус самой сетки
const R_AXIS = 102; // внутреннее кольцо (граница полосы знаков)
const R_ARC = 130; // внешнее кольцо (вторая граница полосы)
const BAND = R_ARC - R_AXIS; // ширина полосы под ватермарки
const RC = (R_AXIS + R_ARC) / 2; // скрытый средний радиус: пространство дозировки
const WM_FONT = Math.round(BAND / 0.72); // кегль: капитель = ширине полосы
const SECTOR_RAD = (60 * Math.PI) / 180; // угловая ширина сектора оси
const WM_PAD = 5; // отступ слова от краёв сектора (в px на радиусе RC)
const MAX_TRACK = 3; // лимит растяжки: максимум +N px на межбуквенный зазор (на RC)
const ARC_GAP = 4; // зазор между внешним кольцом и текстом домена
2026-11-03 15:13:24 +03:00
// свечение: стартует на кольце осей и гаснет к внешнему краю (и за него)
2026-11-03 04:34:38 +03:00
const GLOW_IN = R_AXIS;
const GLOW_OUT = R_ARC + 26;
const GLOW_MID = GLOW_IN + (GLOW_OUT - GLOW_IN) * 0.45;
const rings = [0.25, 0.5, 0.75, 1];
const num = (v) => Number(v) || 0;
2026-11-03 15:13:24 +03:00
const clamp = (v) => Math.min(100, Math.max(0, v));
2026-11-03 04:34:38 +03:00
const rad = (deg) => (deg * Math.PI) / 180;
function polar(deg, r) {
return [cx + r * Math.cos(rad(deg)), cy + r * Math.sin(rad(deg))];
}
function arcPath(from, to, r, sweep) {
const [x0, y0] = polar(from, r);
const [x1, y1] = polar(to, r);
return `M ${x0.toFixed(2)} ${y0.toFixed(2)} A ${r} ${r} 0 0 ${sweep} ${x1.toFixed(2)} ${y1.toFixed(2)}`;
}
// клин сектора: кольцо между r0 и r1 в угловом диапазоне from..to
function sectorPath(from, to, r0, r1, sweep) {
const [ax, ay] = polar(from, r0);
const [bx, by] = polar(to, r0);
const [ex, ey] = polar(to, r1);
const [fx, fy] = polar(from, r1);
const back = sweep === 1 ? 0 : 1;
return (
`M ${ax.toFixed(2)} ${ay.toFixed(2)} ` +
`A ${r0} ${r0} 0 0 ${sweep} ${bx.toFixed(2)} ${by.toFixed(2)} ` +
`L ${ex.toFixed(2)} ${ey.toFixed(2)} ` +
`A ${r1} ${r1} 0 0 ${back} ${fx.toFixed(2)} ${fy.toFixed(2)} Z`
);
}
// «верхняя» половина с допуском: sin(180°) = +1.22e-16, а не 0,
// без допуска WLL считался бы нижним и переворачивался внутрь.
const isUpper = (a) => Math.sin(rad(a)) <= 1e-9;
// дуги-линии осей: каждая ось занимает сектор ±30°, вместе дают внутр. кольцо
const AXIS_ARCS = AXES.map((name, i) => {
const a = ANGLES[i];
const upper = isUpper(a);
return {
name,
from: upper ? a - 30 : a + 30,
to: upper ? a + 30 : a - 30,
sweep: upper ? 1 : 0,
};
});
// ватермарки осей: искривлённый текст по дуге своей оси.
// верх/бока: базовая на R_AXIS, буквы растут наружу (в полосу);
// низ: базовая на R_ARC, буквы растут к центру (тоже в полосу).
// rBase нужен только для проекции textLength из пространства RC.
const AXIS_WM = AXES.map((name, i) => {
const a = ANGLES[i];
const upper = isUpper(a);
return {
name,
gi: Math.floor(i / 2),
from: upper ? a - 30 : a + 30,
to: upper ? a + 30 : a - 30,
sweep: upper ? 1 : 0,
rBase: upper ? R_AXIS : R_ARC,
};
});
// направляющие для текстов доменов: тело букв целиком ЗА внешним кольцом.
const ARC_TEXTS = ARCS.map((arc, i) => {
const upper = arc.sweep === 1;
const r = upper ? R_ARC + ARC_GAP : R_ARC + ARC_GAP + 11;
return { ...arc, r, i };
});
function ringPoints(k) {
return ANGLES.map((deg) => polar(deg, R * k).join(',')).join(' ');
}
2026-11-03 15:13:24 +03:00
// ── спицы и границы делений ОДНИМ путём каждая ──
// В path координаты зашиты в команду M/L, атрибутов x1/y1/cy нет совсем —
// опечатка в имени координатного атрибута (та самая «пирамида») невозможна.
const SPOKES = ANGLES.map((deg) => {
const [x, y] = polar(deg, R);
return `M ${cx} ${cy} L ${x.toFixed(2)} ${y.toFixed(2)}`;
}).join(' ');
const BOUND_LINES = BOUNDS.map((deg) => {
const [x, y] = polar(deg, R_AXIS - 14);
return `M ${cx} ${cy} L ${x.toFixed(2)} ${y.toFixed(2)}`;
}).join(' ');
2026-11-03 04:34:38 +03:00
// ── дозировка трекинга ватермарок (замер + нормализация к RC) ──
// null → атрибут не ставим (natural); число → принудительная длина по дуге.
let tl = $state(/** @type {Array<number | null>} */ (AXES.map(() => null)));
let wmTexts = $state(/** @type {Array<SVGTextElement | null>} */ ([]));
$effect(() => {
AXES.join('|'); // перезамер, если имена осей когда-нибудь поменяются
wmTexts.forEach((el, i) => {
if (!el) return;
// меряем natural-ширину: на время снимаем принудительную длину
const had = el.getAttribute('textLength');
if (had !== null) el.removeAttribute('textLength');
const natural = el.getComputedTextLength();
if (had !== null) el.setAttribute('textLength', had);
if (!natural) return; // шрифт ещё не готов — попробуем в следующий проход
const rBase = AXIS_WM[i].rBase;
const n = AXES[i].length;
// сколько места есть в секторе в пересчёте на зрительный радиус RC
const availRc = SECTOR_RAD * RC - WM_PAD;
2026-11-03 15:13:24 +03:00
// как слово смотрится на RC без вмешательства:
2026-11-03 04:34:38 +03:00
// тот же линейный аванс на чужом базовом радиусе даёт другой угловой шаг
const perceivedNat = (natural * RC) / rBase;
// целевая зрительная длина на RC: не длиннее сектора и не рыхлее лимита
let targetRc = Math.min(availRc, natural + MAX_TRACK * (n - 1));
if (perceivedNat > availRc) targetRc = availRc; // слово не влезает → сжимаем
// проекция цели обратно на базовый радиус этой оси
const tlVal = (targetRc * rBase) / RC;
const val = Math.abs(tlVal - natural) <= 0.5 ? null : tlVal;
if (val !== tl[i]) tl[i] = val;
});
});
2026-11-03 15:13:24 +03:00
// ── витрина: текущий слайд, морфинг полигона, ранг считаем от цели ──
let slide = $state(0);
let values = $state(SHOWCASE[0].slice()); // то, что сейчас на радаре (дробное во время морфинга)
const target = $derived(SHOWCASE[slide]); // целевой профиль слайда
let raf = 0;
let timer = 0;
const reduced = () =>
typeof matchMedia !== 'undefined' && matchMedia('(prefers-reduced-motion: reduce)').matches;
function goTo(next) {
slide = next;
const from = values.slice();
const to = SHOWCASE[next];
cancelAnimationFrame(raf);
if (reduced()) {
values = to.slice(); // без анимации — просто переключаем
return;
}
const t0 = performance.now();
const step = (now) => {
const t = Math.min(1, (now - t0) / MORPH_MS);
const e = t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
for (let i = 0; i < values.length; i++) {
values[i] = clamp(from[i] + (to[i] - from[i]) * e);
}
if (t < 1) raf = requestAnimationFrame(step);
};
raf = requestAnimationFrame(step);
}
onMount(() => {
timer = setInterval(() => goTo((slide + 1) % SHOWCASE.length), SLIDE_MS);
});
onDestroy(() => {
clearInterval(timer);
cancelAnimationFrame(raf);
});
2026-11-03 04:34:38 +03:00
const valuePoints = $derived(
ANGLES.map((deg, i) => polar(deg, (R * num(values[i])) / 100).join(',')).join(' ')
);
2026-11-03 15:13:24 +03:00
// среднее по каждому делению — от ЦЕЛЕВОГО профиля, чтобы буква и индекс
// не мигали посреди морфинга
2026-11-03 04:34:38 +03:00
const groupMeans = $derived(
2026-11-03 15:13:24 +03:00
GROUPS.map((_, gi) => Math.round((num(target[gi * 2]) + num(target[gi * 2 + 1])) / 2))
2026-11-03 04:34:38 +03:00
);
// геометрическое среднее делений: провал в одном делении тянет весь индекс
const index = $derived(Math.round(Math.cbrt(groupMeans[0] * groupMeans[1] * groupMeans[2])));
const rank = $derived(RANKS.find((r) => index >= r.min)?.grade ?? 'E');
const rankColor = $derived(RANK_COLORS[rank] ?? '#4ff0b7');
</script>
<div class="rank">
2026-11-03 15:13:24 +03:00
<div class="rank-head">
<h3 class="rank-title">Ранг система</h3>
2026-11-03 15:13:24 +03:00
<div class="rank-side">
<span class="rank-kicker">Ранг</span>
{#key rank}
<span class="rank-grade" style:color={rankColor}>{rank}</span>
{/key}
<!-- полоса прокачки: деления E → S+, текущее светится -->
<div class="rank-track" aria-hidden="true">
{#each GRADE_ORDER as g}
<span class="tick" class:on={g === rank}></span>
2026-11-03 04:34:38 +03:00
{/each}
2026-11-03 15:13:24 +03:00
</div>
<span class="rank-avg">индекс {index}/100</span>
</div>
</div>
<svg class="radar" viewBox="0 0 400 330" aria-hidden="true">
<defs>
<!-- blur только для мягких угловых стыков секторов -->
<filter id="bx-glow" x="-30%" y="-30%" width="160%" height="160%">
<feGaussianBlur stdDeviation="5" />
</filter>
<!-- градиент свечения: максимум на кольце осей, ноль на внешнем крае -->
{#each GROUPS as g, i}
<radialGradient
id="bx-glow-grad-{i}"
gradientUnits="userSpaceOnUse"
cx={cx}
cy={cy}
r={GLOW_OUT}
>
<stop offset={GLOW_IN / GLOW_OUT} stop-color={g.color} stop-opacity="0.3" />
<stop offset={GLOW_MID / GLOW_OUT} stop-color={g.color} stop-opacity="0.12" />
<stop offset="1" stop-color={g.color} stop-opacity="0" />
</radialGradient>
2026-11-03 04:34:38 +03:00
{/each}
2026-11-03 15:13:24 +03:00
<!-- жёсткий срез: внутрь кольца осей свечение не заходит совсем -->
<mask id="bx-glow-mask" x="-20%" y="-20%" width="140%" height="140%">
<rect x="0" y="0" width="400" height="330" fill="#fff" />
<circle cx={cx} cy={cy} r={R_AXIS - 0.5} fill="#000" />
</mask>
<!-- кольцо-маска для ватермарок: видно только между R_AXIS и R_ARC -->
<mask id="bx-band-mask">
<circle cx={cx} cy={cy} r={R_ARC} fill="#fff" />
<circle cx={cx} cy={cy} r={R_AXIS} fill="#000" />
</mask>
</defs>
<!-- свечение делений: исходит ОТ кольца осей (R_AXIS), гаснет наружу и
свободно выходит за внешнее кольцо; маска режет всё внутрь R_AXIS -->
<g mask="url(#bx-glow-mask)">
{#each ARCS as arc, i}
2026-11-03 04:34:38 +03:00
<path
2026-11-03 15:13:24 +03:00
d={sectorPath(arc.from, arc.to, GLOW_IN, GLOW_OUT, arc.sweep)}
fill="url(#bx-glow-grad-{i})"
filter="url(#bx-glow)"
2026-11-03 04:34:38 +03:00
/>
{/each}
2026-11-03 15:13:24 +03:00
</g>
<!-- сетка -->
{#each rings as k, ki}
<polygon
points={ringPoints(k)}
fill={ki === rings.length - 1 ? 'rgba(255,255,255,0.015)' : 'none'}
stroke={ki === rings.length - 1 ? 'var(--line-2)' : 'var(--line)'}
stroke-width="1"
/>
{/each}
<!-- границы делений: один путь, координаты в командах M/L -->
<path
d={BOUND_LINES}
fill="none"
stroke="var(--line)"
stroke-width="1"
stroke-dasharray="2 5"
opacity="0.7"
/>
<!-- оси: один путь-спицы, координаты в командах M/L -->
<path d={SPOKES} fill="none" stroke="var(--line)" stroke-width="1" />
<!-- внутреннее кольцо: цветные дуги осей -->
{#each AXIS_ARCS as ax, i}
{@const gi = Math.floor(i / 2)}
<path
d={arcPath(ax.from, ax.to, R_AXIS, ax.sweep)}
fill="none"
stroke={GROUPS[gi].color}
stroke-width="1"
opacity="0.35"
/>
{/each}
<!-- направляющие дуги ватермарков (невидимые) -->
{#each AXIS_WM as w, i}
<path
id="bx-wm-{i}"
d={arcPath(w.from, w.to, w.rBase, w.sweep)}
fill="none"
stroke="none"
/>
{/each}
<!-- ватермарки осей: толстые полупрозрачные буквы, искривлённые по дуге;
textLength дозируется замером на среднем радиусе RC (см. $effect);
маска срезает всё, что вылезает за пределы полосы между кольцами -->
<g mask="url(#bx-band-mask)">
2026-11-03 04:34:38 +03:00
{#each AXIS_WM as w, i}
2026-11-03 15:13:24 +03:00
<text class="wm-label" fill={GROUPS[w.gi].color} bind:this={wmTexts[i]}>
<textPath
href="#bx-wm-{i}"
startOffset="50%"
text-anchor="middle"
textLength={tl[i]}
lengthAdjust="spacing"
>
{w.name}
2026-11-03 04:34:38 +03:00
</textPath>
</text>
{/each}
2026-11-03 15:13:24 +03:00
</g>
<!-- внешнее кольцо + названия делений (тело букв за кольцом) -->
{#each ARC_TEXTS as arc, i}
<path
d={arcPath(arc.from, arc.to, R_ARC, arc.sweep)}
fill="none"
stroke={GROUPS[i].color}
stroke-width="1"
opacity="0.5"
2026-11-03 04:34:38 +03:00
/>
2026-11-03 15:13:24 +03:00
<path
id="bx-arc-text-{i}"
d={arcPath(arc.from, arc.to, arc.r, arc.sweep)}
fill="none"
stroke="none"
/>
<text class="arc-label" fill={GROUPS[i].color}>
<textPath href="#bx-arc-text-{i}" startOffset="50%" text-anchor="middle">
{arc.name}
</textPath>
</text>
2026-11-03 04:34:38 +03:00
{/each}
2026-11-03 15:13:24 +03:00
<!-- значения -->
<polygon
points={valuePoints}
fill="rgba(79,240,183,0.16)"
stroke="var(--acc)"
stroke-width="1.5"
stroke-linejoin="round"
/>
{#each ANGLES as deg, i}
{@const [x, y] = polar(deg, (R * num(values[i])) / 100)}
<circle cx={x} cy={y} r="2.5" fill="var(--acc)" />
{/each}
</svg>
2026-11-03 04:34:38 +03:00
</div>
<style>
/* ватермарки осей: толстые, полупрозрачные, искривлённые по дуге своей оси.
Кегль считается из ширины полосы (WM_FONT), так что по высоте
буквы встают ровно между кольцами; трекинг дозируется из скрипта
в пространстве среднего радиуса RC — зрительно одинаково на всех осях. */
.wm-label {
font-size: 38px;
font-weight: 800;
letter-spacing: 1px;
opacity: 0.2;
text-anchor: middle;
}
.arc-label {
font-size: 14px;
letter-spacing: 3px;
opacity: 0.9;
}
2026-11-03 15:13:24 +03:00
/* без собственной рамки: блок живёт прямо в теле карточки */
2026-11-03 04:34:38 +03:00
.rank {
display: flex;
flex-direction: column;
2026-11-03 15:13:24 +03:00
gap: 16px;
min-width: 0;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
.rank-head {
2026-11-03 04:34:38 +03:00
display: flex;
align-items: center;
2026-11-03 15:13:24 +03:00
gap: 18px;
2026-11-03 04:34:38 +03:00
}
.rank-title {
2026-11-03 04:34:38 +03:00
flex: 1;
min-width: 0;
2026-11-03 15:13:24 +03:00
margin: 0;
font-size: clamp(20px, 2.6vw, 26px);
font-weight: 800;
letter-spacing: 0.12em;
text-transform: uppercase;
color: var(--dim); /* сероватый, как просил */
2026-11-03 04:34:38 +03:00
}
.rank-side {
flex-shrink: 0;
display: flex;
flex-direction: column;
align-items: center;
2026-11-03 15:13:24 +03:00
gap: 3px;
min-width: 104px;
2026-11-03 04:34:38 +03:00
}
.rank-kicker {
font-family: var(--mono);
font-size: 10px;
letter-spacing: 0.2em;
text-transform: uppercase;
color: var(--dim);
}
.rank-grade {
font-family: var(--mono);
2026-11-03 15:13:24 +03:00
font-size: 44px;
2026-11-03 04:34:38 +03:00
font-weight: 800;
line-height: 1.05;
letter-spacing: 0.02em;
filter: drop-shadow(0 0 12px);
2026-11-03 15:13:24 +03:00
animation: grade-in 0.45s ease;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
@keyframes grade-in {
from {
opacity: 0;
transform: translateY(5px) scale(0.94);
}
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
/* полоса прокачки: серые деления, текущее светится */
.rank-track {
2026-11-03 04:34:38 +03:00
display: flex;
2026-11-03 15:13:24 +03:00
gap: 5px;
margin-top: 3px;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
.tick {
width: 14px;
height: 4px;
border-radius: 999px;
background: rgba(255, 255, 255, 0.12);
transition: background 0.3s ease, box-shadow 0.3s ease;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
.tick.on {
background: var(--acc);
box-shadow: 0 0 8px rgba(79, 240, 183, 0.8);
}
.rank-avg {
2026-11-03 04:34:38 +03:00
font-family: var(--mono);
font-size: 11px;
color: var(--dim);
}
2026-11-03 15:13:24 +03:00
.radar {
display: block;
2026-11-03 04:34:38 +03:00
width: 100%;
2026-11-03 15:13:24 +03:00
max-width: 460px;
margin: 0 auto;
height: auto;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
@media (max-width: 560px) {
.rank-head {
2026-11-03 04:34:38 +03:00
flex-direction: column;
2026-11-03 15:13:24 +03:00
align-items: stretch;
gap: 12px;
2026-11-03 04:34:38 +03:00
}
2026-11-03 15:13:24 +03:00
.rank-side {
align-self: center;
2026-11-03 04:34:38 +03:00
}
}
</style>