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

512 lines
22 KiB
Svelte
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<script>
import { onMount, onDestroy } from 'svelte';
// Радар навыков сообщества.
// 6 осей в 3 делениях по соседству: MIND / BODY / KNOWLEDGE.
// Имена осей — ВОДЯНЫЕ ЗНАКИ в полосе между кольцами R_AXIS и R_ARC:
// искривлённый текст (textPath), кегль подобран так, что капительная высота
// равна ширине полосы. Верхние оси: базовая на ВНУТРЕННЕМ кольце, буквы растут
// наружу; нижние: базовая на ВНЕШНЕМ кольце, буквы растут к центру.
// Трекинг дозируется на СКРЫТОМ СРЕДНЕМ РАДИУСЕ RC: там меряем/решаем
// (влезание в сектор, лимит растяжки), затем textLength проецируется на
// базовый радиус оси (tl = P * rBase / RC).
// Слой знаков обрезан маской-кольцом: за R_ARC и внутрь сетки ничего не течёт.
// Названия делений вынесены ЗА внешнее кольцо (верх и низ одинаково снаружи).
// Свечение делений — СЕКТОРЫ от кольца осей: максимум на R_AXIS, гаснет наружу
// и свободно выходит за R_ARC; маска жёстко срезает его по R_AXIS,
// внутрь сетки не попадает ничего (даже размывание).
// Индекс = геометрическое среднее делений: ноль в любом делении обнуляет всё.
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',
};
// порядок «прокачки»: по нему строится полоса делений под буквой ранга
const GRADE_ORDER = ['E', 'D', 'C', 'B', 'A', 'S', 'S+'];
const AXES = GROUPS.flatMap((g) => g.axes);
// ── витрина профилей ──
// Слайды сменяются раз в 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;
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; // зазор между внешним кольцом и текстом домена
// свечение: стартует на кольце осей и гаснет к внешнему краю (и за него)
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;
const clamp = (v) => Math.min(100, Math.max(0, v));
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(' ');
}
// ── спицы и границы делений ОДНИМ путём каждая ──
// В 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(' ');
// ── дозировка трекинга ватермарок (замер + нормализация к 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;
// как слово смотрится на RC без вмешательства:
// тот же линейный аванс на чужом базовом радиусе даёт другой угловой шаг
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;
});
});
// ── витрина: текущий слайд, морфинг полигона, ранг считаем от цели ──
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);
});
const valuePoints = $derived(
ANGLES.map((deg, i) => polar(deg, (R * num(values[i])) / 100).join(',')).join(' ')
);
// среднее по каждому делению — от ЦЕЛЕВОГО профиля, чтобы буква и индекс
// не мигали посреди морфинга
const groupMeans = $derived(
GROUPS.map((_, gi) => Math.round((num(target[gi * 2]) + num(target[gi * 2 + 1])) / 2))
);
// геометрическое среднее делений: провал в одном делении тянет весь индекс
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">
<div class="rank-head">
<h3 class="rank-title">Ранг система</h3>
<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>
{/each}
</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>
{/each}
<!-- жёсткий срез: внутрь кольца осей свечение не заходит совсем -->
<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}
<path
d={sectorPath(arc.from, arc.to, GLOW_IN, GLOW_OUT, arc.sweep)}
fill="url(#bx-glow-grad-{i})"
filter="url(#bx-glow)"
/>
{/each}
</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)">
{#each AXIS_WM as w, i}
<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}
</textPath>
</text>
{/each}
</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"
/>
<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>
{/each}
<!-- значения -->
<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>
</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;
}
/* без собственной рамки: блок живёт прямо в теле карточки */
.rank {
display: flex;
flex-direction: column;
gap: 16px;
min-width: 0;
}
.rank-head {
display: flex;
align-items: center;
gap: 18px;
}
.rank-title {
flex: 1;
min-width: 0;
margin: 0;
font-size: clamp(20px, 2.6vw, 26px);
font-weight: 800;
letter-spacing: 0.12em;
text-transform: uppercase;
color: var(--dim); /* сероватый, как просил */
}
.rank-side {
flex-shrink: 0;
display: flex;
flex-direction: column;
align-items: center;
gap: 3px;
min-width: 104px;
}
.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);
font-size: 44px;
font-weight: 800;
line-height: 1.05;
letter-spacing: 0.02em;
filter: drop-shadow(0 0 12px);
animation: grade-in 0.45s ease;
}
@keyframes grade-in {
from {
opacity: 0;
transform: translateY(5px) scale(0.94);
}
}
/* полоса прокачки: серые деления, текущее светится */
.rank-track {
display: flex;
gap: 5px;
margin-top: 3px;
}
.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;
}
.tick.on {
background: var(--acc);
box-shadow: 0 0 8px rgba(79, 240, 183, 0.8);
}
.rank-avg {
font-family: var(--mono);
font-size: 11px;
color: var(--dim);
}
.radar {
display: block;
width: 100%;
max-width: 460px;
margin: 0 auto;
height: auto;
}
@media (max-width: 560px) {
.rank-head {
flex-direction: column;
align-items: stretch;
gap: 12px;
}
.rank-side {
align-self: center;
}
}
</style>